@aztec/accounts 5.0.0-rc.1 → 5.0.0-rc.2

package/artifacts/SimulatedSchnorrAccount.json

@@ -18,7 +18,77 @@
       "path": "std/aes128.nr",
       "source": "// docs:start:aes128\n/// Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.\npub fn aes128_encrypt<let N: u32>(\n    input: [u8; N],\n    iv: [u8; 16],\n    key: [u8; 16],\n) -> [u8; N + 16 - N % 16] {\n    let padding_length = (16 - N % 16) as u8;\n    let mut padded_input: [u8; N + 16 - N % 16] = [0; N + 16 - N % 16];\n    for i in 0..N {\n        padded_input[i] = input[i];\n    }\n    for i in N..N + 16 - N % 16 {\n        padded_input[i] = padding_length;\n    }\n    let output = aes128_encrypt_padded_input(padded_input, iv, key);\n    output\n}\n\n#[foreign(aes128_encrypt)]\nfn aes128_encrypt_padded_input<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8; N] {}\n\n// docs:end:aes128\n\nmod tests {\n    use super::aes128_encrypt;\n\n    #[test]\n    fn encrypt() {\n        let input = \"kevlovesrust\".as_bytes();\n        let iv = \"0000000000000000\".as_bytes();\n        let key = \"0000000000000000\".as_bytes();\n        let output = [244, 14, 126, 172, 171, 40, 208, 186, 173, 184, 226, 105, 238, 122, 205, 191];\n        assert_eq(aes128_encrypt(input, iv, key), output);\n    }\n}\n"
     },
-    "101": {
+    "100": {
+      "function_locations": [
+        {
+          "name": "log_prefix",
+          "start": 525
+        },
+        {
+          "name": "aztecnr_fatal_log",
+          "start": 717
+        },
+        {
+          "name": "aztecnr_error_log",
+          "start": 943
+        },
+        {
+          "name": "aztecnr_warn_log",
+          "start": 1168
+        },
+        {
+          "name": "aztecnr_info_log",
+          "start": 1392
+        },
+        {
+          "name": "aztecnr_verbose_log",
+          "start": 1619
+        },
+        {
+          "name": "aztecnr_debug_log",
+          "start": 1847
+        },
+        {
+          "name": "aztecnr_trace_log",
+          "start": 2073
+        },
+        {
+          "name": "aztecnr_fatal_log_format",
+          "start": 2367
+        },
+        {
+          "name": "aztecnr_error_log_format",
+          "start": 2622
+        },
+        {
+          "name": "aztecnr_warn_log_format",
+          "start": 2876
+        },
+        {
+          "name": "aztecnr_info_log_format",
+          "start": 3129
+        },
+        {
+          "name": "aztecnr_verbose_log_format",
+          "start": 3385
+        },
+        {
+          "name": "aztecnr_debug_log_format",
+          "start": 3642
+        },
+        {
+          "name": "aztecnr_trace_log_format",
+          "start": 3897
+        },
+        {
+          "name": "resolve_fn",
+          "start": 4151
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/logging.nr",
+      "source": "// Not all log levels are currently used, but we provide the full set so that new call sites can use any level. Because\n// of that we tag all with `#[allow(dead_code)]` to prevent warnings.\n//\n// All wrappers resolve function paths at comptime via `resolve_fn` so that the emitted `Quoted` code works both inside\n// aztec-nr (where `crate::` = aztec) and inside macro-generated contract code (where `crate::` = the contract).\n\nuse std::meta::ctstring::AsCtString;\n\ncomptime fn log_prefix<let N: u32>(msg: str<N>) -> CtString {\n    \"[aztec-nr] \".as_ctstring().append_str(msg)\n}\n\n// --- No-args variants (direct call) ---\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_fatal_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::fatal_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_error_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::error_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_warn_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::warn_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_info_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::info_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_verbose_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::verbose_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_debug_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::debug_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_trace_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::trace_log });\n    quote { $f($msg) }\n}\n\n// --- Format variants (return lambda for runtime args) ---\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_fatal_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::fatal_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_error_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::error_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_warn_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::warn_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_info_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::info_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_verbose_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::verbose_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_debug_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::debug_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_trace_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::trace_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n// See module-level comment for why this is needed.\ncomptime fn resolve_fn(path: Quoted) -> TypedExpr {\n    path.as_expr().unwrap().resolve(Option::none())\n}\n"
+    },
+    "102": {
       "function_locations": [
         {
           "name": "generate_contract_library_methods_compute_note_hash_and_nullifier",
@@ -36,7 +106,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec/compute_note_hash_and_nullifier.nr",
       "source": "use crate::logging;\nuse crate::macros::{notes::NOTES, utils::get_trait_impl_method};\n\n/// Generates two contract library methods called `_compute_note_hash` and `_compute_note_nullifier`, plus a\n/// (deprecated) wrapper called `_compute_note_hash_and_nullifier`, which are used for note discovery (i.e. these are\n/// of the `aztec::messages::discovery::ComputeNoteHash` and `aztec::messages::discovery::ComputeNoteNullifier` types).\npub(crate) comptime fn generate_contract_library_methods_compute_note_hash_and_nullifier() -> Quoted {\n    let compute_note_hash = generate_contract_library_method_compute_note_hash();\n    let compute_note_nullifier = generate_contract_library_method_compute_note_nullifier();\n\n    quote {\n        $compute_note_hash\n        $compute_note_nullifier\n\n        /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash tree with `note_nonce`.\n        ///\n        /// This function is automatically injected by the `#[aztec]` macro.\n        #[contract_library_method]\n        #[allow(dead_code)]\n        unconstrained fn _compute_note_hash_and_nullifier(\n            packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n            owner: aztec::protocol::address::AztecAddress,\n            storage_slot: Field,\n            note_type_id: Field,\n            contract_address: aztec::protocol::address::AztecAddress,\n            randomness: Field,\n            note_nonce: Field,\n        ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n            _compute_note_hash(packed_note, owner, storage_slot, note_type_id, contract_address, randomness).map(|note_hash| {\n\n                let siloed_note_hash = aztec::protocol::hash::compute_siloed_note_hash(contract_address, note_hash);\n                let unique_note_hash = aztec::protocol::hash::compute_unique_note_hash(note_nonce, siloed_note_hash);\n                \n                let inner_nullifier = _compute_note_nullifier(unique_note_hash, packed_note, owner, storage_slot, note_type_id, contract_address, randomness);\n\n                aztec::messages::discovery::NoteHashAndNullifier {\n                    note_hash,\n                    inner_nullifier,\n                }\n            })\n        }\n    }\n}\n\ncomptime fn generate_contract_library_method_compute_note_hash() -> Quoted {\n    if NOTES.len() == 0 {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash(\n                _packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                _owner: aztec::protocol::address::AztecAddress,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                _randomness: Field,\n            ) -> Option<Field> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    } else {\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call the correct `unpack` method from the `Packable` trait to obtain the underlying\n        // note type, and compute the note hash (non-siloed).\n\n        // We resolve the log format calls here so that the resulting Quoted values can be spliced into the quote\n        // block below.\n        let warn_length_mismatch = logging::aztecnr_warn_log_format(\n            \"Packed note length mismatch for note type id {0}: expected {1} fields, got {2}. Skipping note.\",\n        );\n        let warn_unknown_note_type = logging::aztecnr_warn_log_format(\"Unknown note type id {0}. Skipping note.\");\n\n        let mut if_note_type_id_match_statements_list = @[];\n        for i in 0..NOTES.len() {\n            let typ = NOTES.get(i);\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol::traits::Packable },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret its raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = <$typ as $crate::protocol::traits::Packable>::N;\n                        let actual_len = packed_note.len();\n                        if actual_len != expected_len {\n                            $warn_length_mismatch([note_type_id, expected_len as Field, actual_len as Field]);\n                            Option::none()\n                        } else {\n                            let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                            Option::some($compute_note_hash(note, owner, storage_slot, randomness))\n                        }\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed).\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHash` type,\n            /// and so it can be used to call functions from that module such as `do_sync_state` and\n            /// `process_private_note_msg`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash(\n                packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                owner: aztec::protocol::address::AztecAddress,\n                storage_slot: Field,\n                note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                randomness: Field,\n            ) -> Option<Field> {\n                $if_note_type_id_match_statements\n                else {\n                    $warn_unknown_note_type([note_type_id]);\n                    Option::none()\n                }\n            }\n        }\n    }\n}\n\ncomptime fn generate_contract_library_method_compute_note_nullifier() -> Quoted {\n    if NOTES.len() == 0 {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_nullifier(\n                _unique_note_hash: Field,\n                _packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                _owner: aztec::protocol::address::AztecAddress,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                _randomness: Field,\n            ) -> Option<Field> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    } else {\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call the correct `unpack` method from the `Packable` trait to obtain the underlying\n        // note type, and compute the inner nullifier (non-siloed).\n\n        // We resolve the log format calls here so that the resulting Quoted values can be spliced into the quote\n        // block below.\n        let warn_length_mismatch = logging::aztecnr_warn_log_format(\n            \"Packed note length mismatch for note type id {0}: expected {1} fields, got {2}. Skipping note.\",\n        );\n        let warn_unknown_note_type = logging::aztecnr_warn_log_format(\"Unknown note type id {0}. Skipping note.\");\n\n        let mut if_note_type_id_match_statements_list = @[];\n        for i in 0..NOTES.len() {\n            let typ = NOTES.get(i);\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol::traits::Packable },\n                quote { unpack },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret its raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = <$typ as $crate::protocol::traits::Packable>::N;\n                        let actual_len = packed_note.len();\n                        if actual_len != expected_len {\n                            $warn_length_mismatch([note_type_id, expected_len as Field, actual_len as Field]);\n                            Option::none()\n                        } else {\n                            let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                            // The message discovery process finds settled notes, that is, notes that were created in\n                            // prior transactions and are therefore already part of the note hash tree. The note hash\n                            // for nullification is hence the unique note hash.\n                            $compute_nullifier_unconstrained(note, owner, unique_note_hash)\n                        }\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Computes a note's inner nullifier (non-siloed) given its unique note hash, preimage and extra data.\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteNullifier`\n            /// type, and so it can be used to call functions from that module such as `do_sync_state` and\n            /// `process_private_note_msg`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_nullifier(\n                unique_note_hash: Field,\n                packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                owner: aztec::protocol::address::AztecAddress,\n                _storage_slot: Field,\n                note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                _randomness: Field,\n            ) -> Option<Field> {\n                $if_note_type_id_match_statements\n                else {\n                    $warn_unknown_note_type([note_type_id]);\n                    Option::none()\n                }\n            }\n        }\n    }\n}\n"
     },
-    "102": {
+    "103": {
       "function_locations": [
         {
           "name": "AztecConfig::new",
@@ -74,7 +144,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
       "source": "mod compute_note_hash_and_nullifier;\n\nuse crate::{\n    macros::{\n        calls_generation::{\n            external_functions::{generate_external_function_calls, generate_external_function_self_calls_structs},\n            internal_functions::generate_call_internal_struct,\n        },\n        dispatch::generate_public_dispatch,\n        emit_public_init_nullifier::generate_emit_public_init_nullifier,\n        internals_functions_generation::{create_fn_abi_exports, process_functions},\n        offchain_receive::{\n            OFFCHAIN_RECEIVE_FN_NAME, OFFCHAIN_RECEIVE_PARAM_NAME, offchain_receive_param_type,\n            OFFCHAIN_RECEIVE_RETURN_TYPE,\n        },\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{is_fn_contract_library_method, is_fn_external, is_fn_internal, is_fn_test, module_has_storage},\n    },\n    messages::discovery::{CustomMessageHandler, CustomSyncHandler},\n};\n\nuse compute_note_hash_and_nullifier::generate_contract_library_methods_compute_note_hash_and_nullifier;\n\n/// Configuration for the [`aztec`] macro.\n///\n/// This type lets users override different parts of the default aztec-nr contract behavior, such\n/// as message handling and state synchronization. These are advanced features that require careful\n/// understanding of the behavior of these systems.\n///\n/// ## Examples\n///\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyContract { ... }\n/// ```\npub struct AztecConfig {\n    custom_message_handler: Option<CustomMessageHandler>,\n    custom_sync_state: Option<CustomSyncHandler>,\n}\n\nimpl AztecConfig {\n    /// Creates a new `AztecConfig` with default values.\n    ///\n    /// Calling `new` is equivalent to invoking the [`aztec`] macro with no parameters. The different methods\n    /// (e.g. [`AztecConfig::custom_message_handler`]) can then be used to change the default behavior.\n    pub comptime fn new() -> Self {\n        Self { custom_message_handler: Option::none(), custom_sync_state: Option::none() }\n    }\n\n    /// Sets a handler for custom messages.\n    ///\n    /// This enables contracts to process non-standard messages (i.e. any with a message type that is not in\n    /// [`crate::messages::msg_type`]).\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomMessageHandler`] type signature.\n    pub comptime fn custom_message_handler(&mut self, handler: CustomMessageHandler) -> Self {\n        self.custom_message_handler = Option::some(handler);\n        *self\n    }\n\n    /// Overrides the default state synchronization logic.\n    ///\n    /// The generated `sync_state` function will call `handler` instead of\n    /// [`crate::messages::discovery::do_sync_state`]. The handler receives all of the same parameters, so it can\n    /// run custom logic (e.g. fetching and decrypting custom logs) before, after, or instead of calling\n    /// `do_sync_state`.\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomSyncHandler`] type signature.\n    pub comptime fn custom_sync_state(&mut self, handler: CustomSyncHandler) -> Self {\n        self.custom_sync_state = Option::some(handler);\n        *self\n    }\n}\n\n/// Enables aztec-nr features on a `contract`.\n///\n/// All aztec-nr contracts should have this macro invoked on them, as it is the one that processes all contract\n/// functions, notes, storage, generates interfaces for external calls, and creates the message processing\n/// boilerplate.\n///\n/// ## Examples\n///\n/// Most contracts can simply invoke the macro with no parameters, resulting in default aztec-nr behavior:\n/// ```noir\n/// #[aztec]\n/// contract MyContract { ... }\n/// ```\n///\n/// Advanced contracts can use [`AztecConfig`] to customize parts of its behavior, such as message\n/// processing.\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyAdvancedContract { ... }\n/// ```\n#[varargs]\npub comptime fn aztec(m: Module, args: [AztecConfig]) -> Quoted {\n    let num_args = args.len();\n    let config = if num_args == 0 {\n        AztecConfig::new()\n    } else if num_args == 1 {\n        args[0]\n    } else {\n        panic(f\"#[aztec] expects 0 or 1 arguments, got {num_args}\")\n    };\n\n    // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n    check_each_fn_macroified(m);\n\n    // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n    // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n    let functions = process_functions(m);\n\n    // We generate structs and their implementations necessary for convenient functions calls.\n    let interface = generate_contract_interface(m);\n    let self_call_structs = generate_external_function_self_calls_structs(m);\n    let call_internal_struct = generate_call_internal_struct(m);\n\n    // We generate ABI exports for all the external functions in the contract.\n    let fn_abi_exports = create_fn_abi_exports(m);\n\n    // We generate `_compute_note_hash`, `_compute_note_nullifier` (and the deprecated\n    // `_compute_note_hash_and_nullifier` wrapper) only if they are not already implemented.\n    // If they are implemented we just insert empty quotes.\n    let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n        // Note that we don't test for `_compute_note_hash` or `_compute_note_nullifier` in order to make this simpler\n        // - users must either implement all three or none.\n        // Down the line we'll remove this check and use `AztecConfig`.\n        f.name() == quote { _compute_note_hash_and_nullifier }\n    }) {\n        generate_contract_library_methods_compute_note_hash_and_nullifier()\n    } else {\n        quote {}\n    };\n    let process_custom_message_option = if config.custom_message_handler.is_some() {\n        let handler = config.custom_message_handler.unwrap();\n        quote { Option::some($handler) }\n    } else {\n        quote { Option::<aztec::messages::discovery::CustomMessageHandler>::none() }\n    };\n\n    let offchain_inbox_sync_option = quote {\n        Option::some(aztec::messages::processing::offchain::sync_inbox)\n    };\n\n    if m.functions().any(|f| f.name() == quote { sync_state }) {\n        panic(\n            \"User-defined 'sync_state' is not allowed. Use AztecConfig::custom_sync_state() to customize sync behavior.\",\n        );\n    }\n\n    let custom_sync_handler = if config.custom_sync_state.is_some() {\n        let handler = config.custom_sync_state.unwrap();\n        Option::some(quote { $handler })\n    } else {\n        Option::none()\n    };\n\n    let sync_state_fn_and_abi_export = generate_sync_state(\n        process_custom_message_option,\n        offchain_inbox_sync_option,\n        custom_sync_handler,\n    );\n\n    if m.functions().any(|f| f.name() == quote { offchain_receive }) {\n        panic(\n            \"User-defined 'offchain_receive' is not allowed. The function is auto-injected by the #[aztec] macro. See https://docs.aztec.network/errors/7\",\n        );\n    }\n    let offchain_receive_fn_and_abi_export = generate_offchain_receive();\n\n    let (has_public_init_nullifier_fn, emit_public_init_nullifier_fn_body) = generate_emit_public_init_nullifier(m);\n    let public_dispatch = generate_public_dispatch(m, has_public_init_nullifier_fn);\n\n    quote {\n        $interface\n        $self_call_structs\n        $call_internal_struct\n        $functions\n        $fn_abi_exports\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_state_fn_and_abi_export\n        $emit_public_init_nullifier_fn_body\n        $offchain_receive_fn_and_abi_export\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let calls = generate_external_function_calls(m);\n\n    let module_name = m.name();\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: aztec::protocol::address::AztecAddress\n        }\n\n        impl $module_name {\n            $calls\n\n            pub fn at(\n                addr: aztec::protocol::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates the `sync_state` utility function that performs message discovery.\ncomptime fn generate_sync_state(\n    process_custom_message_option: Quoted,\n    offchain_inbox_sync_option: Quoted,\n    custom_sync_handler: Option<Quoted>,\n) -> Quoted {\n    let body = if custom_sync_handler.is_some() {\n        let handler = custom_sync_handler.unwrap();\n        quote {\n            $handler(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    } else {\n        quote {\n            aztec::messages::discovery::do_sync_state(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    };\n\n    quote {\n        pub struct sync_state_parameters {\n            pub scope: aztec::protocol::address::AztecAddress,\n        }\n\n        #[abi(functions)]\n        pub struct sync_state_abi {\n            parameters: sync_state_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn sync_state(scope: aztec::protocol::address::AztecAddress) {\n            let address = aztec::context::UtilityContext::new().this_address();\n            $body\n        }\n    }\n}\n\n/// Generates an `offchain_receive` utility function that lets callers add messages to the offchain message inbox.\n///\n/// For more details, see `aztec::messages::processing::offchain::receive`.\ncomptime fn generate_offchain_receive() -> Quoted {\n    let param_type = offchain_receive_param_type(quote { aztec });\n    let parameters_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_parameters\".quoted_contents();\n    let abi_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_abi\".quoted_contents();\n\n    quote {\n        pub struct $parameters_struct_name {\n            pub $OFFCHAIN_RECEIVE_PARAM_NAME: $param_type,\n        }\n\n        #[abi(functions)]\n        pub struct $abi_struct_name {\n            parameters: $parameters_struct_name,\n        }\n\n        /// Receives offchain messages into this contract's offchain inbox for subsequent processing.\n        ///\n        /// Each message is routed to the inbox scoped to its `recipient` field.\n        ///\n        /// For more details, see `aztec::messages::processing::offchain::receive`.\n        ///\n        /// This function is automatically injected by the `#[aztec]` macro.\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn $OFFCHAIN_RECEIVE_FN_NAME($OFFCHAIN_RECEIVE_PARAM_NAME: $param_type) -> $OFFCHAIN_RECEIVE_RETURN_TYPE {\n            let address = aztec::context::UtilityContext::new().this_address();\n            aztec::messages::processing::offchain::receive(address, $OFFCHAIN_RECEIVE_PARAM_NAME);\n        }\n    }\n}\n\n/// Checks that all functions in the module have a context macro applied.\n///\n/// Non-macroified functions are not allowed in contracts. They must all be one of\n/// [`crate::macros::functions::external`], [`crate::macros::functions::internal`] or `test`.\ncomptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_external(f) & !is_fn_contract_library_method(f) & !is_fn_internal(f) & !is_fn_test(f) {\n            // We  don't suggest that #[contract_library_method] is allowed because we don't want to introduce another\n            // concept\n            panic(\n                f\"Function {name} must be marked as either #[external(...)], #[internal(...)], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
-    "117": {
+    "118": {
       "function_locations": [
         {
           "name": "generate_private_external",
@@ -84,7 +154,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/private.nr",
       "source": "use crate::macros::{\n    functions::initialization_utils::has_public_init_checked_functions,\n    internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},\n    utils::{\n        fn_has_allow_phase_change, fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self,\n        is_fn_view, module_has_initializer, module_has_storage,\n    },\n};\nuse crate::protocol::meta::utils::derive_serialization_quotes;\nuse std::meta::type_of;\n\npub(crate) comptime fn generate_private_external(f: FunctionDefinition) -> Quoted {\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to\n    // the Private Kernel Circuit. First we change the function signature so that it also receives\n    // `PrivateContextInputs`, which contain information about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n\n    let original_params_quotes =\n        original_params.map(|(param_name, param_type)| quote { $param_name: $param_type }).join(quote {, });\n\n    let params = quote { inputs: aztec::context::inputs::PrivateContextInputs, $original_params_quotes };\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    let (args_serialization, _, serialized_args_name) = derive_serialization_quotes(original_params, false);\n\n    let storage_init = if module_has_storage {\n        // Contract has Storage defined so we initialize it.\n        quote {\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelfPrivate\n        // requires a storage struct in its constructor. Using an Option type would lead to worse developer experience\n        // and higher constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            $args_serialization\n            let args_hash = aztec::hash::hash_args($serialized_args_name);\n            let mut context = aztec::context::PrivateContext::new(inputs, args_hash);\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<&mut aztec::context::PrivateContext> = CallSelf { address: self_address, context: &mut context };\n            let enqueue_self: EnqueueSelf<&mut aztec::context::PrivateContext> = EnqueueSelf { address: self_address, context: &mut context };\n            let call_self_static: CallSelfStatic<&mut aztec::context::PrivateContext> = CallSelfStatic { address: self_address, context: &mut context };\n            let enqueue_self_static: EnqueueSelfStatic<&mut aztec::context::PrivateContext> = EnqueueSelfStatic { address: self_address, context: &mut context };\n            let internal: CallInternal<&mut aztec::context::PrivateContext> = CallInternal { context: &mut context };\n            let call_self_utility = CallSelfUtility { address: self_address };\n            let utility: aztec::contract_self::PrivateUtilityCalls<CallSelfUtility> = aztec::contract_self::PrivateUtilityCalls { call_self: call_self_utility };\n            aztec::contract_self::ContractSelfPrivate::new(&mut context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal, utility)\n        };\n    };\n\n    let original_function_name = f.name();\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_only_self(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called by the same contract\";\n        quote { assert(self.msg_sender() == self.address, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called statically\".as_quoted_str();\n        quote { assert(self.context.inputs.call_context.is_static_call, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        let has_public_fns_with_init_check = has_public_init_checked_functions(f.module());\n        (\n            quote {\n                aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_private(*self.context);\n            },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_from_private_initializer(self.context, $has_public_fns_with_init_check); },\n        )\n    } else {\n        (quote {}, quote {})\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_private(self.context); }\n    } else {\n        quote {}\n    };\n\n    // Phase checks are skipped in functions that request to manually handle phases\n    let initial_phase_store = if fn_has_allow_phase_change(f) {\n        quote {}\n    } else {\n        quote { let within_revertible_phase: bool = self.context.in_revertible_phase(); }\n    };\n\n    let no_phase_change_check = if fn_has_allow_phase_change(f) {\n        quote {}\n    } else {\n        quote {\n            assert_eq(\n                within_revertible_phase,\n                self.context.in_revertible_phase(),\n                f\"Phase change detected on function with phase check. If this is expected, use #[allow_phase_change]\",\n            );\n        }\n    };\n\n    // Inject the authwit check if the function is marked with #[authorize_once].\n    let authorize_once_check = if fn_has_authorize_once(f) {\n        create_authorize_once_check(f, true)\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is serialized and hashed before being passed to the context.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment = quote { let $return_value_var_name: $return_value_type = $return_value; };\n\n        let (return_serialization, _, serialized_return_name) =\n            derive_serialization_quotes([(return_value_var_name, return_value_type)], false);\n\n        body = body_without_return;\n\n        quote {\n            $return_value_assignment\n            $return_serialization\n            self.context.set_return_hash($serialized_return_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(quote { let $unused_return_value_name = $last_body_expr; }\n                .as_expr()\n                .unwrap());\n        }\n        quote {}\n    };\n\n    let context_finish = quote { self.context.finish() };\n\n    // Preserve all attributes that are relevant to the function's ABI.\n    let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n\n    let to_prepend = quote {\n        aztec::oracle::version::assert_compatible_oracle_version();\n        $contract_self_creation\n        $initial_phase_store\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $authorize_once_check\n    };\n\n    let body_quote = body.map(|expr| expr.quoted()).join(quote { });\n\n    // `mark_as_initialized` is placed after the user's function body. If it ran at the beginning, the contract\n    // would appear initialized while the initializer is still running, allowing contracts called by the initializer\n    // to re-enter into a half-initialized contract.\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $no_phase_change_check\n        $context_finish\n    };\n\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n        $abi_relevant_attributes\n        fn $fn_name($params) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n            $to_prepend\n            $body_quote\n            $to_append\n        }\n    }\n}\n"
     },
-    "125": {
+    "126": {
       "function_locations": [
         {
           "name": "get_next_note_type_id",
@@ -118,111 +188,37 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/notes.nr",
       "source": "use crate::note::note_getter_options::PropertySelector;\nuse std::{collections::bounded_vec::BoundedVec, meta::type_of};\n\n/// Maximum number of note types within 1 contract.\ncomptime global MAX_NOTE_TYPES: u32 = 128;\n\n/// A BoundedVec containing all the note types within this contract.\npub comptime mut global NOTES: BoundedVec<Type, MAX_NOTE_TYPES> = BoundedVec::new();\n\ncomptime mut global NOTE_TYPE_ID_COUNTER: u32 = 0;\n\n/// The note type id is set by enumerating the note types.\ncomptime fn get_next_note_type_id() -> Field {\n    // We assert that the note type id fits within 7 bits\n    assert(\n        NOTE_TYPE_ID_COUNTER < MAX_NOTE_TYPES,\n        f\"A contract can contain at most {MAX_NOTE_TYPES} different note types\",\n    );\n\n    let note_type_id = NOTE_TYPE_ID_COUNTER as Field;\n    NOTE_TYPE_ID_COUNTER += 1;\n    note_type_id\n}\n\n/// Generates default `NoteType` implementation for a given note struct `s` and returns it as a quote.\n///\n/// ```noir\n/// impl NoteType for NoteStruct {\n///     fn get_id() -> Field {\n///         ...\n///     }\n/// }\n/// ```\ncomptime fn generate_note_type_impl(s: TypeDefinition, note_type_id: Field) -> Quoted {\n    let name = s.name();\n    let typ = s.as_type();\n    let note_type_name: str<_> = f\"{name}\".as_quoted_str!();\n    let max_note_packed_len = crate::messages::logs::note::MAX_NOTE_PACKED_LEN;\n\n    quote {\n        impl aztec::note::note_interface::NoteType for $name {\n            fn get_id() -> Field {\n                // This static assertion ensures the note's packed length doesn't exceed the maximum allowed size.\n                // While this check would ideally live in the Packable trait implementation, we place it here since\n                // this function is always generated by our macros and the Packable trait implementation is not.\n                //\n                // Note: We set the note type name and max packed length as local variables because injecting them\n                // directly into the error message doesn't work.\n                let note_type_name = $note_type_name;\n                let max_note_packed_len: u32 = $max_note_packed_len; // Casting to u32 to avoid the value to be printed in hex.\n                let note_packed_len = <$typ as aztec::protocol::traits::Packable>::N;\n                std::static_assert(note_packed_len <= $max_note_packed_len, f\"{note_type_name} has a packed length of {note_packed_len} fields, which exceeds the maximum allowed length of {max_note_packed_len} fields. See https://docs.aztec.network/errors/4\");\n\n                $note_type_id\n            }\n        }\n    }\n}\n\n/// Generates default `NoteHash` trait implementation for a given note struct `s` and returns it as a quote.\n///\n/// # Generated Implementation\n///\n/// ```noir\n/// impl NoteHash for NoteStruct {\n///     fn compute_note_hash(self, owner: AztecAddress, storage_slot: Field, randomness: Field) -> Field { ... }\n///\n///     fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullification: Field, owner:\n/// AztecAddress) -> Field { ... }\n///\n///     unconstrained fn compute_nullifier_unconstrained(note_hash_for_nullification: Field, owner: AztecAddress) ->\n/// Field { ... }\n/// }\n/// ```\ncomptime fn generate_note_hash_trait_impl(s: TypeDefinition) -> Quoted {\n    let name = s.name();\n\n    quote {\n        impl aztec::note::note_interface::NoteHash for $name {\n            fn compute_note_hash(self, owner: aztec::protocol::address::AztecAddress, storage_slot: Field, randomness: Field) -> Field {\n                let data = aztec::protocol::traits::Packable::pack(self).concat([aztec::protocol::traits::ToField::to_field(owner), randomness]);\n                aztec::note::utils::compute_note_hash(storage_slot, data)\n            }\n\n            fn compute_nullifier(\n                self,\n                context: &mut aztec::context::PrivateContext,\n                owner: aztec::protocol::address::AztecAddress,\n                note_hash_for_nullification: Field,\n            ) -> Field {\n                let owner_npk_m_hash = aztec::keys::getters::get_public_keys(owner).npk_m_hash;\n                let secret = context.request_nhk_app(owner_npk_m_hash);\n                aztec::note::utils::compute_note_nullifier(note_hash_for_nullification, [secret])\n            }\n\n            unconstrained fn compute_nullifier_unconstrained(\n                self,\n                owner: aztec::protocol::address::AztecAddress,\n                note_hash_for_nullification: Field,\n            ) -> Option<Field> {\n                // Note: In the current PXE implementation, if public keys are available then the nullifier\n                // hiding key (nhk) is also available, so we don't need to handle get_nhk_app potentially\n                // failing. The Option is only needed for the try_get_public_keys call.\n                aztec::keys::getters::try_get_public_keys(owner).map(|public_keys| {\n                    let owner_npk_m_hash = public_keys.npk_m_hash;\n                    let secret = aztec::keys::getters::get_nhk_app(owner_npk_m_hash);\n                    aztec::note::utils::compute_note_nullifier(note_hash_for_nullification, [secret])\n                })\n            }\n        }\n    }\n}\n\n/// Generates note properties struct for a given note struct `s`.\n///\n/// Example:\n/// ```\n/// struct TokenNoteProperties {\n///     amount: aztec::note::note_getter_options::PropertySelector,\n///     npk_m_hash: aztec::note::note_getter_options::PropertySelector\n///     randomness: aztec::note::note_getter_options::PropertySelector\n/// }\n///\n/// impl aztec::note::note_interface::NoteProperties<TokenNoteProperties> for TokenNote {\n///     fn properties() -> TokenNoteProperties {\n///         Self {\n///             amount: aztec::note::note_getter_options::PropertySelector { index: 0, offset: 0, length: 32 },\n///             npk_m_hash: aztec::note::note_getter_options::PropertySelector { index: 1, offset: 0, length: 32 },\n///             randomness: aztec::note::note_getter_options::PropertySelector { index: 2, offset: 0, length: 32 }\n///         }\n///     }\n/// }\n/// ```\ncomptime fn generate_note_properties(s: TypeDefinition) -> Quoted {\n    let name = s.name();\n\n    let struct_name = f\"{name}Properties\".quoted_contents();\n\n    let property_selector_type = type_of(PropertySelector { index: 0, offset: 0, length: 0 });\n\n    let note_fields = s.fields_as_written();\n\n    let properties_types = note_fields.map(|(name, _, _)| quote { pub $name: $property_selector_type }).join(quote {,});\n\n    // TODO #8694: Properly handle non-field types https://github.com/AztecProtocol/aztec-packages/issues/8694\n    let mut properties_list = @[];\n    for i in 0..note_fields.len() {\n        let (name, _, _) = note_fields[i];\n        let i = i as u8;\n        properties_list = properties_list.push_back(\n            quote { $name: aztec::note::note_getter_options::PropertySelector { index: $i, offset: 0, length: 32 } },\n        );\n    }\n\n    let properties = properties_list.join(quote {,});\n\n    quote {\n        pub struct $struct_name {\n            $properties_types\n        }\n\n        impl aztec::note::note_interface::NoteProperties<$struct_name> for $name {\n            fn properties() -> $struct_name {\n                $struct_name {\n                    $properties\n                }\n            }\n        }\n    }\n}\n\n/// Generates the core note functionality for a struct:\n///\n/// - NoteTypeProperties: Defines the structure and properties of note fields\n/// - NoteType trait implementation: Provides the note type ID\n/// - NoteHash trait implementation: Handles note hash and nullifier computation\n///\n/// # Requirements\n///\n/// The note struct must:\n/// - Implement the `Packable` trait\n/// - Not exceed `MAX_NOTE_PACKED_LEN` when packed\n///\n/// # Registration\n///\n/// Registers the note in the global `NOTES` BoundedVec to enable note processing functionality.\n///\n/// # Generated Code\n///\n/// For detailed documentation on the generated implementations, see:\n/// - `generate_note_properties()`\n/// - `generate_note_type_impl()`\n/// - `generate_note_hash_trait_impl()`\npub comptime fn note(s: TypeDefinition) -> Quoted {\n    assert_has_packable(s);\n\n    // We register the note in the global `NOTES` BoundedVec because we need that information inside the #[aztec] macro\n    // to generate note processing functionality.\n    NOTES.push(s.as_type());\n\n    let note_properties = generate_note_properties(s);\n    let note_type_id = get_next_note_type_id();\n    let note_type_impl = generate_note_type_impl(s, note_type_id);\n    let note_hash_impl = generate_note_hash_trait_impl(s);\n\n    quote {\n        $note_properties\n        $note_type_impl\n        $note_hash_impl\n    }\n}\n\n/// Generates code for a custom note implementation that requires specialized note hash or nullifier computation.\n///\n/// # Generated Code\n/// - NoteTypeProperties: Defines the structure and properties of note fields\n/// - NoteType trait implementation: Provides the note type ID\n///\n/// # Requirements\n///\n/// The note struct must:\n/// - Implement the `Packable` trait\n/// - Not exceed `MAX_NOTE_PACKED_LEN` when packed\n///\n/// # Registration\n///\n/// Registers the note in the global `NOTES` BoundedVec to enable note processing functionality.\n///\n/// # Use Cases\n///\n/// Use this macro when implementing a note that needs custom:\n/// - Note hash computation logic\n/// - Nullifier computation logic\n///\n/// The macro omits generating default NoteHash trait implementation, allowing you to provide your own.\n///\n/// # Example\n/// ```\n/// #[custom_note]\n/// struct CustomNote {\n///     value: Field,\n///     metadata: Field\n/// }\n///\n/// impl NoteHash for CustomNote {\n///     // Custom note hash computation...\n///     fn compute_note_hash(...) -> Field { ... }\n///\n///     // Custom nullifier computation...\n///     fn compute_nullifier(...) -> Field { ... }\n///     fn compute_nullifier_unconstrained(...) -> Field { ... }\n/// }\n/// ```\npub comptime fn custom_note(s: TypeDefinition) -> Quoted {\n    assert_has_packable(s);\n\n    // We register the note in the global `NOTES` BoundedVec because we need that information inside the #[aztec] macro\n    // to generate note processing functionality.\n    NOTES.push(s.as_type());\n\n    let note_type_id = get_next_note_type_id();\n    let note_properties = generate_note_properties(s);\n    let note_type_impl = generate_note_type_impl(s, note_type_id);\n\n    quote {\n        $note_properties\n        $note_type_impl\n    }\n}\n\n/// Asserts that the given note implements the [`Packable`](crate::protocol::traits::Packable) trait.\n///\n/// We require that notes have the `Packable` trait implemented because it is used when emitting a note in a log or as\n/// an offchain message.\ncomptime fn assert_has_packable(note: TypeDefinition) {\n    let packable_constraint = quote { crate::protocol::traits::Packable }.as_trait_constraint();\n    let note_name = note.name();\n\n    assert(\n        note.as_type().implements(packable_constraint),\n        f\"{note_name} does not implement Packable trait. Either implement it manually or place #[derive(Packable)] on the note struct before #[note] macro invocation.\",\n    );\n}\n"
     },
-    "131": {
+    "133": {
       "function_locations": [
+        {
+          "name": "get_or_create_app_siloed_handshake_secret",
+          "start": 3104
+        },
         {
           "name": "get_handshake_secrets",
-          "start": 1874
+          "start": 5041
         },
         {
           "name": "fetch_handshake_page",
-          "start": 3089
+          "start": 6346
         },
         {
           "name": "test::get_handshake_secrets_returns_secrets_from_single_page",
-          "start": 4146
+          "start": 7180
         },
         {
           "name": "test::get_handshake_secrets_fetches_multiple_pages",
-          "start": 5488
+          "start": 8827
         },
         {
           "name": "test::mock_get_shared_secrets",
-          "start": 7347
+          "start": 11128
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/delivery/handshake.nr",
-      "source": "use crate::messages::delivery::OnchainDeliveryMode;\nuse crate::protocol::point::EmbeddedCurvePoint;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    messages::processing::provided_secret::ProvidedSecret,\n    oracle::{call_utility_function::call_utility_function, shared_secret::get_shared_secrets},\n    protocol::{\n        abis::function_selector::FunctionSelector, address::AztecAddress, hash::sha256_to_field, traits::ToField,\n    },\n    standard_addresses::STANDARD_HANDSHAKE_REGISTRY_ADDRESS,\n};\n\n/// Page size for handshake discovery pagination.\npub global MAX_HANDSHAKES_PER_PAGE: u32 = 32;\n\n/// A handshake discovered during sync: the sender's ephemeral public key and the delivery mode.\n#[derive(Deserialize, Eq, Serialize)]\npub struct DiscoveredHandshake {\n    pub eph_pk: EmbeddedCurvePoint,\n    pub mode: OnchainDeliveryMode,\n}\n\n/// A paginated response of discovered handshakes.\n#[derive(Deserialize, Serialize)]\npub struct HandshakePage {\n    pub items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE>,\n    pub total_count: u32,\n}\n\npub(crate) global PROVIDED_SECRETS_ARRAY_BASE_SLOT: Field =\n    sha256_to_field(\"AZTEC_NR::PROVIDED_SECRETS_ARRAY_BASE_SLOT\".as_bytes());\n\nglobal HANDSHAKE_EPH_PKS_SLOT: Field = sha256_to_field(\"AZTEC_NR::HANDSHAKE_EPH_PKS_SLOT\".as_bytes());\n\nglobal HANDSHAKE_MODES_SLOT: Field = sha256_to_field(\"AZTEC_NR::HANDSHAKE_MODES_SLOT\".as_bytes());\n\n/// Fetches discovered handshakes from the HandshakeRegistry and derives app-siloed tagging secrets for each,\n/// returning them so that [`get_pending_tagged_logs`](crate::oracle::message_processing::get_pending_tagged_logs)\n/// searches for logs tagged with these secrets.\npub(crate) unconstrained fn get_handshake_secrets(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<ProvidedSecret> {\n    let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);\n\n    let eph_pks: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(HANDSHAKE_EPH_PKS_SLOT);\n    let modes: EphemeralArray<OnchainDeliveryMode> = EphemeralArray::empty_at(HANDSHAKE_MODES_SLOT);\n\n    let mut page_offset: u32 = 0;\n    let mut has_more = true;\n    while has_more {\n        let page = fetch_handshake_page(scope, page_offset);\n\n        for j in 0..page.items.len() {\n            let handshake = page.items.get(j);\n            eph_pks.push(handshake.eph_pk);\n            modes.push(handshake.mode);\n        }\n\n        page_offset += page.items.len();\n        has_more = page_offset < page.total_count;\n    }\n\n    if eph_pks.len() > 0 {\n        let secrets = get_shared_secrets(scope, eph_pks, contract_address);\n        for j in 0..secrets.len() {\n            provided_secrets.push(ProvidedSecret { secret: secrets.get(j), mode: modes.get(j) });\n        }\n    }\n\n    provided_secrets\n}\n\n/// Calls the HandshakeRegistry's `get_handshakes` utility function and deserializes the response.\nunconstrained fn fetch_handshake_page(recipient: AztecAddress, page_offset: u32) -> HandshakePage {\n    let selector = comptime { FunctionSelector::from_signature(\"get_handshakes((Field),u32)\") };\n    let args: [Field; 2] = [recipient.to_field(), page_offset as Field];\n    let response = call_utility_function(STANDARD_HANDSHAKE_REGISTRY_ADDRESS, selector, args);\n    HandshakePage::deserialize(response)\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::delivery::handshake::{\n        DiscoveredHandshake, get_handshake_secrets, HandshakePage, MAX_HANDSHAKES_PER_PAGE,\n    };\n    use crate::messages::delivery::OnchainDeliveryMode;\n    use crate::protocol::{address::AztecAddress, traits::Serialize};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use crate::utils::point::point_from_x_coord;\n    use std::test::OracleMock;\n\n    global UNCONSTRAINED: OnchainDeliveryMode = OnchainDeliveryMode::onchain_unconstrained();\n    global CONSTRAINED: OnchainDeliveryMode = OnchainDeliveryMode::onchain_constrained();\n\n    #[test]\n    unconstrained fn get_handshake_secrets_returns_secrets_from_single_page() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            let pk_a = point_from_x_coord(1).unwrap();\n            let pk_b = point_from_x_coord(2).unwrap();\n\n            let mut items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();\n            items.push(DiscoveredHandshake { eph_pk: pk_a, mode: UNCONSTRAINED });\n            items.push(DiscoveredHandshake { eph_pk: pk_b, mode: CONSTRAINED });\n            let page = HandshakePage { items, total_count: 2 };\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page.serialize());\n\n            let secret_a: Field = 111;\n            let secret_b: Field = 222;\n            mock_get_shared_secrets([secret_a, secret_b]);\n\n            let secrets = get_handshake_secrets(contract_address, scope);\n\n            assert_eq(secrets.len(), 2);\n            assert_eq(secrets.get(0).secret, secret_a);\n            assert_eq(secrets.get(0).mode, UNCONSTRAINED);\n            assert_eq(secrets.get(1).secret, secret_b);\n            assert_eq(secrets.get(1).mode, CONSTRAINED);\n        });\n    }\n\n    #[test]\n    unconstrained fn get_handshake_secrets_fetches_multiple_pages() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            let pk_a = point_from_x_coord(1).unwrap();\n            let pk_b = point_from_x_coord(2).unwrap();\n            let pk_c = point_from_x_coord(8).unwrap();\n\n            let mut page_1_items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();\n            page_1_items.push(DiscoveredHandshake { eph_pk: pk_a, mode: UNCONSTRAINED });\n            page_1_items.push(DiscoveredHandshake { eph_pk: pk_b, mode: CONSTRAINED });\n            let page_1 = HandshakePage { items: page_1_items, total_count: 3 };\n\n            let mut page_2_items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();\n            page_2_items.push(DiscoveredHandshake { eph_pk: pk_c, mode: UNCONSTRAINED });\n            let page_2 = HandshakePage { items: page_2_items, total_count: 3 };\n\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page_1.serialize()).times(1);\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page_2.serialize()).times(1);\n\n            mock_get_shared_secrets([111, 222, 333]);\n\n            let secrets = get_handshake_secrets(contract_address, scope);\n            assert_eq(secrets.len(), 3);\n            assert_eq(secrets.get(0).secret, 111);\n            assert_eq(secrets.get(0).mode, UNCONSTRAINED);\n            assert_eq(secrets.get(1).secret, 222);\n            assert_eq(secrets.get(1).mode, CONSTRAINED);\n            assert_eq(secrets.get(2).secret, 333);\n            assert_eq(secrets.get(2).mode, UNCONSTRAINED);\n        });\n    }\n\n    unconstrained fn mock_get_shared_secrets<let N: u32>(response_values: [Field; N]) {\n        let response_slot: Field = 99;\n        let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n        for value in response_values {\n            response_array.push(value);\n        }\n        let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n    }\n}\n"
-    },
-    "133": {
-      "function_locations": [
-        {
-          "name": "DeliveryMode::offchain",
-          "start": 313
-        },
-        {
-          "name": "DeliveryMode::onchain_unconstrained",
-          "start": 398
-        },
-        {
-          "name": "DeliveryMode::onchain_constrained",
-          "start": 515
-        },
-        {
-          "name": "DeliveryMode::assert_is_constant",
-          "start": 625
-        },
-        {
-          "name": "<impl Eq for DeliveryMode>::eq",
-          "start": 737
-        },
-        {
-          "name": "OnchainDeliveryMode::onchain_unconstrained",
-          "start": 1490
-        },
-        {
-          "name": "OnchainDeliveryMode::onchain_constrained",
-          "start": 1636
-        },
-        {
-          "name": "OnchainDeliveryMode::from_u8",
-          "start": 1705
-        },
-        {
-          "name": "OnchainDeliveryMode::is_valid",
-          "start": 1923
-        },
-        {
-          "name": "<impl Deserialize for OnchainDeliveryMode>::deserialize",
-          "start": 2160
-        },
-        {
-          "name": "<impl Deserialize for OnchainDeliveryMode>::stream_deserialize",
-          "start": 2303
-        },
-        {
-          "name": "<impl Eq for OnchainDeliveryMode>::eq",
-          "start": 2428
-        },
-        {
-          "name": "<impl ToField for OnchainDeliveryMode>::to_field",
-          "start": 2543
-        },
-        {
-          "name": "<impl From<OnchainDeliveryMode> for DeliveryMode>::from",
-          "start": 2687
-        },
-        {
-          "name": "test::onchain_delivery_modes_are_valid",
-          "start": 2918
-        },
-        {
-          "name": "test::mode_roundtrips_through_serialization",
-          "start": 3130
-        },
-        {
-          "name": "test::deserializing_invalid_mode_fails",
-          "start": 3601
-        },
-        {
-          "name": "test::delivery_mode_onchain_constructors_match_onchain_delivery_modes",
-          "start": 3751
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/delivery/mode.nr",
-      "source": "use crate::protocol::{traits::{Deserialize, Serialize, ToField}, utils::reader::Reader};\n\n/// Noir does not support enums, so this wrapper models delivery variants while keeping raw discriminants private.\npub(crate) struct DeliveryMode {\n    inner: u8,\n}\n\nimpl DeliveryMode {\n    pub(crate) fn offchain() -> Self {\n        Self { inner: 1 }\n    }\n\n    pub(crate) fn onchain_unconstrained() -> Self {\n        OnchainDeliveryMode::onchain_unconstrained().into()\n    }\n\n    pub(crate) fn onchain_constrained() -> Self {\n        OnchainDeliveryMode::onchain_constrained().into()\n    }\n\n    pub(crate) fn assert_is_constant(self) {\n        assert_constant(self.inner);\n    }\n}\n\nimpl Eq for DeliveryMode {\n    fn eq(self, other: Self) -> bool {\n        self.inner == other.inner\n    }\n}\n\n/// The mode of an on-chain message delivery: unconstrained or constrained tagging.\n///\n/// This is kept separate from the private [`DeliveryMode`] wrapper because it is used in external ABIs and therefore\n/// owns the serialization and validation for the on-chain-only subset.\n///\n/// Consumers derive modes through the delivery API, e.g.\n/// `let mode: OnchainDeliveryMode = MessageDelivery::onchain_unconstrained().into()`.\n#[derive(Serialize)]\npub struct OnchainDeliveryMode {\n    inner: u8,\n}\n\nimpl OnchainDeliveryMode {\n    /// On-chain delivery without constrained encryption/tagging.\n    ///\n    /// `unconstrained` alone is a reserved Noir keyword.\n    pub(crate) fn onchain_unconstrained() -> Self {\n        Self { inner: 2 }\n    }\n\n    /// On-chain delivery with constrained encryption/tagging.\n    pub(crate) fn onchain_constrained() -> Self {\n        Self { inner: 3 }\n    }\n\n    fn from_u8(inner: u8) -> Self {\n        let mode = Self { inner };\n        assert(mode.is_valid(), \"unrecognized delivery mode\");\n        mode\n    }\n\n    /// Whether `self` is one of the valid on-chain delivery modes.\n    fn is_valid(self) -> bool {\n        (self == Self::onchain_unconstrained()) | (self == Self::onchain_constrained())\n    }\n}\n\nimpl Deserialize for OnchainDeliveryMode {\n    let N: u32 = <u8 as Deserialize>::N;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self::from_u8(<u8 as Deserialize>::deserialize(fields))\n    }\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self::from_u8(reader.read() as u8)\n    }\n}\n\nimpl Eq for OnchainDeliveryMode {\n    fn eq(self, other: Self) -> bool {\n        self.inner == other.inner\n    }\n}\n\nimpl ToField for OnchainDeliveryMode {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl From<OnchainDeliveryMode> for DeliveryMode {\n    fn from(mode: OnchainDeliveryMode) -> DeliveryMode {\n        DeliveryMode { inner: mode.inner }\n    }\n}\n\nmod test {\n    use crate::protocol::traits::{Deserialize, Serialize};\n    use super::{DeliveryMode, OnchainDeliveryMode};\n\n    #[test]\n    fn onchain_delivery_modes_are_valid() {\n        assert(OnchainDeliveryMode::onchain_unconstrained().is_valid());\n        assert(OnchainDeliveryMode::onchain_constrained().is_valid());\n    }\n\n    #[test]\n    fn mode_roundtrips_through_serialization() {\n        let unconstrained_mode = OnchainDeliveryMode::onchain_unconstrained();\n        let constrained_mode = OnchainDeliveryMode::onchain_constrained();\n\n        assert(OnchainDeliveryMode::deserialize(unconstrained_mode.serialize()) == unconstrained_mode);\n        assert(OnchainDeliveryMode::deserialize(constrained_mode.serialize()) == constrained_mode);\n    }\n\n    #[test(should_fail_with = \"unrecognized delivery mode\")]\n    fn deserializing_invalid_mode_fails() {\n        let _ = OnchainDeliveryMode::deserialize([99]);\n    }\n\n    #[test]\n    fn delivery_mode_onchain_constructors_match_onchain_delivery_modes() {\n        let unconstrained_delivery_mode: DeliveryMode = OnchainDeliveryMode::onchain_unconstrained().into();\n        let constrained_delivery_mode: DeliveryMode = OnchainDeliveryMode::onchain_constrained().into();\n\n        assert(DeliveryMode::onchain_unconstrained() == unconstrained_delivery_mode);\n        assert(DeliveryMode::onchain_constrained() == constrained_delivery_mode);\n    }\n}\n"
+      "source": "use crate::protocol::point::EmbeddedCurvePoint;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\nuse crate::{\n    context::PrivateContext,\n    ephemeral::EphemeralArray,\n    messages::{delivery::OnchainDeliveryMode, processing::provided_secret::ProvidedSecret},\n    oracle::{call_utility_function::call_utility_function, shared_secret::get_shared_secrets},\n    protocol::{\n        abis::function_selector::FunctionSelector, address::AztecAddress, hash::sha256_to_field, traits::ToField,\n    },\n    standard_addresses::STANDARD_HANDSHAKE_REGISTRY_ADDRESS,\n};\n\n/// Page size for handshake discovery pagination.\npub global MAX_HANDSHAKES_PER_PAGE: u32 = 32;\n\n/// A handshake discovered during sync: the sender's ephemeral public key.\n#[derive(Deserialize, Eq, Serialize)]\npub struct DiscoveredHandshake {\n    pub eph_pk: EmbeddedCurvePoint,\n}\n\n/// A paginated response of discovered handshakes.\n#[derive(Deserialize, Serialize)]\npub struct HandshakePage {\n    pub items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE>,\n    pub total_count: u32,\n}\n\npub(crate) global PROVIDED_SECRETS_ARRAY_BASE_SLOT: Field =\n    sha256_to_field(\"AZTEC_NR::PROVIDED_SECRETS_ARRAY_BASE_SLOT\".as_bytes());\n\nglobal HANDSHAKE_EPH_PKS_SLOT: Field = sha256_to_field(\"AZTEC_NR::HANDSHAKE_EPH_PKS_SLOT\".as_bytes());\n\n// The helper cannot import the handshake registry interface because the registry contract depends on aztec-nr. These\n// selector constants pin the registry ABI surface this library calls. The registry's test suite compares them against\n// its macro-generated `HandshakeRegistry::at(...).method(...).selector` values so signature drift fails in tests.\npub global GET_APP_SILOED_SECRET_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"get_app_siloed_secret((Field),(Field))\") };\npub global NON_INTERACTIVE_HANDSHAKE_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"non_interactive_handshake((Field),(Field))\") };\npub global GET_HANDSHAKES_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"get_handshakes((Field),u32)\") };\n\n/// Resolves the app-siloed handshake secret, bootstrapping when none exists.\n///\n/// Resolves the secret for `(sender, recipient)`, creating it via the registry's `non_interactive_handshake`\n/// when no handshake exists yet.\n///\n/// Returns `(secret, bootstrapped)`, where `bootstrapped` is true when this call created the handshake.\n///\n/// ## Batching\n///\n/// The reuse-vs-bootstrap decision is a utility call that reads committed state. If no handshake exists yet,\n/// multiple sends in the same transaction can't see each other's pending bootstrap, so each one creates its own\n/// handshake (a fresh secret on a separate sequence) rather than reusing one. A brand-new recipient therefore needs\n/// one landed transaction to establish the handshake before further sends can be batched onto it.\npub(crate) fn get_or_create_app_siloed_handshake_secret(\n    context: &mut PrivateContext,\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> (Field, bool) {\n    // Safety: the response only selects which path runs. On `None` we bootstrap via `non_interactive_handshake`,\n    // whose constrained return value is the secret, so a forged empty response cannot fabricate one; it can only\n    // trigger an unnecessary re-handshake that replaces the registry note. The caller must constrain the returned\n    // `(secret, bootstrapped)` pair against the selected tagging index before emitting a handshake-derived tag.\n    let maybe_secret: Option<Field> = unsafe {\n        let returns = call_utility_function(\n            registry,\n            GET_APP_SILOED_SECRET_SELECTOR,\n            [sender.to_field(), recipient.to_field()],\n        );\n        Deserialize::deserialize(returns)\n    };\n\n    maybe_secret.map(|secret| (secret, false)).unwrap_or_else(|| {\n        // Bootstrap: no handshake exists yet. The registry inserts a fresh note and returns the app-siloed\n        // secret to the caller. The constrained return is the source of truth for the secret, so no separate\n        // `validate_handshake` is needed by constrained delivery.\n        // TODO(F-660): dispatch to `perform_handshake(sender, recipient, handshake_type)` once interactive\n        // handshakes are supported.\n        let secret: Field = context\n            .call_private_function(\n                registry,\n                NON_INTERACTIVE_HANDSHAKE_SELECTOR,\n                [sender.to_field(), recipient.to_field()],\n            )\n            .get_preimage();\n\n        (secret, true)\n    })\n}\n\n/// Fetches discovered handshakes from the HandshakeRegistry and derives app-siloed tagging secrets for each,\n/// returning them so that [`get_pending_tagged_logs`](crate::oracle::message_processing::get_pending_tagged_logs)\n/// searches for logs tagged with these secrets.\npub(crate) unconstrained fn get_handshake_secrets(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<ProvidedSecret> {\n    let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);\n\n    let eph_pks: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(HANDSHAKE_EPH_PKS_SLOT);\n\n    let mut page_offset: u32 = 0;\n    let mut has_more = true;\n    while has_more {\n        let page = fetch_handshake_page(scope, page_offset);\n\n        for j in 0..page.items.len() {\n            eph_pks.push(page.items.get(j).eph_pk);\n        }\n\n        page_offset += page.items.len();\n        has_more = page_offset < page.total_count;\n    }\n\n    if eph_pks.len() > 0 {\n        let secrets = get_shared_secrets(scope, eph_pks, contract_address);\n        for j in 0..secrets.len() {\n            let secret = secrets.get(j);\n            // Handshakes are mode-agnostic; emit one entry per on-chain tag domain for PXE to scan.\n            provided_secrets.push(ProvidedSecret { secret, mode: OnchainDeliveryMode::onchain_unconstrained() });\n            provided_secrets.push(ProvidedSecret { secret, mode: OnchainDeliveryMode::onchain_constrained() });\n        }\n    }\n\n    provided_secrets\n}\n\n/// Calls the HandshakeRegistry's `get_handshakes` utility function and deserializes the response.\nunconstrained fn fetch_handshake_page(recipient: AztecAddress, page_offset: u32) -> HandshakePage {\n    let args: [Field; 2] = [recipient.to_field(), page_offset as Field];\n    let response = call_utility_function(\n        STANDARD_HANDSHAKE_REGISTRY_ADDRESS,\n        GET_HANDSHAKES_SELECTOR,\n        args,\n    );\n    HandshakePage::deserialize(response)\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::delivery::handshake::{\n        DiscoveredHandshake, get_handshake_secrets, HandshakePage, MAX_HANDSHAKES_PER_PAGE,\n    };\n    use crate::messages::delivery::OnchainDeliveryMode;\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Serialize}};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use crate::utils::point::point_from_x_coord;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn get_handshake_secrets_returns_secrets_from_single_page() {\n        let env = TestEnvironment::new();\n        let scope = AztecAddress::from_field(1);\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            let pk_a = point_from_x_coord(1).unwrap();\n            let pk_b = point_from_x_coord(2).unwrap();\n\n            let mut items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();\n            items.push(DiscoveredHandshake { eph_pk: pk_a });\n            items.push(DiscoveredHandshake { eph_pk: pk_b });\n            let page = HandshakePage { items, total_count: 2 };\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page.serialize());\n\n            let secret_a: Field = 111;\n            let secret_b: Field = 222;\n            mock_get_shared_secrets([secret_a, secret_b]);\n\n            let secrets = get_handshake_secrets(contract_address, scope);\n\n            assert_eq(secrets.len(), 4);\n            assert_eq(secrets.get(0).secret, secret_a);\n            assert(secrets.get(0).mode == OnchainDeliveryMode::onchain_unconstrained());\n            assert_eq(secrets.get(1).secret, secret_a);\n            assert(secrets.get(1).mode == OnchainDeliveryMode::onchain_constrained());\n            assert_eq(secrets.get(2).secret, secret_b);\n            assert(secrets.get(2).mode == OnchainDeliveryMode::onchain_unconstrained());\n            assert_eq(secrets.get(3).secret, secret_b);\n            assert(secrets.get(3).mode == OnchainDeliveryMode::onchain_constrained());\n        });\n    }\n\n    #[test]\n    unconstrained fn get_handshake_secrets_fetches_multiple_pages() {\n        let env = TestEnvironment::new();\n        let scope = AztecAddress::from_field(1);\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            let pk_a = point_from_x_coord(1).unwrap();\n            let pk_b = point_from_x_coord(2).unwrap();\n            let pk_c = point_from_x_coord(8).unwrap();\n\n            let mut page_1_items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();\n            page_1_items.push(DiscoveredHandshake { eph_pk: pk_a });\n            page_1_items.push(DiscoveredHandshake { eph_pk: pk_b });\n            let page_1 = HandshakePage { items: page_1_items, total_count: 3 };\n\n            let mut page_2_items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();\n            page_2_items.push(DiscoveredHandshake { eph_pk: pk_c });\n            let page_2 = HandshakePage { items: page_2_items, total_count: 3 };\n\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page_1.serialize()).times(1);\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page_2.serialize()).times(1);\n\n            mock_get_shared_secrets([111, 222, 333]);\n\n            let secrets = get_handshake_secrets(contract_address, scope);\n            assert_eq(secrets.len(), 6);\n            assert_eq(secrets.get(0).secret, 111);\n            assert(secrets.get(0).mode == OnchainDeliveryMode::onchain_unconstrained());\n            assert_eq(secrets.get(1).secret, 111);\n            assert(secrets.get(1).mode == OnchainDeliveryMode::onchain_constrained());\n            assert_eq(secrets.get(2).secret, 222);\n            assert(secrets.get(2).mode == OnchainDeliveryMode::onchain_unconstrained());\n            assert_eq(secrets.get(3).secret, 222);\n            assert(secrets.get(3).mode == OnchainDeliveryMode::onchain_constrained());\n            assert_eq(secrets.get(4).secret, 333);\n            assert(secrets.get(4).mode == OnchainDeliveryMode::onchain_unconstrained());\n            assert_eq(secrets.get(5).secret, 333);\n            assert(secrets.get(5).mode == OnchainDeliveryMode::onchain_constrained());\n        });\n    }\n\n    unconstrained fn mock_get_shared_secrets<let N: u32>(response_values: [Field; N]) {\n        let response_slot: Field = 99;\n        let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n        for value in response_values {\n            response_array.push(value);\n        }\n        let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n    }\n}\n"
     },
-    "135": {
+    "139": {
       "function_locations": [
         {
           "name": "do_sync_state",
@@ -252,7 +248,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::logging::{aztecnr_debug_log, aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::messages::{\n    delivery::handshake::{get_handshake_secrets, PROVIDED_SECRETS_ARRAY_BASE_SLOT},\n    processing::provided_secret::ProvidedSecret,\n};\nuse crate::protocol::address::AztecAddress;\n\npub(crate) mod nonce_discovery;\npub(crate) mod partial_notes;\npub(crate) mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    messages::{\n        discovery::process_message::process_message_ciphertext,\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{\n            MessageContext, offchain::OffchainInboxSync, OffchainMessageWithContext,\n            pending_tagged_log::PendingTaggedLog, validate_and_store_enqueued_notes_and_events,\n        },\n    },\n    oracle::message_processing,\n    utils::array,\n};\n\npub struct NoteHashAndNullifier {\n    /// The result of [`crate::note::note_interface::NoteHash::compute_note_hash`].\n    pub note_hash: Field,\n    /// The result of [`crate::note::note_interface::NoteHash::compute_nullifier_unconstrained`].\n    ///\n    /// This value is unconstrained, as all of message discovery is unconstrained. It is `None` if the nullifier\n    /// cannot be computed (e.g. because the nullifier hiding key is not available).\n    pub inner_nullifier: Option<Field>,\n}\n\n/// A contract's way of computing note hashes.\n///\n/// Each contract in the network is free to compute their note's hash as they see fit - the hash function itself is not\n/// enshrined or standardized. Some aztec-nr functions however do need to know the details of this computation (e.g.\n/// when finding new notes), which is what this type represents.\n///\n/// This function takes a note's packed content, storage slot, note type ID, address of the emitting contract and\n/// randomness, and attempts to compute its inner note hash (not siloed by address nor uniqued by nonce).\n///\n/// ## Transient Notes\n///\n/// This function is meant to always be used on **settled** notes, i.e. those that have been inserted into the trees\n/// and for which the nonce is known. It is never invoked in the context of a transient note, as those are not involved\n/// in message processing.\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract by inspecting all note types in use and the storage layout. This injected function is a\n/// `#[contract_library_method]` called `_compute_note_hash`, and it looks something like this:\n///\n/// ```noir\n/// |packed_note, owner, storage_slot, note_type_id, _contract_address, randomness| {\n///     if note_type_id == MyNoteType::get_id() {\n///         if packed_note.len() != MY_NOTE_TYPE_SERIALIZATION_LENGTH {\n///             Option::none()\n///         } else {\n///             let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///             Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n///         }\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\npub type ComputeNoteHash = unconstrained fn(/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /*\n owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /*\nrandomness */ Field) -> Option<Field>;\n\n/// A contract's way of computing note nullifiers.\n///\n/// Like [`ComputeNoteHash`], each contract is free to derive nullifiers as they see fit. This function takes the\n/// unique note hash (used as the note hash for nullification for settled notes), plus the note's packed content and\n/// metadata, and attempts to compute the inner nullifier (not siloed by address).\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract called `_compute_note_nullifier`. It dispatches on `note_type_id` similarly to\n/// [`ComputeNoteHash`], then calls the note's\n/// [`compute_nullifier_unconstrained`](crate::note::note_interface::NoteHash::compute_nullifier_unconstrained) method.\npub type ComputeNoteNullifier = unconstrained fn(/* unique_note_hash */Field, /* packed_note */ BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/* randomness */ Field) -> Option<Field>;\n\n/// Deprecated: use [`ComputeNoteHash`] and [`ComputeNoteNullifier`] instead.\npub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/*randomness */ Field, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// A handler for custom messages.\n///\n/// Contracts that emit custom messages (i.e. any with a message type that is not in [`crate::messages::msg_type`])\n/// need to use [`crate::macros::AztecConfig::custom_message_handler`] with a function of this type in order to\n/// process them. They will otherwise be **silently ignored**.\npub type CustomMessageHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* msg_type_id */ u64,\n/* msg_metadata */ u64,\n/* msg_content */ BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n/* message_context */ MessageContext,\n/* scope */ AztecAddress);\n\n/// Custom state synchronization handler.\n///\n/// When set via [`crate::macros::AztecConfig::custom_sync_state`], the generated `sync_state` function will call\n/// this handler instead of [`do_sync_state`]. It receives all of the same parameters, so it can run custom logic\n/// (e.g. fetching and decrypting custom logs) before, after, or instead of calling [`do_sync_state`].\npub type CustomSyncHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* compute_note_hash */ ComputeNoteHash,\n/* compute_note_nullifier */ ComputeNoteNullifier,\n/* process_custom_message */ Option<CustomMessageHandler>,\n/* offchain_inbox_sync */ Option<OffchainInboxSync>,\n/* scope */ AztecAddress);\n\n/// Synchronizes the contract's private state with the network.\n///\n/// As blocks are mined, it is possible for a contract's private state to change (e.g. with new notes being created),\n/// but because these changes are private they will be invisible to most actors. This is the function that processes\n/// new transactions in order to discover new notes, events, and other kinds of private state changes.\n///\n/// The private state will be synchronized up to the block that will be used for private transactions (i.e. the anchor\n/// block. This will typically be close to the tip of the chain.\npub unconstrained fn do_sync_state(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n) {\n    let provided_secrets = get_handshake_secrets(contract_address, scope);\n    sync_state_with_secrets(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        process_custom_message,\n        offchain_inbox_sync,\n        scope,\n        provided_secrets,\n    );\n}\n\n/// Variant of [`do_sync_state`] that skips handshake secret discovery. Used by the HandshakeRegistry to avoid\n/// infinite recursion (the registry discovers handshakes for other contracts, not for itself).\npub unconstrained fn do_sync_state_without_handshake_discovery(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n) {\n    let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);\n    sync_state_with_secrets(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        process_custom_message,\n        offchain_inbox_sync,\n        scope,\n        provided_secrets,\n    );\n}\n\nunconstrained fn sync_state_with_secrets(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) {\n    aztecnr_debug_log!(\"Performing state synchronization\");\n\n    let logs = message_processing::get_pending_tagged_logs(scope, provided_secrets);\n    logs.for_each(|_i, pending_tagged_log: PendingTaggedLog| {\n        if pending_tagged_log.log.len() == 0 {\n            aztecnr_warn_log_format!(\"Skipping empty log from tx {0}\")([pending_tagged_log.context.tx_hash]);\n        } else {\n            aztecnr_debug_log_format!(\"Processing log with tag {0}\")([pending_tagged_log.log.get(0)]);\n\n            // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n            let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                message_ciphertext,\n                pending_tagged_log.context,\n                scope,\n            );\n        }\n    });\n\n    if offchain_inbox_sync.is_some() {\n        let msgs = offchain_inbox_sync.unwrap()(contract_address, scope);\n        msgs.for_each(|_i, msg: OffchainMessageWithContext| {\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                msg.message_ciphertext,\n                msg.message_context,\n                scope,\n            );\n        });\n    }\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::fetch_and_process_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        scope,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_and_store_enqueued_notes_and_events(scope);\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::{\n        delivery::handshake::HandshakePage,\n        discovery::{CustomMessageHandler, do_sync_state},\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{offchain::OffchainInboxSync, pending_tagged_log::PendingTaggedLog},\n    };\n    use crate::protocol::{address::AztecAddress, traits::Serialize};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn do_sync_state_does_not_panic_on_empty_logs() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            // get_handshake_secrets calls the HandshakeRegistry during sync; return an empty page so\n            // no tagging secrets are produced.\n            let empty_page = HandshakePage { items: BoundedVec::new(), total_count: 0 };\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(empty_page.serialize());\n\n            // Mock the oracle call to return a known base slot, then populate an ephemeral\n            // array at that slot so do_sync_state processes a non-empty log list.\n            let base_slot = 42;\n            let mock = std::test::OracleMock::mock(\"aztec_utl_getPendingTaggedLogs\");\n            let _ = mock.returns(base_slot);\n\n            let logs: EphemeralArray<PendingTaggedLog> = EphemeralArray::at(base_slot);\n            logs.push(PendingTaggedLog { log: BoundedVec::new(), context: std::mem::zeroed() });\n            assert_eq(logs.len(), 1);\n\n            let no_handler: Option<CustomMessageHandler> = Option::none();\n            let no_inbox_sync: Option<OffchainInboxSync> = Option::none();\n            do_sync_state(\n                contract_address,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n                no_handler,\n                no_inbox_sync,\n                scope,\n            );\n        });\n    }\n\n    unconstrained fn dummy_compute_note_hash(\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n\n    unconstrained fn dummy_compute_note_nullifier(\n        _unique_note_hash: Field,\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n}\n"
     },
-    "136": {
+    "140": {
       "function_locations": [
         {
           "name": "attempt_note_nonce_discovery",
@@ -310,7 +306,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/nonce_discovery.nr",
       "source": "use crate::messages::{discovery::{ComputeNoteHash, ComputeNoteNullifier}, logs::note::MAX_NOTE_PACKED_LEN};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::MAX_NOTE_HASHES_PER_TX,\n    hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n    traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub(crate) struct DiscoveredNoteInfo {\n    pub(crate) note_nonce: Field,\n    pub(crate) note_hash: Field,\n    pub(crate) inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub(crate) unconstrained fn attempt_note_nonce_discovery(\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) -> BoundedVec<DiscoveredNoteInfo, MAX_NOTE_HASHES_PER_TX> {\n    let discovered_notes = &mut BoundedVec::new();\n\n    aztecnr_debug_log_format!(\n        \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n    )(\n        [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n    );\n\n    let maybe_note_hash = compute_note_hash(\n        packed_note,\n        owner,\n        storage_slot,\n        note_type_id,\n        contract_address,\n        randomness,\n    );\n\n    if maybe_note_hash.is_none() {\n        aztecnr_warn_log_format!(\n            \"Unable to compute note hash for note of id {0} with packed length {1}, skipping nonce discovery\",\n        )(\n            [note_type_id, packed_note.len() as Field],\n        );\n    } else {\n        let note_hash = maybe_note_hash.unwrap();\n        let siloed_note_hash = compute_siloed_note_hash(contract_address, note_hash);\n\n        // We need to find nonces (typically just one) that result in the siloed note hash that being uniqued into one\n        // of the transaction's effects.\n        // The nonce is meant to be derived from the index of the note hash in the transaction effects array. However,\n        // due to an issue in the kernels the nonce might actually use any of the possible note hash indices - not\n        // necessarily the one that corresponds to the note hash. Hence, we need to try them all.\n        for i in 0..MAX_NOTE_HASHES_PER_TX {\n            let nonce_for_i = compute_note_hash_nonce(first_nullifier_in_tx, i);\n            let unique_note_hash_for_i = compute_unique_note_hash(nonce_for_i, siloed_note_hash);\n\n            let matching_notes = bvec_filter(\n                unique_note_hashes_in_tx,\n                |unique_note_hash_in_tx| unique_note_hash_in_tx == unique_note_hash_for_i,\n            );\n            if matching_notes.len() > 1 {\n                let identical_note_hashes = matching_notes.len();\n                // Note that we don't actually check that the note hashes array contains unique values, only that the\n                // note we found is unique. We don't expect for this to ever happen (it'd indicate a malicious node or\n                // PXE, which are both assumed to be cooperative) so testing for it just in case is unnecessary, but we\n                // _do_ need to handle it if we find a duplicate.\n                panic(\n                    f\"Received {identical_note_hashes} identical note hashes for a transaction - these should all be unique\",\n                )\n            } else if matching_notes.len() == 1 {\n                let maybe_inner_nullifier_for_i = compute_note_nullifier(\n                    unique_note_hash_for_i,\n                    packed_note,\n                    owner,\n                    storage_slot,\n                    note_type_id,\n                    contract_address,\n                    randomness,\n                );\n\n                if maybe_inner_nullifier_for_i.is_none() {\n                    // TODO: down the line we want to be able to store notes for which we don't know their nullifier,\n                    // e.g. notes that belong to someone that is not us (and for which we therefore don't know their\n                    // associated app-siloed nullifer hiding secret key).\n                    // https://linear.app/aztec-labs/issue/F-265/store-external-notes\n                    aztecnr_warn_log_format!(\n                        \"Unable to compute nullifier of unique note {0} with note type id {1} and owner {2}, skipping PXE insertion\",\n                    )(\n                        [unique_note_hash_for_i, note_type_id, owner.to_field()],\n                    );\n                } else {\n                    // Note that while we did check that the note hash is the preimage of a unique note hash, we\n                    // perform no validations on the nullifier - we fundamentally cannot, since only the application\n                    // knows how to compute nullifiers. We simply trust it to have provided the correct one: if it\n                    // hasn't, then PXE may fail to realize that a given note has been nullified already, and calls to\n                    // the application could result in invalid transactions (with duplicate nullifiers). This is not a\n                    // concern because an application already has more direct means of making a call to it fail the\n                    // transaction.\n                    discovered_notes.push(\n                        DiscoveredNoteInfo {\n                            note_nonce: nonce_for_i,\n                            note_hash,\n                            inner_nullifier: maybe_inner_nullifier_for_i.unwrap(),\n                        },\n                    );\n                }\n                // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n                // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n                // notes containing random values in order to hide their contents.\n            }\n        }\n    }\n\n    *discovered_notes\n}\n\n// There is no BoundedVec::filter in the stdlib, so we use this until that is implemented.\nunconstrained fn bvec_filter<Env, T, let MAX_LEN: u32>(\n    bvec: BoundedVec<T, MAX_LEN>,\n    filter: fn[Env](T) -> bool,\n) -> BoundedVec<T, MAX_LEN> {\n    let filtered = &mut BoundedVec::new();\n\n    bvec.for_each(|value| {\n        if filter(value) {\n            filtered.push(value);\n        }\n    });\n\n    *filtered\n}\n\nmod test {\n    use crate::{\n        messages::logs::note::MAX_NOTE_PACKED_LEN,\n        note::{\n            note_interface::{NoteHash, NoteType},\n            note_metadata::SettledNoteMetadata,\n            utils::compute_note_hash_for_nullification,\n        },\n        oracle::random::random,\n        test::mocks::mock_note::MockNote,\n        utils::array,\n    };\n\n    use crate::protocol::{\n        address::AztecAddress,\n        hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n        traits::{FromField, Packable},\n    };\n\n    use super::attempt_note_nonce_discovery;\n\n    // This implementation could be simpler, but this serves as a nice example of the expected flow in a real\n    // implementation, and as a sanity check that the interface is sufficient.\n\n    unconstrained fn compute_note_hash(\n        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        owner: AztecAddress,\n        storage_slot: Field,\n        note_type_id: Field,\n        _contract_address: AztecAddress,\n        randomness: Field,\n    ) -> Option<Field> {\n        if (note_type_id == MockNote::get_id()) & (packed_note.len() == <MockNote as Packable>::N) {\n            let note = MockNote::unpack(array::subarray(packed_note.storage(), 0));\n            Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n        } else {\n            Option::none()\n        }\n    }\n\n    unconstrained fn compute_note_nullifier(\n        unique_note_hash: Field,\n        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        owner: AztecAddress,\n        _storage_slot: Field,\n        note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        if (note_type_id == MockNote::get_id()) & (packed_note.len() == <MockNote as Packable>::N) {\n            let note = MockNote::unpack(array::subarray(packed_note.storage(), 0));\n            note.compute_nullifier_unconstrained(owner, unique_note_hash)\n        } else {\n            Option::none()\n        }\n    }\n\n    global VALUE: Field = 7;\n    global FIRST_NULLIFIER_IN_TX: Field = 47;\n    global CONTRACT_ADDRESS: AztecAddress = AztecAddress::from_field(13);\n    global OWNER: AztecAddress = AztecAddress::from_field(14);\n    global STORAGE_SLOT: Field = 99;\n    global RANDOMNESS: Field = 99;\n\n    #[test]\n    unconstrained fn no_note_hashes() {\n        let unique_note_hashes_in_tx = BoundedVec::new();\n        let packed_note = BoundedVec::new();\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            packed_note,\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn failed_hash_computation_is_ignored() {\n        let unique_note_hashes_in_tx = BoundedVec::from_array([random()]);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            |_, _, _, _, _, _| Option::none(),\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::new(),\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn failed_nullifier_computation_is_ignored() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            |_, _, _, _, _, _, _| Option::none(),\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    struct NoteAndData {\n        note: MockNote,\n        note_nonce: Field,\n        note_hash: Field,\n        unique_note_hash: Field,\n        inner_nullifier: Field,\n    }\n\n    unconstrained fn construct_note(value: Field, note_index_in_tx: u32) -> NoteAndData {\n        let note_nonce = compute_note_hash_nonce(FIRST_NULLIFIER_IN_TX, note_index_in_tx);\n\n        let hinted_note = MockNote::new(value)\n            .contract_address(CONTRACT_ADDRESS)\n            .owner(OWNER)\n            .randomness(RANDOMNESS)\n            .storage_slot(STORAGE_SLOT)\n            .note_metadata(SettledNoteMetadata::new(note_nonce).into())\n            .build_hinted_note();\n        let note = hinted_note.note;\n\n        let note_hash = note.compute_note_hash(OWNER, STORAGE_SLOT, RANDOMNESS);\n        let unique_note_hash = compute_unique_note_hash(\n            note_nonce,\n            compute_siloed_note_hash(CONTRACT_ADDRESS, note_hash),\n        );\n        let inner_nullifier = note\n            .compute_nullifier_unconstrained(OWNER, compute_note_hash_for_nullification(hinted_note))\n            .expect(f\"Could not compute nullifier for note owned by {OWNER}\");\n\n        NoteAndData { note, note_nonce, note_hash, unique_note_hash, inner_nullifier }\n    }\n\n    #[test]\n    unconstrained fn single_note() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test]\n    unconstrained fn multiple_notes_same_preimage() {\n        let first_note_index_in_tx = 3;\n        let first_note_and_data = construct_note(VALUE, first_note_index_in_tx);\n\n        let second_note_index_in_tx = 5;\n        let second_note_and_data = construct_note(VALUE, second_note_index_in_tx);\n\n        // Both notes have the same preimage (and therefore packed representation), so both should be found in the same\n        // call.\n        assert_eq(first_note_and_data.note, second_note_and_data.note);\n        let packed_note = first_note_and_data.note.pack();\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(first_note_index_in_tx, first_note_and_data.unique_note_hash);\n        unique_note_hashes_in_tx.set(second_note_index_in_tx, second_note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(packed_note),\n        );\n\n        assert_eq(discovered_notes.len(), 2);\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == first_note_and_data.note_nonce)\n                & (discovered_note.note_hash == first_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == first_note_and_data.inner_nullifier)\n        }));\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == second_note_and_data.note_nonce)\n                & (discovered_note.note_hash == second_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == second_note_and_data.inner_nullifier)\n        }));\n    }\n\n    #[test]\n    unconstrained fn single_note_misaligned_nonce() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n\n        // The note is not at the correct index\n        unique_note_hashes_in_tx.set(note_index_in_tx + 1, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test]\n    unconstrained fn single_note_nonce_with_index_past_note_hashes_in_tx() {\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n\n        // The nonce is computed with an index that does not exist in the tx\n        let note_index_in_tx = unique_note_hashes_in_tx.len() + 5;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        // The note is inserted at an arbitrary index - its true index is out of the array's bounds\n        unique_note_hashes_in_tx.set(2, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test(should_fail_with = \"identical note hashes for a transaction\")]\n    unconstrained fn duplicate_unique_note_hashes() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n\n        // The same unique note hash is present in two indices in the array, which is not allowed. Note that we don't\n        // test all note hashes for uniqueness, only those that we actually find.\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n        unique_note_hashes_in_tx.set(note_index_in_tx + 1, note_and_data.unique_note_hash);\n\n        let _ = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n    }\n}\n"
     },
-    "137": {
+    "141": {
       "function_locations": [
         {
           "name": "process_partial_note_private_msg",
@@ -322,9 +318,9 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/partial_notes.nr",
-      "source": "use crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::partial_note::{decode_partial_note_private_message, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN},\n        processing::{\n            enqueue_note_for_validation,\n            get_pending_partial_notes_completion_logs,\n            log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN},\n        },\n    },\n    utils::array,\n};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, traits::{Deserialize, Serialize}};\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub(crate) global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) owner: AztecAddress,\n    pub(crate) randomness: Field,\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n}\n\npub(crate) unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n    scope: AztecAddress,\n) {\n    let decoded = decode_partial_note_private_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later\n        // search for the public log that will complete it.\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content) = decoded.unwrap();\n\n        let pending = DeliveredPendingPartialNote {\n            owner,\n            randomness,\n            note_completion_log_tag,\n            note_type_id,\n            packed_private_note_content,\n        };\n\n        CapsuleArray::at(\n            contract_address,\n            DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n            scope,\n        )\n            .push(pending);\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode partial note private message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Searches for logs that would result in the completion of pending partial notes, ultimately resulting in the notes\n/// being delivered to PXE if completed.\npub(crate) unconstrained fn fetch_and_process_partial_note_completion_logs(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    scope: AztecAddress,\n) {\n    let pending_partial_notes = CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n        scope,\n    );\n\n    aztecnr_debug_log_format!(\"{} pending partial notes\")([pending_partial_notes.len() as Field]);\n\n    // Each of the pending partial notes might get completed by a log containing its public values. For performance\n    // reasons, we fetch all of these logs concurrently and then process them one by one, minimizing the amount of time\n    // waiting for the node roundtrip.\n    let completion_logs = get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n\n    // Each entry in the completion logs array corresponds to the entry in the pending partial notes array at the same\n    // index. Each inner array contains all matching LogRetrievalResponses.\n    assert_eq(completion_logs.len(), pending_partial_notes.len());\n\n    completion_logs.for_each(|i, logs_for_tag: EphemeralArray<LogRetrievalResponse>| {\n        let pending_partial_note = pending_partial_notes.get(i);\n        let num_logs = logs_for_tag.len();\n\n        if num_logs == 0 {\n            aztecnr_debug_log_format!(\"Found no completion logs for partial note with tag {}\")(\n                [pending_partial_note.note_completion_log_tag],\n            );\n\n            // Note that we're not removing the pending partial note from the capsule array, so we will continue\n            // searching for this tagged log when performing message discovery in the future until we either find it or\n            // the entry is somehow removed from the array.\n        } else {\n            assert(num_logs == 1, f\"Expected at most 1 completion log per partial note, got {num_logs}\");\n\n            aztecnr_debug_log_format!(\"Completion log found for partial note with tag {}\")([\n                pending_partial_note.note_completion_log_tag,\n            ]);\n            let log = logs_for_tag.get(0);\n\n            // The first field in the completion log payload is the storage slot, followed by the public note\n            // content fields.\n            let storage_slot = log.log_payload.get(0);\n            let public_note_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN - 1> = array::subbvec(log.log_payload, 1);\n\n            // Public fields are assumed to all be placed at the end of the packed representation, so we combine\n            // the private and public packed fields (i.e. the contents of the private message and public log\n            // plaintext) to get the complete packed content.\n            let complete_packed_note = array::append(\n                pending_partial_note.packed_private_note_content,\n                public_note_content,\n            );\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                contract_address,\n                pending_partial_note.owner,\n                storage_slot,\n                pending_partial_note.randomness,\n                pending_partial_note.note_type_id,\n                complete_packed_note,\n            );\n\n            // TODO(#11627): is there anything reasonable we can do if we get a log but it doesn't result in a note\n            // being found?\n            if discovered_notes.len() == 0 {\n                panic(\n                    f\"A partial note's completion log did not result in any notes being found - this should never happen\",\n                );\n            }\n\n            aztecnr_debug_log_format!(\"Discovered {0} notes for partial note with tag {1}\")([\n                discovered_notes.len() as Field,\n                pending_partial_note.note_completion_log_tag,\n            ]);\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    contract_address,\n                    pending_partial_note.owner,\n                    storage_slot,\n                    pending_partial_note.randomness,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                );\n            });\n\n            // Because there is only a single log for a given tag, once we've processed the tagged log then we simply\n            // delete the pending work entry, regardless of whether it was actually completed or not.\n            pending_partial_notes.remove(i);\n        }\n    });\n}\n"
+      "source": "use crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::partial_note::{decode_partial_note_private_message, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN},\n        processing::{\n            enqueue_note_for_validation,\n            get_pending_partial_notes_completion_logs,\n            log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN},\n        },\n    },\n    utils::array,\n};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, traits::{Deserialize, Serialize}};\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub(crate) global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) owner: AztecAddress,\n    pub(crate) randomness: Field,\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n}\n\npub(crate) unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n    scope: AztecAddress,\n) {\n    let decoded = decode_partial_note_private_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later\n        // search for the public log that will complete it.\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content) = decoded.unwrap();\n\n        let pending = DeliveredPendingPartialNote {\n            owner,\n            randomness,\n            note_completion_log_tag,\n            note_type_id,\n            packed_private_note_content,\n        };\n\n        CapsuleArray::at(\n            contract_address,\n            DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n            scope,\n        )\n            .push(pending);\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode partial note private message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Searches for logs that would result in the completion of pending partial notes, ultimately resulting in the notes\n/// being delivered to PXE if completed.\npub(crate) unconstrained fn fetch_and_process_partial_note_completion_logs(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    scope: AztecAddress,\n) {\n    let pending_partial_notes = CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n        scope,\n    );\n\n    aztecnr_debug_log_format!(\"{} pending partial notes\")([pending_partial_notes.len() as Field]);\n\n    // Each of the pending partial notes might get completed by a log containing its public values. For performance\n    // reasons, we fetch all of these logs concurrently and then process them one by one, minimizing the amount of time\n    // waiting for the node roundtrip.\n    let completion_logs = get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n\n    // Each entry in the completion logs array corresponds to the entry in the pending partial notes array at the same\n    // index. Each inner array contains all matching LogRetrievalResponses.\n    assert_eq(completion_logs.len(), pending_partial_notes.len());\n\n    // Note: the loop runs backwards because it removes completed entries from `pending_partial_notes`, which is\n    // index-aligned with `completion_logs`. Going from last to first keeps the indices of not-yet-visited entries\n    // stable.\n    let mut i = completion_logs.len();\n    while i > 0 {\n        i -= 1;\n        let logs_for_tag: EphemeralArray<LogRetrievalResponse> = completion_logs.get(i);\n        let pending_partial_note = pending_partial_notes.get(i);\n        let num_logs = logs_for_tag.len();\n\n        if num_logs == 0 {\n            aztecnr_debug_log_format!(\"Found no completion logs for partial note with tag {}\")(\n                [pending_partial_note.note_completion_log_tag],\n            );\n\n            // Note that we're not removing the pending partial note from the capsule array, so we will continue\n            // searching for this tagged log when performing message discovery in the future until we either find it or\n            // the entry is somehow removed from the array.\n        } else {\n            assert(num_logs == 1, f\"Expected at most 1 completion log per partial note, got {num_logs}\");\n\n            aztecnr_debug_log_format!(\"Completion log found for partial note with tag {}\")([\n                pending_partial_note.note_completion_log_tag,\n            ]);\n            let log = logs_for_tag.get(0);\n\n            // The first field in the completion log payload is the storage slot, followed by the public note\n            // content fields.\n            let storage_slot = log.log_payload.get(0);\n            let public_note_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN - 1> = array::subbvec(log.log_payload, 1);\n\n            // Public fields are assumed to all be placed at the end of the packed representation, so we combine\n            // the private and public packed fields (i.e. the contents of the private message and public log\n            // plaintext) to get the complete packed content.\n            let complete_packed_note = array::append(\n                pending_partial_note.packed_private_note_content,\n                public_note_content,\n            );\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                contract_address,\n                pending_partial_note.owner,\n                storage_slot,\n                pending_partial_note.randomness,\n                pending_partial_note.note_type_id,\n                complete_packed_note,\n            );\n\n            // TODO(#11627): is there anything reasonable we can do if we get a log but it doesn't result in a note\n            // being found?\n            if discovered_notes.len() == 0 {\n                panic(\n                    f\"A partial note's completion log did not result in any notes being found - this should never happen\",\n                );\n            }\n\n            aztecnr_debug_log_format!(\"Discovered {0} notes for partial note with tag {1}\")([\n                discovered_notes.len() as Field,\n                pending_partial_note.note_completion_log_tag,\n            ]);\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    contract_address,\n                    pending_partial_note.owner,\n                    storage_slot,\n                    pending_partial_note.randomness,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                );\n            });\n\n            // Because there is only a single log for a given tag, once we've processed the tagged log then we simply\n            // delete the pending work entry, regardless of whether it was actually completed or not.\n            pending_partial_notes.remove(i);\n        }\n    }\n}\n"
     },
-    "138": {
+    "142": {
       "function_locations": [
         {
           "name": "process_private_event_msg",
@@ -334,7 +330,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_events.nr",
       "source": "use crate::{\n    event::event_interface::compute_private_serialized_event_commitment,\n    logging::aztecnr_warn_log_format,\n    messages::{\n        encoding::MAX_MESSAGE_CONTENT_LEN, logs::event::decode_private_event_message,\n        processing::enqueue_event_for_validation,\n    },\n};\nuse crate::protocol::{address::AztecAddress, traits::ToField};\n\npub(crate) unconstrained fn process_private_event_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n) {\n    let decoded = decode_private_event_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (event_type_id, randomness, serialized_event) = decoded.unwrap();\n\n        let event_commitment =\n            compute_private_serialized_event_commitment(serialized_event, randomness, event_type_id.to_field());\n\n        enqueue_event_for_validation(\n            contract_address,\n            event_type_id,\n            randomness,\n            serialized_event,\n            event_commitment,\n            tx_hash,\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode private event message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n"
     },
-    "139": {
+    "143": {
       "function_locations": [
         {
           "name": "process_private_note_msg",
@@ -348,7 +344,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
       "source": "use crate::{\n    logging::{aztecnr_debug_log_format, aztecnr_warn_log_format},\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::{decode_private_note_message, MAX_NOTE_PACKED_LEN},\n        processing::enqueue_note_for_validation,\n    },\n    protocol::{address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, traits::ToField},\n};\n\n/// Processes a private note message, attempting to discover and enqueue any notes it contains.\n///\n/// For each note recovered from the message whose computed note hash matches a unique note hash in the transaction,\n/// a [`NoteValidationRequest`](crate::messages::processing::NoteValidationRequest) is pushed onto the ephemeral array\n/// at `NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT` via\n/// [`enqueue_note_for_validation`](crate::messages::processing::enqueue_note_for_validation). PXE later drains this\n/// array during `validate_and_store_enqueued_notes_and_events`, after which the notes are retrievable via `get_notes`.\n///\n/// Messages that fail to decode, or whose computed note hash matches nothing in the transaction, are discarded\n/// (with a debug or warning log respectively) and produce no validation requests. Decode failures are not treated\n/// as errors since messages may originate from malicious senders and we don't want them to be able to brick message\n/// processing.\n///\n/// ## Use Cases\n///\n/// This function is invoked automatically by aztec-nr when handling messages with the built-in private note type id,\n/// so contracts do not normally need to call it directly. It is exposed for use by custom message handlers (see\n/// [`CustomMessageHandler`](crate::messages::discovery::CustomMessageHandler)) that might want to use the standard\n/// note message processing pipeline while extending it with custom logic.\npub unconstrained fn process_private_note_msg(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let decoded = decode_private_note_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (note_type_id, owner, storage_slot, randomness, packed_note) = decoded.unwrap();\n\n        attempt_note_discovery(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            compute_note_hash,\n            compute_note_nullifier,\n            owner,\n            storage_slot,\n            randomness,\n            note_type_id,\n            packed_note,\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode private note message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is suspected the\n/// note was created.\nunconstrained fn attempt_note_discovery(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) {\n    let discovered_notes = attempt_note_nonce_discovery(\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        compute_note_hash,\n        compute_note_nullifier,\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_type_id,\n        packed_note,\n    );\n\n    if discovered_notes.len() == 0 {\n        // A private note message that results in no discovered notes means none of the computed note hashes matched\n        // any unique note hash in the transaction. This could indicate a malformed or malicious message (e.g. a sender\n        // providing bogus note content).\n        aztecnr_warn_log_format!(\n            \"Discarding private note message from tx {0} for contract {1}: no matching note hash found in the tx\",\n        )(\n            [tx_hash, contract_address.to_field()],\n        );\n    } else {\n        aztecnr_debug_log_format!(\n            \"Discovered {0} notes from a private message for contract {1}\",\n        )(\n            [discovered_notes.len() as Field, contract_address.to_field()],\n        );\n    }\n\n    discovered_notes.for_each(|discovered_note| {\n        enqueue_note_for_validation(\n            contract_address,\n            owner,\n            storage_slot,\n            randomness,\n            discovered_note.note_nonce,\n            packed_note,\n            discovered_note.note_hash,\n            discovered_note.inner_nullifier,\n            tx_hash,\n        );\n    });\n}\n"
     },
-    "140": {
+    "144": {
       "function_locations": [
         {
           "name": "process_message_ciphertext",
@@ -362,7 +358,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHash, ComputeNoteNullifier, CustomMessageHandler, partial_notes::process_partial_note_private_msg,\n        private_events::process_private_event_msg, private_notes::process_private_note_msg,\n    },\n    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN},\n    encryption::{aes128::AES128, message_encryption::MessageEncryption},\n    msg_type::{\n        MIN_CUSTOM_MSG_TYPE_ID, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    processing::MessageContext,\n};\n\nuse crate::logging::{aztecnr_debug_log, aztecnr_warn_log_format};\nuse crate::protocol::address::AztecAddress;\n\n/// Processes a message that can contain notes, partial notes, or events.\n///\n/// Notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash\n/// in which the notes would've been created (typically the same transaction in which the log was emitted), along with\n/// the list of unique note hashes in said transaction and the `compute_note_hash` and `compute_note_nullifier`\n/// functions. Once discovered, the notes are enqueued for validation.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved\n/// to search for the note's completion public log.\n///\n/// Events are processed by computing an event commitment from the serialized event data and its randomness field, then\n/// enqueueing the event data and commitment for validation.\npub unconstrained fn process_message_ciphertext(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    message_context: MessageContext,\n    recipient: AztecAddress,\n) {\n    let message_plaintext_option = AES128::decrypt(message_ciphertext, recipient, contract_address);\n\n    if message_plaintext_option.is_some() {\n        process_message_plaintext(\n            contract_address,\n            compute_note_hash,\n            compute_note_nullifier,\n            process_custom_message,\n            message_plaintext_option.unwrap(),\n            message_context,\n            recipient,\n        );\n    } else {\n        aztecnr_warn_log_format!(\"Could not decrypt message ciphertext from tx {0}, ignoring\")([message_context.tx_hash]);\n    }\n}\n\npub(crate) unconstrained fn process_message_plaintext(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    message_plaintext: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n    message_context: MessageContext,\n    recipient: AztecAddress,\n) {\n    // The first thing to do after decrypting the message is to determine what type of message we're processing. We\n    // have 3 message types: private notes, partial notes and events.\n\n    // We decode the message to obtain the message type id, metadata and content.\n    let decoded = decode_message(message_plaintext);\n\n    if decoded.is_some() {\n        let (msg_type_id, msg_metadata, msg_content) = decoded.unwrap();\n\n        if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private note msg\");\n\n            process_private_note_msg(\n                contract_address,\n                message_context.tx_hash,\n                message_context.unique_note_hashes_in_tx,\n                message_context.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                msg_metadata,\n                msg_content,\n            );\n        } else if msg_type_id == PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing partial note private msg\");\n\n            process_partial_note_private_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                message_context.tx_hash,\n                recipient,\n            );\n        } else if msg_type_id == PRIVATE_EVENT_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private event msg\");\n\n            process_private_event_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                message_context.tx_hash,\n            );\n        } else if msg_type_id < MIN_CUSTOM_MSG_TYPE_ID {\n            // The message type ID falls in the range reserved for aztec.nr built-in types but wasn't matched above.\n            // This most likely means the message is malformed or a custom message was incorrectly assigned a reserved\n            // ID. Custom message types must use IDs allocated via `custom_msg_type_id`.\n            aztecnr_warn_log_format!(\n                \"Message type ID {0} is in the reserved range but is not recognized, ignoring. See https://docs.aztec.network/errors/3\",\n            )(\n                [msg_type_id as Field],\n            );\n        } else if process_custom_message.is_some() {\n            process_custom_message.unwrap()(\n                contract_address,\n                msg_type_id,\n                msg_metadata,\n                msg_content,\n                message_context,\n                recipient,\n            );\n        } else {\n            // A custom message was received but no handler is configured. This likely means the contract emits custom\n            // messages but forgot to register a handler via `AztecConfig::custom_message_handler`.\n            aztecnr_warn_log_format!(\n                \"Received custom message with type id {0} but no handler is configured, ignoring. See https://docs.aztec.network/errors/2\",\n            )(\n                [msg_type_id as Field],\n            );\n        }\n    } else {\n        aztecnr_warn_log_format!(\"Could not decode message plaintext from tx {0}, ignoring\")([message_context.tx_hash]);\n    }\n}\n"
     },
-    "141": {
+    "145": {
       "function_locations": [
         {
           "name": "encode_message",
@@ -424,7 +420,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encoding.nr",
       "source": "// TODO(#12750): don't make these values assume we're using AES.\nuse crate::protocol::constants::PRIVATE_LOG_CIPHERTEXT_LEN;\nuse crate::utils::array;\n\n// We reassign to the constant here to communicate the distinction between a log and a message. In Aztec.nr, unlike in\n// protocol circuits, we have a concept of a message that can be emitted either as a private log or as an offchain\n// message. Message is a piece of data that is to be eventually delivered to a contract via the `process_message(...)`\n// utility function function that is injected by the #[aztec] macro. Note: PRIVATE_LOG_CIPHERTEXT_LEN is an amount of\n// fields, so MESSAGE_CIPHERTEXT_LEN is the size of the message in fields.\npub global MESSAGE_CIPHERTEXT_LEN: u32 = PRIVATE_LOG_CIPHERTEXT_LEN;\n\n// TODO(#12750): The global variables below should not be here as they are AES128 specific.\n// The header plaintext is 2 bytes (ciphertext length), padded to the 16-byte AES block size by PKCS#7.\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 16;\n// AES PKCS#7 always adds at least one byte of padding. Since each plaintext field is 32 bytes (a multiple of the\n// 16-byte AES block size), a full 16-byte padding block is always appended.\npub(crate) global AES128_PKCS7_EXPANSION_IN_BYTES: u32 = 16;\n\npub global EPH_PK_X_SIZE_IN_FIELDS: u32 = 1;\n\n// (15 - 1) * 31 - 16 - 16 = 402. Note: We multiply by 31 because ciphertext bytes are stored in fields using\n// encode_bytes_as_fields, which packs 31 bytes per field (since a Field is ~254 bits and can safely store 31 whole\n// bytes).\npub(crate) global MESSAGE_PLAINTEXT_SIZE_IN_BYTES: u32 = (MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31\n    - HEADER_CIPHERTEXT_SIZE_IN_BYTES\n    - AES128_PKCS7_EXPANSION_IN_BYTES;\n// The plaintext bytes represent Field values that were originally serialized using encode_fields_as_bytes, which\n// converts each Field to 32 bytes. To convert the plaintext bytes back to fields, we divide by 32. 402 / 32 = 12\npub global MESSAGE_PLAINTEXT_LEN: u32 = MESSAGE_PLAINTEXT_SIZE_IN_BYTES / 32;\n\npub global MESSAGE_EXPANDED_METADATA_LEN: u32 = 1;\n\n// The standard message layout is composed of:\n//  - an initial field called the 'expanded metadata'\n//  - an arbitrary number of fields following that called the 'message content'\n//\n// ```\n// message: [ msg_expanded_metadata, ...msg_content ]\n// ```\n//\n// The expanded metadata itself is interpreted as a u128, of which:\n//  - the upper 64 bits are the message type id\n//  - the lower 64 bits are called the 'message metadata'\n//\n// ```\n// msg_expanded_metadata: [  msg_type_id    |  msg_metadata  ]\n//                        <---  64 bits --->|<--- 64 bits --->\n// ```\n//\n// The meaning of the message metadata and message content depend on the value of the message type id. Note that there\n// is nothing special about the message metadata, it _can_ be considered part of the content. It just has a different\n// name to make it distinct from the message content given that it is not a full field.\n\n/// The maximum length of a message's content, i.e. not including the expanded message metadata.\npub global MAX_MESSAGE_CONTENT_LEN: u32 = MESSAGE_PLAINTEXT_LEN - MESSAGE_EXPANDED_METADATA_LEN;\n\n/// Encodes a message following aztec-nr's standard message encoding. This message can later be decoded with\n/// `decode_message` to retrieve the original values.\n///\n/// - The `msg_type` is an identifier that groups types of messages that are all processed the same way, e.g. private\n/// notes or events. Possible values are defined in `aztec::messages::msg_type`.\n/// - The `msg_metadata` and `msg_content` are the values stored in the message, whose meaning depends on the\n/// `msg_type`. The only special thing about `msg_metadata` that separates it from `msg_content` is that it is a u64\n/// instead of a full Field (due to details of how messages are encoded), allowing applications that can fit values\n/// into this smaller variable to achieve higher data efficiency.\npub fn encode_message<let N: u32>(\n    msg_type: u64,\n    msg_metadata: u64,\n    msg_content: [Field; N],\n) -> [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] {\n    std::static_assert(\n        msg_content.len() <= MAX_MESSAGE_CONTENT_LEN,\n        \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\",\n    );\n\n    // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of the\n    // message encoding below must be updated as well.\n    std::static_assert(\n        MESSAGE_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n    );\n    let mut message: [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] = std::mem::zeroed();\n\n    message[0] = to_expanded_metadata(msg_type, msg_metadata);\n    for i in 0..msg_content.len() {\n        message[MESSAGE_EXPANDED_METADATA_LEN + i] = msg_content[i];\n    }\n\n    message\n}\n\n/// Decodes a standard aztec-nr message, i.e. one created via `encode_message`, returning the original encoded values.\n///\n/// Returns `None` if the message is empty or has invalid (>128 bit) expanded metadata.\n///\n/// Note that `encode_message` returns a fixed size array while this function takes a `BoundedVec`: this is because\n/// prior to decoding the message type is unknown, and consequentially not known at compile time. If working with\n/// fixed-size messages, consider using `BoundedVec::from_array` to convert them.\npub unconstrained fn decode_message(\n    message: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n) -> Option<(u64, u64, BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>)> {\n    Option::some(message)\n        .and_then(|message| {\n            // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring\n            // of the\n            // message encoding below must be updated as well.\n            std::static_assert(\n                MESSAGE_EXPANDED_METADATA_LEN == 1,\n                \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n            );\n            if message.len() < MESSAGE_EXPANDED_METADATA_LEN {\n                Option::none()\n            } else {\n                Option::some(message.get(0))\n            }\n        })\n        .and_then(|msg_expanded_metadata| from_expanded_metadata(msg_expanded_metadata))\n        .map(|(msg_type_id, msg_metadata)| {\n            let msg_content = array::subbvec(message, MESSAGE_EXPANDED_METADATA_LEN);\n            (msg_type_id, msg_metadata, msg_content)\n        })\n}\n\nglobal U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\nfn to_expanded_metadata(msg_type: u64, msg_metadata: u64) -> Field {\n    // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n    // expensive in circuits.\n    let type_field: Field = (msg_type as Field) * U64_SHIFT_MULTIPLIER;\n    let msg_metadata_field = msg_metadata as Field;\n\n    type_field + msg_metadata_field\n}\n\nglobal TWO_POW_128: Field = 2.pow_32(128);\n\n/// Unpacks expanded metadata into (msg_type, msg_metadata). Returns `None` if `input >= 2^128`.\nfn from_expanded_metadata(input: Field) -> Option<(u64, u64)> {\n    if input.lt(TWO_POW_128) {\n        let msg_metadata = (input as u64);\n        let msg_type = ((input - (msg_metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n        // Use division instead of bit shift since bit shifts are expensive in circuits\n        Option::some((msg_type, msg_metadata))\n    } else {\n        Option::none()\n    }\n}\n\nmod tests {\n    use crate::utils::array::subarray::subarray;\n    use super::{\n        decode_message, encode_message, from_expanded_metadata, MAX_MESSAGE_CONTENT_LEN, to_expanded_metadata,\n        TWO_POW_128,\n    };\n\n    global U64_MAX: u64 = (2.pow_32(64) - 1) as u64;\n    global U128_MAX: Field = (2.pow_32(128) - 1);\n\n    #[test]\n    unconstrained fn encode_decode_empty_message(msg_type: u64, msg_metadata: u64) {\n        let encoded = encode_message(msg_type, msg_metadata, []);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_short_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN / 2],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_full_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn to_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let packed = to_expanded_metadata(U64_MAX, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let packed = to_expanded_metadata(U64_MAX, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let packed = to_expanded_metadata(0, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let packed = to_expanded_metadata(0, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn from_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let input = U128_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let input = (U128_MAX - U64_MAX as Field);\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let input = U64_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let input = 0;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn to_from_expanded_metadata(original_msg_type: u64, original_msg_metadata: u64) {\n        let packed = to_expanded_metadata(original_msg_type, original_msg_metadata);\n        let (unpacked_msg_type, unpacked_msg_metadata) = from_expanded_metadata(packed).unwrap();\n\n        assert_eq(original_msg_type, unpacked_msg_type);\n        assert_eq(original_msg_metadata, unpacked_msg_metadata);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_message() {\n        let msg_type_id: u64 = 42;\n        let msg_metadata: u64 = 99;\n        let mut msg_content = [0; MAX_MESSAGE_CONTENT_LEN];\n        for i in 0..MAX_MESSAGE_CONTENT_LEN {\n            msg_content[i] = i as Field;\n        }\n\n        let encoded = encode_message(msg_type_id, msg_metadata, msg_content);\n        let (decoded_type_id, decoded_metadata, decoded_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_type_id, msg_type_id);\n        assert_eq(decoded_metadata, msg_metadata);\n        assert_eq(decoded_content, BoundedVec::from_array(msg_content));\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_message_fails() {\n        let msg_content = [0; MAX_MESSAGE_CONTENT_LEN + 1];\n        let _ = encode_message(0, 0, msg_content);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_message_returns_none() {\n        assert(decode_message(BoundedVec::new()).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_message_with_oversized_metadata_returns_none() {\n        let message = BoundedVec::from_array([TWO_POW_128]);\n        assert(decode_message(message).is_none());\n    }\n}\n"
     },
-    "142": {
+    "146": {
       "function_locations": [
         {
           "name": "extract_many_close_to_uniformly_random_256_bits_using_poseidon2",
@@ -510,78 +506,6 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
       "source": "use crate::protocol::{address::AztecAddress, public_keys::AddressPoint, traits::ToField};\n\nuse crate::{\n    keys::{\n        ecdh_shared_secret::{\n            compute_app_siloed_shared_secret, derive_ecdh_shared_secret, derive_shared_secret_field_mask,\n            derive_shared_secret_subkey,\n        },\n        ephemeral::generate_positive_ephemeral_key_pair,\n    },\n    logging::aztecnr_warn_log_format,\n    messages::{\n        encoding::{\n            EPH_PK_X_SIZE_IN_FIELDS, HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN,\n            MESSAGE_PLAINTEXT_SIZE_IN_BYTES,\n        },\n        encryption::message_encryption::MessageEncryption,\n        logs::arithmetic_generics_utils::{\n            get_arr_of_size__message_bytes__from_PT, get_arr_of_size__message_bytes_padding__from_PT,\n        },\n    },\n    oracle::{aes128_decrypt::try_aes128_decrypt, random::random, shared_secret::get_shared_secret},\n    utils::{\n        array,\n        conversion::{\n            bytes_as_fields::{decode_bytes_from_fields, encode_bytes_as_fields},\n            fields_as_bytes::{encode_fields_as_bytes, try_decode_fields_from_bytes},\n        },\n        point::point_from_x_coord_and_sign,\n    },\n};\n\nuse std::aes128::aes128_encrypt;\n\n/// Computes N close-to-uniformly-random 256 bits from a given app-siloed shared secret.\n///\n/// NEVER re-use the same iv and sym_key. DO NOT call this function more than once with the same s_app.\n///\n/// This function is only known to be safe if s_app is derived from combining a random ephemeral key with an\n/// address point and a contract address. See big comment within the body of the function.\nfn extract_many_close_to_uniformly_random_256_bits_using_poseidon2<let N: u32>(s_app: Field) -> [[u8; 32]; N] {\n    /*\n     * Unsafe because of https://eprint.iacr.org/2010/264.pdf Page 13, Lemma 2 (and the two paragraphs below it).\n    *\n    * If you call this function, you need to be careful and aware of how the arg `s_app` has been derived.\n    *\n    * The paper says that the way you derive aes keys and IVs should be fine with poseidon2 (modelled as a RO),\n    * as long as you _don't_ use Poseidon2 as a PRG to generate the two exponents x & y which multiply to the\n    * shared secret S:\n    *\n    * S = [x*y]*G.\n    *\n    * (Otherwise, you would have to \"key\" poseidon2, i.e. generate a uniformly string K which can be public and\n    * compute Hash(x) as poseidon(K,x)).\n    * In that lemma, k would be 2*254=508, and m would be the number of points on the grumpkin curve (which is\n    * close to r according to the Hasse bound).\n    *\n    * Our shared secret S is [esk * address_sk] * G, and the question is: Can we compute hash(S) using poseidon2\n    * instead of sha256?\n    *\n    * Well, esk is random and not generated with poseidon2, so that's good.\n    * What about address_sk?\n    * Well, address_sk = poseidon2(stuff) + ivsk, so there was some discussion about whether address_sk is\n    * independent of poseidon2. Given that ivsk is random and independent of poseidon2, the address_sk is also\n    * independent of poseidon2.\n    *\n    * Tl;dr: we believe it's safe to hash S = [esk * address_sk] * G using poseidon2, in order to derive a\n    * symmetric key.\n    *\n    * If you're calling this function for a differently-derived `s_app`, be careful.\n    */\n    \n\n    /* The output of this function needs to be 32 random bytes.\n     * A single field won't give us 32 bytes of entropy. So we compute two \"random\" fields, by poseidon-hashing\n    * with two different indices. We then extract the last 16 (big endian) bytes of each \"random\" field.\n    * Note: we use to_be_bytes because it's slightly more efficient. But we have to be careful not to take bytes\n    * from the \"big end\", because the \"big\" byte is not uniformly random over the byte: it only has < 6 bits of\n    * randomness, because it's the big end of a 254-bit field element.\n    */\n\n    let mut all_bytes: [[u8; 32]; N] = std::mem::zeroed();\n    std::static_assert(N < 256, \"N too large\");\n    for k in 0..N {\n        let rand1: Field = derive_shared_secret_subkey(s_app, 2 * k);\n        let rand2: Field = derive_shared_secret_subkey(s_app, 2 * k + 1);\n\n        let rand1_bytes: [u8; 32] = rand1.to_be_bytes();\n        let rand2_bytes: [u8; 32] = rand2.to_be_bytes();\n\n        let mut bytes: [u8; 32] = [0; 32];\n        for i in 0..16 {\n            // We take bytes from the \"little end\" of the be-bytes arrays:\n            let j = 32 - i - 1;\n            bytes[i] = rand1_bytes[j];\n            bytes[16 + i] = rand2_bytes[j];\n        }\n\n        all_bytes[k] = bytes;\n    }\n\n    all_bytes\n}\n\nfn derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits<let N: u32>(\n    many_random_256_bits: [[u8; 32]; N],\n) -> [([u8; 16], [u8; 16]); N] {\n    // Many (sym_key, iv) pairs:\n    let mut many_pairs: [([u8; 16], [u8; 16]); N] = std::mem::zeroed();\n    for k in 0..N {\n        let random_256_bits = many_random_256_bits[k];\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n        for i in 0..16 {\n            sym_key[i] = random_256_bits[i];\n            iv[i] = random_256_bits[i + 16];\n        }\n        many_pairs[k] = (sym_key, iv);\n    }\n\n    many_pairs\n}\n\npub fn derive_aes_symmetric_key_and_iv_from_shared_secret<let N: u32>(s_app: Field) -> [([u8; 16], [u8; 16]); N] {\n    let many_random_256_bits: [[u8; 32]; N] = extract_many_close_to_uniformly_random_256_bits_using_poseidon2(s_app);\n\n    derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits(many_random_256_bits)\n}\n\npub struct AES128 {}\n\nimpl MessageEncryption for AES128 {\n\n    /// AES128-CBC encryption for Aztec protocol messages.\n    ///\n    /// ## Overview\n    ///\n    /// The plaintext is an array of up to `MESSAGE_PLAINTEXT_LEN` (12) fields. The output is always exactly\n    /// `MESSAGE_CIPHERTEXT_LEN` (15) fields, regardless of plaintext size. All output fields except the\n    /// ephemeral public key are uniformly random `Field` values to any observer without knowledge of the\n    /// shared secret, making all encrypted messages indistinguishable by size or content.\n    ///\n    /// ## PKCS#7 Padding\n    ///\n    /// AES operates on 16-byte blocks, so the plaintext must be padded to a multiple of 16. PKCS#7 padding always\n    /// adds at least 1 byte (so the receiver can always detect and strip it), which means:\n    /// - 1 B plaintext  -> 15 B padding -> 16 B total\n    /// - 15 B plaintext ->  1 B padding -> 16 B total\n    /// - 16 B plaintext -> 16 B padding -> 32 B total (full extra block)\n    ///\n    /// In general: if the plaintext is already a multiple of 16, a full 16-byte padding block is appended.\n    ///\n    /// ## Encryption Steps\n    ///\n    /// **1. Body encryption.** The plaintext fields are serialized to bytes (32 bytes per field) and AES-128-CBC\n    /// encrypted. Since 32 is a multiple of 16, PKCS#7 always adds a full 16-byte padding block (see above):\n    ///\n    /// ```text\n    /// +---------------------------------------------+\n    /// |                   body ct                    |\n    /// |            PlaintextLen*32 + 16 B            |\n    /// +-------------------------------+--------------+\n    /// | encrypted plaintext fields    | PKCS#7 (16B) |\n    /// | (serialized at 32 B each)     |              |\n    /// +-------------------------------+--------------+\n    /// ```\n    ///\n    /// **2. Header encryption.** The byte length of `body_ct` is stored as a 2-byte big-endian integer. This 2-byte\n    /// header plaintext is then AES-encrypted; PKCS#7 pads the remaining 14 bytes to fill one 16-byte AES block,\n    /// producing a 16-byte header ciphertext:\n    ///\n    /// ```text\n    /// +---------------------------+\n    /// |         header ct         |\n    /// |            16 B           |\n    /// +--------+------------------+\n    /// | body ct| PKCS#7 (14B)     |\n    /// | length |                  |\n    /// | (2 B)  |                  |\n    /// +--------+------------------+\n    /// ```\n    ///\n    /// ## Wire Format\n    ///\n    /// Messages are transmitted as fields, not bytes. A field is ~254 bits and can safely store 31 whole bytes, so\n    /// we need to pack our byte data into 31-byte chunks. This packing drives the wire format.\n    ///\n    /// **Step 1 -- Assemble bytes.** The ciphertexts are laid out in a byte array, padded with zero bytes to a\n    /// multiple of 31 so it divides evenly into fields:\n    ///\n    /// ```text\n    /// +------------+-------------------------+---------+\n    /// | header ct  |        body ct          | byte pad|\n    /// |   16 B     | PlaintextLen*32 + 16 B  | (zeros) |\n    /// +------------+-------------------------+---------+\n    /// |<-------- padded to a multiple of 31 B -------->|\n    /// ```\n    ///\n    /// **Step 2 -- Pack and mask.** The byte array is split into 31-byte chunks, each stored in one field. A\n    /// Poseidon2-derived mask (see `derive_shared_secret_field_mask`) is added to each so that the resulting\n    /// fields appear as uniformly random `Field` values to any observer without knowledge of the shared secret,\n    /// hiding the fact that the underlying ciphertext consists of 128-bit AES blocks.\n    ///\n    /// **Step 3 -- Assemble ciphertext.** The ephemeral public key x-coordinate is prepended and random field padding\n    /// is appended to fill to 15 fields:\n    ///\n    /// ```text\n    /// +----------+-------------------------+-------------------+\n    /// | eph_pk.x |  masked message fields   | random field pad  |\n    /// |          | (packed 31 B per field)  |  (fills to 15)    |\n    /// +----------+-------------------------+-------------------+\n    /// |<---------- MESSAGE_CIPHERTEXT_LEN = 15 fields -------->|\n    /// ```\n    ///\n    /// ## Key Derivation\n    ///\n    /// The raw ECDH shared secret point is first app-siloed into a scalar `s_app` by hashing with the contract\n    /// address (see\n    /// [`compute_app_siloed_shared_secret`](crate::keys::ecdh_shared_secret::compute_app_siloed_shared_secret)).\n    /// Two (key, IV) pairs are then derived from `s_app` via indexed Poseidon2 hashing: one pair for the body\n    /// ciphertext and one for the header ciphertext.\n    fn encrypt<let PlaintextLen: u32>(\n        plaintext: [Field; PlaintextLen],\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> [Field; MESSAGE_CIPHERTEXT_LEN] {\n        std::static_assert(\n            PlaintextLen <= MESSAGE_PLAINTEXT_LEN,\n            \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\",\n        );\n\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes. (This process is then\n        // reversed when processing the message in `process_message_ciphertext`)\n        let plaintext_bytes = encode_fields_as_bytes(plaintext);\n\n        // Derive ECDH shared secret with recipient using a fresh ephemeral keypair.\n        let (eph_sk, eph_pk) = generate_positive_ephemeral_key_pair();\n\n        let raw_shared_secret = derive_ecdh_shared_secret(\n            eph_sk,\n            recipient\n                .to_address_point()\n                .unwrap_or_else(|| {\n                    aztecnr_warn_log_format!(\n                        \"Attempted to encrypt message for an invalid recipient ({0})\",\n                    )(\n                        [recipient.to_field()],\n                    );\n\n                    // Safety: if the recipient is an invalid address, then it is not possible to encrypt a message for\n                    // them because we cannot establish a shared secret. This is never expected to occur during normal\n                    // operation. However, it is technically possible for us to receive an invalid address, and we must\n                    // therefore handle it. We could simply fail, but that'd introduce a potential security issue in\n                    // which an attacker forces a contract to encrypt a message for an invalid address, resulting in an\n                    // impossible transaction - this is sometimes called a 'king of the hill' attack. We choose instead\n                    // to not fail and encrypt the plaintext regardless using the shared secret that results from a\n                    // random valid address. The sender is free to choose this address and hence shared secret, but\n                    // this has no security implications as they already know not only the full plaintext but also the\n                    // ephemeral private key anyway.\n                    unsafe {\n                        random_address_point()\n                    }\n                })\n                .inner,\n        );\n\n        let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n        // It is safe to derive AES keys from `s_app` using Poseidon2 because `s_app` was derived from an ECDH shared\n        // secret using an AztecAddress (the recipient). See the block comment in\n        // `extract_many_close_to_uniformly_random_256_bits_using_poseidon2` for more info.\n        let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, body_iv, body_sym_key);\n\n        // Each plaintext field is 32 bytes (a multiple of the 16-byte AES block\n        // size), so PKCS#7 always appends a full 16-byte padding block:\n        //   |ciphertext| = PlaintextLen*32 + 16 = 16 * (1 + PlaintextLen*32 / 16)\n        std::static_assert(\n            ciphertext_bytes.len() == 16 * (1 + (PlaintextLen * 32) / 16),\n            \"unexpected ciphertext length\",\n        );\n\n        // Encrypt a 2-byte header containing the body ciphertext length.\n        let header_plaintext = encode_header(ciphertext_bytes.len());\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the input, according to pkcs#7; hence why\n        // the output `header_ciphertext_bytes` is 16 bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, header_iv, header_sym_key);\n        // Verify expected header ciphertext size at compile time.\n        std::static_assert(\n            header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n            \"unexpected ciphertext header length\",\n        );\n\n        // Assemble the message byte array:\n        //  [header_ct (16B)] [body_ct] [padding to mult of 31]\n        let message_bytes_padding_to_mult_31 = get_arr_of_size__message_bytes_padding__from_PT::<PlaintextLen * 32>();\n\n        let mut message_bytes = get_arr_of_size__message_bytes__from_PT::<PlaintextLen * 32>();\n\n        std::static_assert(\n            message_bytes.len() % 31 == 0,\n            \"Unexpected error: message_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        let mut offset = 0;\n        for i in 0..header_ciphertext_bytes.len() {\n            message_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            message_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..message_bytes_padding_to_mult_31.len() {\n            message_bytes[offset + i] = message_bytes_padding_to_mult_31[i];\n        }\n        offset += message_bytes_padding_to_mult_31.len();\n\n        // Ideally we would be able to have a static assert where we check that the offset would be such that we've\n        // written to the entire log_bytes array, but we cannot since Noir does not treat the offset as a comptime\n        // value (despite the values that it goes through being known at each stage). We instead check that the\n        // computation used to obtain the offset computes the expected value (which we _can_ do in a static check), and\n        // then add a cheap runtime check to also validate that the offset matches this.\n        std::static_assert(\n            header_ciphertext_bytes.len() + ciphertext_bytes.len() + message_bytes_padding_to_mult_31.len()\n                == message_bytes.len(),\n            \"unexpected message length\",\n        );\n        assert(offset == message_bytes.len(), \"unexpected encrypted message length\");\n\n        // Pack message bytes into fields (31 bytes per field) and prepend eph_pk.x.\n        let message_bytes_as_fields = encode_bytes_as_fields(message_bytes);\n\n        let mut ciphertext: [Field; MESSAGE_CIPHERTEXT_LEN] = [0; MESSAGE_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        // Mask each content field with a Poseidon2-derived value, so that they appear as uniformly random `Field`\n        // values\n        let mut offset = 1;\n        for i in 0..message_bytes_as_fields.len() {\n            let mask = derive_shared_secret_field_mask(s_app, i as u32);\n            ciphertext[offset + i] = message_bytes_as_fields[i] + mask;\n        }\n        offset += message_bytes_as_fields.len();\n\n        // Pad with random fields so that padding is indistinguishable from masked data fields.\n        for i in offset..MESSAGE_CIPHERTEXT_LEN {\n            // Safety: we assume that the sender wants for the message to be private - a malicious one could simply\n            // reveal its contents publicly. It is therefore fine to trust the sender to provide random padding.\n            ciphertext[i] = unsafe { random() };\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt(\n        ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> Option<BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>> {\n        // Extract the ephemeral public key x-coordinate and masked fields, returning None for empty ciphertext.\n        if ciphertext.len() > 0 {\n            let masked_fields: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS> =\n                array::subbvec(ciphertext, EPH_PK_X_SIZE_IN_FIELDS);\n            Option::some((ciphertext.get(0), masked_fields))\n        } else {\n            Option::none()\n        }\n            .and_then(|(eph_pk_x, masked_fields)| {\n                // With the x-coordinate of the ephemeral public key we can reconstruct the point as we know that the\n                // y-coordinate must be positive. This may fail however, as not all x-coordinates are on the curve. In\n                // that case, we simply return `Option::none`.\n                point_from_x_coord_and_sign(eph_pk_x, true).and_then(|eph_pk| {\n                    let s_app = get_shared_secret(recipient, eph_pk, contract_address);\n\n                    let unmasked_fields = masked_fields.mapi(|i, field| {\n                        let unmasked = unmask_field(s_app, i, field);\n                        // If we failed to unmask the field, we are dealing with the random padding. We'll ignore it\n                        // later, so we can simply set it to 0\n                        unmasked.unwrap_or(0)\n                    });\n                    let ciphertext_without_eph_pk_x = decode_bytes_from_fields(unmasked_fields);\n\n                    // Derive symmetric keys:\n                    let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n                    let (body_sym_key, body_iv) = pairs[0];\n                    let (header_sym_key, header_iv) = pairs[1];\n\n                    // Extract the header ciphertext\n                    let header_start = 0;\n                    let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n                        array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n                    // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's\n                    // designed to work with messages with unknown length at compile time. This would not be necessary\n                    // here as the header ciphertext length is fixed. But we do it anyway to not have to have duplicate\n                    // oracles.\n                    let header_ciphertext_bvec =\n                        BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n                    try_aes128_decrypt(header_ciphertext_bvec, header_iv, header_sym_key)\n                    // Extract ciphertext length from header (2 bytes, big-endian)\n                    .and_then(|header_plaintext| extract_ciphertext_length(header_plaintext))\n                        .filter(|ciphertext_length| ciphertext_length <= MESSAGE_PLAINTEXT_SIZE_IN_BYTES)\n                        .map(|ciphertext_length| {\n                            // Extract and decrypt main ciphertext\n                            let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n                            let ciphertext_with_padding: [u8; MESSAGE_PLAINTEXT_SIZE_IN_BYTES] =\n                                array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n                            BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length)\n                        })\n                        // Decrypt main ciphertext and return it\n                        .and_then(|ciphertext| try_aes128_decrypt(ciphertext, body_iv, body_sym_key))\n                        // Convert bytes back to fields (32 bytes per field). Returns None if the actual bytes are\n                        // not valid.\n                        .and_then(|plaintext_bytes| try_decode_fields_from_bytes(plaintext_bytes))\n                })\n            })\n    }\n}\n\n/// Encodes the body ciphertext length into a 2-byte big-endian header.\nfn encode_header(ciphertext_length: u32) -> [u8; 2] {\n    [(ciphertext_length >> 8) as u8, ciphertext_length as u8]\n}\n\n/// Extracts the body ciphertext length from a decrypted header as a 2-byte big-endian integer.\n///\n/// Returns `Option::none()` if the header has fewer than 2 bytes.\nunconstrained fn extract_ciphertext_length<let N: u32>(header: BoundedVec<u8, N>) -> Option<u32> {\n    if header.len() >= 2 {\n        Option::some(((header.get(0) as u32) << 8) | (header.get(1) as u32))\n    } else {\n        Option::none()\n    }\n}\n\n/// 2^248: upper bound for values that fit in 31 bytes\nglobal TWO_POW_248: Field = 2.pow_32(248);\n\n/// Removes the Poseidon2-derived mask from a ciphertext field. Returns the unmasked value if it fits in 31 bytes\n/// (a content field), or `None` if it doesn't (random padding). Unconstrained to prevent accidental use in\n/// constrained context.\nunconstrained fn unmask_field(s_app: Field, index: u32, masked: Field) -> Option<Field> {\n    let unmasked = masked - derive_shared_secret_field_mask(s_app, index);\n    if unmasked.lt(TWO_POW_248) {\n        Option::some(unmasked)\n    } else {\n        Option::none()\n    }\n}\n\n/// Produces a random valid address point, i.e. one that is on the curve. This is equivalent to calling\n/// [`AztecAddress::to_address_point`] on a random valid address.\nunconstrained fn random_address_point() -> AddressPoint {\n    let mut result = std::mem::zeroed();\n\n    loop {\n        // We simply produce random x coordinates until we find one that is on the curve. About half of the x\n        // coordinates fulfill this condition, so this should only take a few iterations at most.\n        let x_coord = random();\n        let point = point_from_x_coord_and_sign(x_coord, true);\n        if point.is_some() {\n            result = AddressPoint { inner: point.unwrap() };\n            break;\n        }\n    }\n\n    result\n}\n\nmod test {\n    use crate::{\n        ephemeral::EphemeralArray,\n        keys::ecdh_shared_secret::{compute_app_siloed_shared_secret, derive_ecdh_shared_secret},\n        messages::{\n            encoding::{HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_PLAINTEXT_LEN, MESSAGE_PLAINTEXT_SIZE_IN_BYTES},\n            encryption::message_encryption::MessageEncryption,\n        },\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use super::{AES128, encode_header, random_address_point};\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt_deterministic() {\n        let env = TestEnvironment::new();\n\n        // Message decryption requires oracles that are only available during private execution\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n\n            let recipient = AztecAddress::from_field(\n                0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n            );\n\n            // Mock random values for deterministic test\n            let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n            let _ = OracleMock::mock(\"aztec_misc_getRandomField\").returns(eph_sk).times(1);\n\n            let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n            let _ = OracleMock::mock(\"aztec_misc_getRandomField\").returns(randomness).times(1000000);\n\n            // Encrypt the message\n            let encrypted_message = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            // Compute the same app-siloed shared secret that the oracle would return\n            let raw_shared_secret = derive_ecdh_shared_secret(\n                EmbeddedCurveScalar::from_field(eph_sk),\n                recipient.to_address_point().unwrap().inner,\n            );\n            let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n            // The shared-secrets oracle is batched: it returns a slot pointing at an EphemeralArray\n            // populated with the per-key results. Set up that array with the single expected `s_app`\n            // and mock the oracle to return its slot.\n            let response_slot: Field = 99;\n            let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n            response_array.push(s_app);\n            let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n\n            // Decrypt the message\n            let decrypted = AES128::decrypt(encrypted_message, recipient, contract_address).unwrap();\n\n            // The decryption function spits out a BoundedVec because it's designed to work with messages with unknown\n            // length at compile time. For this reason we need to convert the original input to a BoundedVec.\n            let plaintext_bvec = BoundedVec::<Field, MESSAGE_PLAINTEXT_LEN>::from_array(plaintext);\n\n            // Verify decryption matches original plaintext\n            assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n            // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n            // static methods of the struct).\n            let _ = AES128 {};\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_random() {\n        // Same as `encrypt_decrypt_deterministic`, except we don't mock any of the oracles and rely on\n        // `TestEnvironment` instead.\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_to_invalid_address() {\n        // x = 3 is a non-residue for this curve, resulting in an invalid address\n        let invalid_address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n\n        let _ = AES128::encrypt([1, 2, 3, 4], invalid_address, contract_address);\n    }\n\n    // Documents the PKCS#7 padding behavior that `encrypt` relies on (see its static_assert).\n    #[test]\n    fn pkcs7_padding_always_adds_at_least_one_byte() {\n        let key = [0 as u8; 16];\n        let iv = [0 as u8; 16];\n\n        // 1 byte input + 15 bytes padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 1], iv, key).len(), 16);\n\n        // 15 bytes input + 1 byte padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 15], iv, key).len(), 16);\n\n        // 16 bytes input (block-aligned) + full 16-byte padding block = 32 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 16], iv, key).len(), 32);\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_max_size_plaintext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let mut plaintext = [0; MESSAGE_PLAINTEXT_LEN];\n            for i in 0..MESSAGE_PLAINTEXT_LEN {\n                plaintext[i] = i as Field;\n            }\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test(should_fail_with = \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\")]\n    unconstrained fn encrypt_oversized_plaintext() {\n        let address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n        let plaintext: [Field; MESSAGE_PLAINTEXT_LEN + 1] = [0; MESSAGE_PLAINTEXT_LEN + 1];\n        let _ = AES128::encrypt(plaintext, address, contract_address);\n    }\n\n    #[test]\n    unconstrained fn random_address_point_produces_valid_points() {\n        // About half of random addresses are invalid, so testing just a couple gives us high confidence that\n        // `random_address_point` is indeed producing valid addresses.\n        for _ in 0..10 {\n            let random_address = AztecAddress { inner: random_address_point().inner.x };\n            assert(random_address.to_address_point().is_some());\n        }\n    }\n\n    #[test]\n    unconstrained fn decrypt_invalid_ephemeral_public_key() {\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3, 4];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            // The first field of the ciphertext is the x-coordinate of the ephemeral public key. We set it to a known\n            // non-residue (3), causing `decrypt` to fail to produce a decryption shared secret.\n            let mut bad_ciphertext = BoundedVec::from_array(ciphertext);\n            bad_ciphertext.set(0, 3);\n\n            assert(AES128::decrypt(bad_ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_ciphertext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            assert(AES128::decrypt(BoundedVec::new(), recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header AES decrypt oracle to return an empty result. The TS oracle never throws on invalid\n    // input: it decrypts to garbage bytes or returns empty\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_header() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let empty_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::new();\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(empty_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header oracle to return a 2-byte header that decodes to a ciphertext_length one past the maximum\n    // allowed value, verifying the edge case is handled correctly.\n    #[test]\n    unconstrained fn decrypt_returns_none_on_oversized_ciphertext_length() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let bad_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(encode_header(\n                MESSAGE_PLAINTEXT_SIZE_IN_BYTES + 1,\n            ));\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(bad_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n}\n"
     },
-    "147": {
-      "function_locations": [
-        {
-          "name": "encode_private_event_message",
-          "start": 1377
-        },
-        {
-          "name": "decode_private_event_message",
-          "start": 3755
-        },
-        {
-          "name": "test::encode_decode",
-          "start": 5127
-        },
-        {
-          "name": "test::decode_empty_content_returns_none",
-          "start": 5869
-        },
-        {
-          "name": "test::decode_with_only_reserved_fields_returns_none",
-          "start": 6064
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
-      "source": "use crate::{\n    event::{event_interface::EventInterface, EventSelector},\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n    },\n    utils::array,\n};\nuse crate::protocol::traits::{FromField, Serialize, ToField};\n\n/// The number of fields in a private event message content that are not the event's serialized representation (1 field\n/// for randomness).\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 1;\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 0;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_event_message`].\npub fn encode_private_event_message<Event>(\n    event: Event,\n    randomness: Field,\n) -> [Field; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Event: EventInterface + Serialize,\n{\n    std::static_assert(\n        <Event as Serialize>::N <= MAX_EVENT_SERIALIZED_LEN,\n        \"event's serialized length exceeds the maximum allowed for private events\",\n    );\n\n    // We use `Serialize` because we want for events to be processable by off-chain actors, e.g. block explorers,\n    // wallets and apps, without having to rely on contract invocation. If we used `Packable` we'd need to call utility\n    // functions in order to unpack events, which would introduce a level of complexity we don't currently think is\n    // worth the savings in DA (for public events) and proving time (when encrypting private event messages).\n    let serialized_event = event.serialize();\n\n    // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_plaintext = [0; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N];\n    msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n\n    for i in 0..serialized_event.len() {\n        msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = serialized_event[i];\n    }\n\n    // The event type id is stored in the message metadata\n    encode_message(\n        PRIVATE_EVENT_MSG_TYPE_ID,\n        Event::get_event_type_id().to_field() as u64,\n        msg_plaintext,\n    )\n}\n\n/// Decodes the plaintext from a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_event_message`].\n///\n/// Note that while [`encode_private_event_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_event_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(EventSelector, Field, BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>)> {\n    if msg_content.len() <= PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n        // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // destructuring of the private event message encoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n            \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let randomness = msg_content.get(PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let serialized_event = array::subbvec(msg_content, PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((event_type_id, randomness, serialized_event))\n    }\n}\n\nmod test {\n    use crate::{\n        event::event_interface::EventInterface,\n        messages::{\n            encoding::decode_message,\n            logs::event::{decode_private_event_message, encode_private_event_message},\n            msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n        },\n    };\n    use crate::protocol::traits::Serialize;\n    use crate::test::mocks::mock_event::MockEvent;\n\n    global VALUE: Field = 7;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let event = MockEvent::new(VALUE).build_event();\n\n        let message_plaintext = encode_private_event_message(event, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_EVENT_MSG_TYPE_ID);\n\n        let (event_type_id, randomness, serialized_event) =\n            decode_private_event_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(event_type_id, MockEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event, BoundedVec::from_array(event.serialize()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_event_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0]);\n        assert(decode_private_event_message(0, content).is_none());\n    }\n}\n"
-    },
-    "149": {
-      "function_locations": [
-        {
-          "name": "encode_private_note_message_with_msg_type_id",
-          "start": 1652
-        },
-        {
-          "name": "encode_private_note_message",
-          "start": 3078
-        },
-        {
-          "name": "decode_private_note_message",
-          "start": 4069
-        },
-        {
-          "name": "test::encode_decode",
-          "start": 5757
-        },
-        {
-          "name": "test::<impl NoteType for MaxSizeNote>::get_id",
-          "start": 6680
-        },
-        {
-          "name": "test::encode_decode_max_size_note",
-          "start": 6776
-        },
-        {
-          "name": "test::<impl NoteType for OversizedNote>::get_id",
-          "start": 7792
-        },
-        {
-          "name": "test::encode_oversized_note_fails",
-          "start": 7978
-        },
-        {
-          "name": "test::decode_empty_content_returns_none",
-          "start": 8213
-        },
-        {
-          "name": "test::decode_with_only_reserved_fields_returns_none",
-          "start": 8407
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
-      "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\n\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX: u32 = 1;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 2;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, randomness, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private note message with the given `msg_type_id`.\n///\n/// Shared encoder used by [`encode_private_note_message`] and by custom message handlers that use the same format as\n/// standard private note message but perform additional validation logic.\npub fn encode_private_note_message_with_msg_type_id<Note>(\n    msg_type_id: u64,\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    let packed_note = note.pack();\n\n    // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_content = [0; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N];\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX] = storage_slot;\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    for i in 0..packed_note.len() {\n        msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_note[i];\n    }\n\n    // Notes use the note type id for metadata\n    encode_message(msg_type_id, Note::get_id() as u64, msg_content)\n}\n\n/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_note_message`].\npub fn encode_private_note_message<Note>(\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    encode_private_note_message_with_msg_type_id(\n        PRIVATE_NOTE_MSG_TYPE_ID,\n        note,\n        owner,\n        storage_slot,\n        randomness,\n    )\n}\n\n/// Decodes the plaintext from a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_note_message`].\n///\n/// Note that while [`encode_private_note_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_note_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(Field, AztecAddress, Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>)> {\n    if msg_content.len() <= PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // decoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let owner = AztecAddress::from_field(msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX));\n        let storage_slot = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX);\n        let randomness = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((note_type_id, owner, storage_slot, randomness, packed_note))\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::note::{decode_private_note_message, encode_private_note_message, MAX_NOTE_PACKED_LEN},\n            msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global STORAGE_SLOT: Field = 9;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[derive(Packable)]\n    struct MaxSizeNote {\n        data: [Field; MAX_NOTE_PACKED_LEN],\n    }\n\n    impl NoteType for MaxSizeNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_note() {\n        let mut data = [0; MAX_NOTE_PACKED_LEN];\n        for i in 0..MAX_NOTE_PACKED_LEN {\n            data[i] = i as Field;\n        }\n        let note = MaxSizeNote { data };\n\n        let encoded = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n        let (msg_type_id, msg_metadata, msg_content) = decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MaxSizeNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(data));\n    }\n\n    #[derive(Packable)]\n    struct OversizedNote {\n        data: [Field; MAX_NOTE_PACKED_LEN + 1],\n    }\n\n    impl NoteType for OversizedNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_note_fails() {\n        let note = OversizedNote { data: [0; MAX_NOTE_PACKED_LEN + 1] };\n        let _ = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_note_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        assert(decode_private_note_message(0, content).is_none());\n    }\n}\n"
-    },
     "15": {
       "function_locations": [
         {
@@ -652,75 +576,125 @@
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n    use crate::internal::test_unconstrained;\n    use super::assert_lt;\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    #[test_unconstrained]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert_lt(0, 1);\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
     },
-    "150": {
+    "151": {
       "function_locations": [
         {
-          "name": "encode_partial_note_private_message",
-          "start": 1715
+          "name": "encode_private_event_message",
+          "start": 1377
         },
         {
-          "name": "decode_partial_note_private_message",
-          "start": 3810
+          "name": "decode_private_event_message",
+          "start": 3755
         },
         {
           "name": "test::encode_decode",
-          "start": 6022
+          "start": 5127
         },
         {
           "name": "test::decode_empty_content_returns_none",
-          "start": 6999
+          "start": 5869
         },
         {
-          "name": "test::decode_succeeds_with_only_reserved_fields",
-          "start": 7197
+          "name": "test::decode_with_only_reserved_fields_returns_none",
+          "start": 6064
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/partial_note.nr",
-      "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 1;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private message\n/// (e.g. the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a partial note private message (i.e. one of type [`PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_partial_note_private_message`].\npub fn encode_partial_note_private_message<PartialNotePrivateContent>(\n    partial_note_private_content: PartialNotePrivateContent,\n    owner: AztecAddress,\n    randomness: Field,\n    note_completion_log_tag: Field,\n    ) -> [Field; PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <PartialNotePrivateContent as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    PartialNotePrivateContent: NoteType + Packable,\n{\n    let packed_private_content = partial_note_private_content.pack();\n\n    // If PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then\n    // the encoding below must be updated as well.\n    std::static_assert(\n        PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    let mut msg_content =\n        [0; PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <PartialNotePrivateContent as Packable>::N];\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX] = note_completion_log_tag;\n\n    for i in 0..packed_private_content.len() {\n        msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_private_content[i];\n    }\n\n    encode_message(\n        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n        // Notes use the note type id for metadata\n        PartialNotePrivateContent::get_id() as u64,\n        msg_content,\n    )\n}\n\n/// Decodes the plaintext from a partial note private message (i.e. one of type\n/// [`PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_partial_note_private_message`].\n///\n/// Note that while [`encode_partial_note_private_message`] returns a fixed-size array, this function takes a\n/// [`BoundedVec`] instead. This is because when decoding we're typically processing runtime-sized plaintexts, more\n/// specifically, those that originate from\n/// [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_partial_note_private_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(AztecAddress, Field, Field, Field, BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>)> {\n    if msg_content.len() < PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id: Field = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail,\n        // then the destructuring of the partial note private message encoding below must be updated as well.\n        std::static_assert(\n            PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN\",\n        );\n\n        // We currently have three fields that are not the partial note's packed representation, which are the owner,\n        // the randomness, and the note completion log tag.\n        let owner = AztecAddress::from_field(\n            msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX),\n        );\n        let randomness = msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let note_completion_log_tag = msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX);\n\n        let packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN> = array::subbvec(\n            msg_content,\n            PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN,\n        );\n\n        Option::some(\n            (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content),\n        )\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::partial_note::{decode_partial_note_private_message, encode_partial_note_private_message},\n            msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global RANDOMNESS: Field = 10;\n    global NOTE_COMPLETION_LOG_TAG: Field = 11;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        // Note that here we use MockNote as the private fields of a partial note\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_partial_note_private_message(note, OWNER, RANDOMNESS, NOTE_COMPLETION_LOG_TAG);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID);\n\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_note) =\n            decode_partial_note_private_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(note_completion_log_tag, NOTE_COMPLETION_LOG_TAG);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_partial_note_private_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        let (_, _, _, _, packed_note) = decode_partial_note_private_message(0, content).unwrap();\n        assert_eq(packed_note.len(), 0);\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
+      "source": "use crate::{\n    event::{event_interface::EventInterface, EventSelector},\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n    },\n    utils::array,\n};\nuse crate::protocol::traits::{FromField, Serialize, ToField};\n\n/// The number of fields in a private event message content that are not the event's serialized representation (1 field\n/// for randomness).\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 1;\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 0;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_event_message`].\npub fn encode_private_event_message<Event>(\n    event: Event,\n    randomness: Field,\n) -> [Field; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Event: EventInterface + Serialize,\n{\n    std::static_assert(\n        <Event as Serialize>::N <= MAX_EVENT_SERIALIZED_LEN,\n        \"event's serialized length exceeds the maximum allowed for private events\",\n    );\n\n    // We use `Serialize` because we want for events to be processable by off-chain actors, e.g. block explorers,\n    // wallets and apps, without having to rely on contract invocation. If we used `Packable` we'd need to call utility\n    // functions in order to unpack events, which would introduce a level of complexity we don't currently think is\n    // worth the savings in DA (for public events) and proving time (when encrypting private event messages).\n    let serialized_event = event.serialize();\n\n    // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_plaintext = [0; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N];\n    msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n\n    for i in 0..serialized_event.len() {\n        msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = serialized_event[i];\n    }\n\n    // The event type id is stored in the message metadata\n    encode_message(\n        PRIVATE_EVENT_MSG_TYPE_ID,\n        Event::get_event_type_id().to_field() as u64,\n        msg_plaintext,\n    )\n}\n\n/// Decodes the plaintext from a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_event_message`].\n///\n/// Note that while [`encode_private_event_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_event_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(EventSelector, Field, BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>)> {\n    if msg_content.len() <= PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n        // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // destructuring of the private event message encoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n            \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let randomness = msg_content.get(PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let serialized_event = array::subbvec(msg_content, PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((event_type_id, randomness, serialized_event))\n    }\n}\n\nmod test {\n    use crate::{\n        event::event_interface::EventInterface,\n        messages::{\n            encoding::decode_message,\n            logs::event::{decode_private_event_message, encode_private_event_message},\n            msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n        },\n    };\n    use crate::protocol::traits::Serialize;\n    use crate::test::mocks::mock_event::MockEvent;\n\n    global VALUE: Field = 7;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let event = MockEvent::new(VALUE).build_event();\n\n        let message_plaintext = encode_private_event_message(event, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_EVENT_MSG_TYPE_ID);\n\n        let (event_type_id, randomness, serialized_event) =\n            decode_private_event_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(event_type_id, MockEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event, BoundedVec::from_array(event.serialize()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_event_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0]);\n        assert(decode_private_event_message(0, content).is_none());\n    }\n}\n"
     },
-    "159": {
+    "153": {
       "function_locations": [
         {
-          "name": "enqueue_note_for_validation",
-          "start": 3744
+          "name": "encode_private_note_message_with_msg_type_id",
+          "start": 1652
         },
         {
-          "name": "enqueue_event_for_validation",
-          "start": 5107
+          "name": "encode_private_note_message",
+          "start": 3078
         },
         {
-          "name": "validate_and_store_enqueued_notes_and_events",
-          "start": 5775
+          "name": "decode_private_note_message",
+          "start": 4069
         },
         {
-          "name": "get_pending_partial_notes_completion_logs",
-          "start": 7073
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
-      "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\nmod message_context;\npub use message_context::MessageContext;\n\nmod note_validation_request;\npub use note_validation_request::NoteValidationRequest;\n\npub mod log_retrieval_request;\npub mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\npub(crate) mod provided_secret;\n\nuse crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\n        discovery::partial_notes::DeliveredPendingPartialNote,\n        encoding::MESSAGE_CIPHERTEXT_LEN,\n        logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},\n        processing::{log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse},\n    },\n    oracle::message_processing,\n};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n    hash::{compute_log_tag, sha256_to_field},\n    traits::{Deserialize, Serialize},\n};\nuse event_validation_request::EventValidationRequest;\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// An offchain-delivered message with resolved context, ready for processing during sync.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessageWithContext {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub message_context: MessageContext,\n}\n\n/// Enqueues a note for validation and storage by PXE.\n///\n/// Once validated, the note becomes retrievable via the `get_notes` oracle. The note will be scoped to\n/// `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many note validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value is\n/// typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are the\n/// inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and `NoteHash::compute_nullifier`. PXE\n/// will verify that the siloed unique note hash was inserted into the tree at `tx_hash`, and will store the nullifier\n/// to later check for nullification.\n///\n/// `owner` is the address used in note hash and nullifier computation, often requiring knowledge of their nullifier\n/// secret key.\n///\n/// `scope` is the account to which the note message was delivered (i.e. the address the message was encrypted to).\n/// This determines which PXE account can see the note - other accounts will not be able to access it (e.g. other\n/// accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized. In\n/// most cases `recipient` equals `owner`, but they can differ in scenarios like delegated discovery.\npub unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(NoteValidationRequest::new(\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n    ))\n}\n\n/// Enqueues an event for validation and storage by PXE.\n///\n/// This is the primary way for custom message handlers (registered via\n/// [`crate::macros::AztecConfig::custom_message_handler`]) to deliver reassembled events back to PXE after processing\n/// application-specific message formats.\n///\n/// In order for the event validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many event validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// Note that `validate_and_store_enqueued_notes_and_events` is called by Aztec.nr after processing messages, so custom\n/// message processors do not need to be concerned with this.\npub unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    randomness: Field,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(EventValidationRequest::new(\n        contract_address,\n        event_type_id,\n        randomness,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n    ))\n}\n\n/// Validates and stores all enqueued notes and events.\n///\n/// Processes all requests enqueued via [`enqueue_note_for_validation`] and [`enqueue_event_for_validation`], inserting\n/// them into the note database and event store respectively, making them queryable via `get_notes` oracle and our TS\n/// API (PXE::getPrivateEvents).\npub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAddress) {\n    message_processing::validate_and_store_enqueued_notes_and_events(\n        EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        scope,\n    );\n\n    // Defensive clearing: purge the queues after processing to prevent double-processing if this function is called\n    // more than once in the same call frame. It is currently defensive because we only call this once per sync run.\n    let _ = EphemeralArray::<NoteValidationRequest>::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n    let _ = EphemeralArray::<EventValidationRequest>::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a nested `EphemeralArray`, one inner\n/// array per pending partial note, each containing all matching `LogRetrievalResponse`s (which may be empty if no\n/// logs were found).\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    let log_retrieval_requests = EphemeralArray::at(LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the EphemeralArray. Because we need the indices\n    // in the request array to match the indices in the partial note array, we can't use EphemeralArray::for_each, as\n    // that function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push\n    // into the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        // Partial note completion logs are emitted with a domain-separated tag. To find matching logs, we apply the\n        // same domain separation to the stored raw tag.\n        let log_tag = compute_log_tag(\n            pending_partial_note.note_completion_log_tag,\n            DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n        );\n        log_retrieval_requests.push(LogRetrievalRequest::new(contract_address, log_tag));\n        i += 1;\n    }\n\n    let responses = message_processing::get_logs_by_tag(log_retrieval_requests);\n\n    // Defensive clearing: prevent stale requests if this function is called more than once in the same call frame.\n    let _ = log_retrieval_requests.clear();\n\n    responses\n}\n"
-    },
-    "16": {
-      "function_locations": [
-        {
-          "name": "Field::assert_max_bit_size",
-          "start": 380
+          "name": "test::encode_decode",
+          "start": 5757
         },
         {
-          "name": "Field::to_le_bits",
-          "start": 1196
+          "name": "test::<impl NoteType for MaxSizeNote>::get_id",
+          "start": 6680
         },
         {
-          "name": "Field::to_be_bits",
-          "start": 2387
+          "name": "test::encode_decode_max_size_note",
+          "start": 6776
         },
         {
-          "name": "Field::to_le_bytes",
-          "start": 3562
+          "name": "test::<impl NoteType for OversizedNote>::get_id",
+          "start": 7792
         },
         {
-          "name": "Field::to_be_bytes",
-          "start": 5033
+          "name": "test::encode_oversized_note_fails",
+          "start": 7978
+        },
+        {
+          "name": "test::decode_empty_content_returns_none",
+          "start": 8213
+        },
+        {
+          "name": "test::decode_with_only_reserved_fields_returns_none",
+          "start": 8407
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
+      "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\n\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX: u32 = 1;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 2;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, randomness, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private note message with the given `msg_type_id`.\n///\n/// Shared encoder used by [`encode_private_note_message`] and by custom message handlers that use the same format as\n/// standard private note message but perform additional validation logic.\npub fn encode_private_note_message_with_msg_type_id<Note>(\n    msg_type_id: u64,\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    let packed_note = note.pack();\n\n    // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_content = [0; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N];\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX] = storage_slot;\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    for i in 0..packed_note.len() {\n        msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_note[i];\n    }\n\n    // Notes use the note type id for metadata\n    encode_message(msg_type_id, Note::get_id() as u64, msg_content)\n}\n\n/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_note_message`].\npub fn encode_private_note_message<Note>(\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    encode_private_note_message_with_msg_type_id(\n        PRIVATE_NOTE_MSG_TYPE_ID,\n        note,\n        owner,\n        storage_slot,\n        randomness,\n    )\n}\n\n/// Decodes the plaintext from a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_note_message`].\n///\n/// Note that while [`encode_private_note_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_note_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(Field, AztecAddress, Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>)> {\n    if msg_content.len() <= PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // decoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let owner = AztecAddress::from_field(msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX));\n        let storage_slot = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX);\n        let randomness = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((note_type_id, owner, storage_slot, randomness, packed_note))\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::note::{decode_private_note_message, encode_private_note_message, MAX_NOTE_PACKED_LEN},\n            msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global STORAGE_SLOT: Field = 9;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[derive(Packable)]\n    struct MaxSizeNote {\n        data: [Field; MAX_NOTE_PACKED_LEN],\n    }\n\n    impl NoteType for MaxSizeNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_note() {\n        let mut data = [0; MAX_NOTE_PACKED_LEN];\n        for i in 0..MAX_NOTE_PACKED_LEN {\n            data[i] = i as Field;\n        }\n        let note = MaxSizeNote { data };\n\n        let encoded = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n        let (msg_type_id, msg_metadata, msg_content) = decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MaxSizeNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(data));\n    }\n\n    #[derive(Packable)]\n    struct OversizedNote {\n        data: [Field; MAX_NOTE_PACKED_LEN + 1],\n    }\n\n    impl NoteType for OversizedNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_note_fails() {\n        let note = OversizedNote { data: [0; MAX_NOTE_PACKED_LEN + 1] };\n        let _ = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_note_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        assert(decode_private_note_message(0, content).is_none());\n    }\n}\n"
+    },
+    "154": {
+      "function_locations": [
+        {
+          "name": "encode_partial_note_private_message",
+          "start": 1715
+        },
+        {
+          "name": "decode_partial_note_private_message",
+          "start": 3810
+        },
+        {
+          "name": "test::encode_decode",
+          "start": 6022
+        },
+        {
+          "name": "test::decode_empty_content_returns_none",
+          "start": 6999
+        },
+        {
+          "name": "test::decode_succeeds_with_only_reserved_fields",
+          "start": 7197
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/partial_note.nr",
+      "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 1;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private message\n/// (e.g. the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a partial note private message (i.e. one of type [`PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_partial_note_private_message`].\npub fn encode_partial_note_private_message<PartialNotePrivateContent>(\n    partial_note_private_content: PartialNotePrivateContent,\n    owner: AztecAddress,\n    randomness: Field,\n    note_completion_log_tag: Field,\n    ) -> [Field; PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <PartialNotePrivateContent as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    PartialNotePrivateContent: NoteType + Packable,\n{\n    let packed_private_content = partial_note_private_content.pack();\n\n    // If PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then\n    // the encoding below must be updated as well.\n    std::static_assert(\n        PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    let mut msg_content =\n        [0; PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <PartialNotePrivateContent as Packable>::N];\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX] = note_completion_log_tag;\n\n    for i in 0..packed_private_content.len() {\n        msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_private_content[i];\n    }\n\n    encode_message(\n        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n        // Notes use the note type id for metadata\n        PartialNotePrivateContent::get_id() as u64,\n        msg_content,\n    )\n}\n\n/// Decodes the plaintext from a partial note private message (i.e. one of type\n/// [`PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_partial_note_private_message`].\n///\n/// Note that while [`encode_partial_note_private_message`] returns a fixed-size array, this function takes a\n/// [`BoundedVec`] instead. This is because when decoding we're typically processing runtime-sized plaintexts, more\n/// specifically, those that originate from\n/// [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_partial_note_private_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(AztecAddress, Field, Field, Field, BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>)> {\n    if msg_content.len() < PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id: Field = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail,\n        // then the destructuring of the partial note private message encoding below must be updated as well.\n        std::static_assert(\n            PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN\",\n        );\n\n        // We currently have three fields that are not the partial note's packed representation, which are the owner,\n        // the randomness, and the note completion log tag.\n        let owner = AztecAddress::from_field(\n            msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX),\n        );\n        let randomness = msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let note_completion_log_tag = msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX);\n\n        let packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN> = array::subbvec(\n            msg_content,\n            PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN,\n        );\n\n        Option::some(\n            (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content),\n        )\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::partial_note::{decode_partial_note_private_message, encode_partial_note_private_message},\n            msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global RANDOMNESS: Field = 10;\n    global NOTE_COMPLETION_LOG_TAG: Field = 11;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        // Note that here we use MockNote as the private fields of a partial note\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_partial_note_private_message(note, OWNER, RANDOMNESS, NOTE_COMPLETION_LOG_TAG);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID);\n\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_note) =\n            decode_partial_note_private_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(note_completion_log_tag, NOTE_COMPLETION_LOG_TAG);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_partial_note_private_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        let (_, _, _, _, packed_note) = decode_partial_note_private_message(0, content).unwrap();\n        assert_eq(packed_note.len(), 0);\n    }\n}\n"
+    },
+    "16": {
+      "function_locations": [
+        {
+          "name": "Field::assert_max_bit_size",
+          "start": 380
+        },
+        {
+          "name": "Field::to_le_bits",
+          "start": 1196
+        },
+        {
+          "name": "Field::to_be_bits",
+          "start": 2387
+        },
+        {
+          "name": "Field::to_le_bytes",
+          "start": 3562
+        },
+        {
+          "name": "Field::to_be_bytes",
+          "start": 5033
         },
         {
           "name": "Field::to_le_radix",
@@ -962,59 +936,147 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [bool; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n    pub fn sgn0(self) -> bool {\n        (self as u8) % 2 == 1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_le_bytes\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_be_bytes\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes\n        static_assert(\n            N <= modulus_be_bytes().len(),\n            \"N must be less than or equal to modulus_be_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a little endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_le_bytes_checked\n    pub fn from_le_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes_checked\n        let p = modulus_le_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[N - 1 - i] != p[N - 1 - i] {\n                    assert(\n                        bytes[N - 1 - i] < p[N - 1 - i],\n                        \"input bytes are not a canonical field representation\",\n                    );\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_le_bytes(bytes)\n    }\n\n    /// Convert a big endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_be_bytes_checked\n    pub fn from_be_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes_checked\n        let p = modulus_be_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[i] != p[i] {\n                    assert(bytes[i] < p[i], \"input bytes are not a canonical field representation\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_be_bytes(bytes)\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_be_bits();\n        assert_eq(bits, [false, false, false, false, false, false, true, false]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_le_bits();\n        assert_eq(bits, [false, true, false, false, false, false, false, false]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_le_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_be_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_be_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n            let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n            let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n            let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n            let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_bytes_checked_small_n() {\n        // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n        // variants behave identically to the unchecked ones.\n        let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n        assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n        let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n        assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn max_bit_size_too_large() {\n        let x: Field = 0x010000;\n        x.assert_max_bit_size::<16>();\n    }\n\n}\n"
     },
-    "161": {
+    "162": {
+      "function_locations": [
+        {
+          "name": "enqueue_note_for_validation",
+          "start": 3744
+        },
+        {
+          "name": "enqueue_event_for_validation",
+          "start": 5107
+        },
+        {
+          "name": "validate_and_store_enqueued_notes_and_events",
+          "start": 5775
+        },
+        {
+          "name": "get_pending_partial_notes_completion_logs",
+          "start": 7073
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
+      "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\nmod message_context;\npub use message_context::MessageContext;\n\nmod note_validation_request;\npub use note_validation_request::NoteValidationRequest;\n\npub mod log_retrieval_request;\npub mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\npub(crate) mod provided_secret;\n\nuse crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\n        discovery::partial_notes::DeliveredPendingPartialNote,\n        encoding::MESSAGE_CIPHERTEXT_LEN,\n        logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},\n        processing::{log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse},\n    },\n    oracle::message_processing,\n};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n    hash::{compute_log_tag, sha256_to_field},\n    traits::{Deserialize, Serialize},\n};\nuse event_validation_request::EventValidationRequest;\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// An offchain-delivered message with resolved context, ready for processing during sync.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessageWithContext {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub message_context: MessageContext,\n}\n\n/// Enqueues a note for validation and storage by PXE.\n///\n/// Once validated, the note becomes retrievable via the `get_notes` oracle. The note will be scoped to\n/// `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many note validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value is\n/// typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are the\n/// inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and `NoteHash::compute_nullifier`. PXE\n/// will verify that the siloed unique note hash was inserted into the tree at `tx_hash`, and will store the nullifier\n/// to later check for nullification.\n///\n/// `owner` is the address used in note hash and nullifier computation, often requiring knowledge of their nullifier\n/// secret key.\n///\n/// `scope` is the account to which the note message was delivered (i.e. the address the message was encrypted to).\n/// This determines which PXE account can see the note - other accounts will not be able to access it (e.g. other\n/// accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized. In\n/// most cases `recipient` equals `owner`, but they can differ in scenarios like delegated discovery.\npub unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(NoteValidationRequest::new(\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n    ))\n}\n\n/// Enqueues an event for validation and storage by PXE.\n///\n/// This is the primary way for custom message handlers (registered via\n/// [`crate::macros::AztecConfig::custom_message_handler`]) to deliver reassembled events back to PXE after processing\n/// application-specific message formats.\n///\n/// In order for the event validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many event validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// Note that `validate_and_store_enqueued_notes_and_events` is called by Aztec.nr after processing messages, so custom\n/// message processors do not need to be concerned with this.\npub unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    randomness: Field,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(EventValidationRequest::new(\n        contract_address,\n        event_type_id,\n        randomness,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n    ))\n}\n\n/// Validates and stores all enqueued notes and events.\n///\n/// Processes all requests enqueued via [`enqueue_note_for_validation`] and [`enqueue_event_for_validation`], inserting\n/// them into the note database and event store respectively, making them queryable via `get_notes` oracle and our TS\n/// API (PXE::getPrivateEvents).\npub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAddress) {\n    message_processing::validate_and_store_enqueued_notes_and_events(\n        EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        scope,\n    );\n\n    // Defensive clearing: purge the queues after processing to prevent double-processing if this function is called\n    // more than once in the same call frame. It is currently defensive because we only call this once per sync run.\n    let _ = EphemeralArray::<NoteValidationRequest>::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n    let _ = EphemeralArray::<EventValidationRequest>::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a nested `EphemeralArray`, one inner\n/// array per pending partial note, each containing all matching `LogRetrievalResponse`s (which may be empty if no\n/// logs were found).\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    let log_retrieval_requests = EphemeralArray::at(LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    pending_partial_notes.for_each(|_i, pending_partial_note| {\n        // Partial note completion logs are emitted with a domain-separated tag. To find matching logs, we apply the\n        // same domain separation to the stored raw tag.\n        let log_tag = compute_log_tag(\n            pending_partial_note.note_completion_log_tag,\n            DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n        );\n        log_retrieval_requests.push(LogRetrievalRequest::new(contract_address, log_tag));\n    });\n\n    let responses = message_processing::get_logs_by_tag(log_retrieval_requests);\n\n    // Defensive clearing: prevent stale requests if this function is called more than once in the same call frame.\n    let _ = log_retrieval_requests.clear();\n\n    responses\n}\n"
+    },
+    "164": {
       "function_locations": [
         {
           "name": "receive",
-          "start": 5315
+          "start": 2571
         },
         {
           "name": "sync_inbox",
-          "start": 6758
+          "start": 3354
         },
         {
           "name": "test::setup",
-          "start": 11124
+          "start": 5138
         },
         {
           "name": "test::make_msg",
-          "start": 11454
+          "start": 5468
         },
         {
           "name": "test::advance_by",
-          "start": 11737
+          "start": 5751
         },
         {
           "name": "test::empty_inbox_returns_empty_result",
-          "start": 11928
+          "start": 5942
         },
         {
-          "name": "test::tx_bound_msg_expires_after_max_msg_ttl",
-          "start": 12391
+          "name": "test::multiple_messages_mixed_expiration",
+          "start": 6330
         },
         {
-          "name": "test::tx_bound_msg_not_expired_before_max_msg_ttl",
-          "start": 13356
+          "name": "test::redelivery_is_idempotent",
+          "start": 8312
         },
         {
-          "name": "test::tx_less_msg_expires_after_max_msg_ttl",
-          "start": 14314
+          "name": "test::redelivery_after_processing_keeps_processed_guard",
+          "start": 9177
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/mod.nr",
+      "source": "use crate::{\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithContext},\n    oracle::{contract_sync::set_contract_sync_cache_invalid, tx_resolution::get_resolved_txs},\n    protocol::{address::AztecAddress, traits::{Deserialize, Serialize}},\n};\n\nmod reception;\nuse reception::OffchainReception;\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an [`OffchainInboxSync`] is [`sync_inbox`], which manages an inbox with\n/// expiration\n/// based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The expiration is set to `anchor_block_timestamp + MAX_MSG_TTL`\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // Offchain reception facts are scoped to the recipient. Note that because offchain messages have no integrity or\n    // authenticity checks it is not possible to verify that this is indeed the intended recipient. In this case we're\n    // assuming a cooperative environment, which is on par with other offchain delivery expectations.\n    messages.for_each(|msg| OffchainReception::init(contract_address, msg));\n\n    // Clear cache for message recipients so the next sync runs.\n    set_contract_sync_cache_invalid(contract_address, messages.map(|msg| msg.recipient));\n}\n\n/// Returns offchain-delivered messages to process during sync.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let active_receptions = OffchainReception::load_all(contract_address, scope);\n\n    // Ask PXE to resolve each message's originating tx. We pass the tx hashes in reception order, so the resolved txs\n    // come back aligned with the reception indices and can be matched back positionally.\n    let resolved_txs = get_resolved_txs(active_receptions.map(|reception: OffchainReception| {\n        reception.read_message().tx_hash.unwrap_or(0)\n    }));\n\n    let processable_messages: EphemeralArray<OffchainMessageWithContext> = EphemeralArray::empty();\n    let now = UtilityContext::new().timestamp();\n\n    active_receptions.for_each(|i, reception| {\n        let maybe_message = reception.step(resolved_txs.get(i), now);\n        if maybe_message.is_some() {\n            processable_messages.push(maybe_message.unwrap());\n        }\n    });\n\n    processable_messages\n}\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\nmod test {\n    use crate::{\n        oracle::random::random, protocol::address::AztecAddress, test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OffchainMessage, receive, sync_inbox};\n    use super::reception::{MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(OffchainReception::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let expired_a_tx_hash = random();\n        let survivor_tx_hash = random();\n\n        let expired_a = make_msg(scope, Option::some(expired_a_tx_hash), 0);\n        let survivor = make_msg(scope, Option::some(survivor_tx_hash), anchor_ts);\n        let expired_b = make_msg(scope, Option::none(), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor=0 so it expires quickly.\n            msgs.push(expired_a);\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(survivor);\n            // Message 2: tx-less, anchor=0 so it also expires.\n            msgs.push(expired_b);\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor=0, but not for anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            assert(\n                !OffchainReception::is_active(address, scope, expired_a),\n                \"expired tx-bound reception should be terminated\",\n            );\n            assert(\n                !OffchainReception::is_active(address, scope, expired_b),\n                \"expired tx-less reception should be terminated\",\n            );\n            assert(OffchainReception::is_active(address, scope, survivor), \"survivor reception should stay active\");\n            assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n        });\n    }\n\n    // -- Idempotent re-delivery (first-write-wins fact recording) ---------\n\n    #[test]\n    unconstrained fn redelivery_is_idempotent() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n        let msg = make_msg(scope, Option::some(random()), anchor_ts);\n\n        // First delivery, committed as its own job.\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n        // Re-delivering the same content-addressed message must not panic and must not create a second reception.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([msg]));\n\n            assert(OffchainReception::is_active(address, scope, msg), \"reception should be active\");\n            assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn redelivery_after_processing_keeps_processed_guard() {\n        let (env, scope) = setup();\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n        let msg = make_msg(scope, Option::some(known_tx_hash), anchor_ts);\n\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n        let _now = advance_by(env, 100);\n\n        // First sync resolves the message and marks it as processed.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            assert_eq(sync_inbox(address, scope).len(), 1);\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n\n        // Re-deliver the same message. The next sync recognizes it as already processed and does not re-push it.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([msg]));\n\n            assert(\n                OffchainReception::is_processed(address, scope, msg),\n                \"re-delivery must preserve the processed guard\",\n            );\n            assert_eq(sync_inbox(address, scope).len(), 0);\n        });\n    }\n}\n"
+    },
+    "165": {
+      "function_locations": [
+        {
+          "name": "OffchainReception::init",
+          "start": 8508
         },
         {
-          "name": "test::unresolved_tx_stays_in_inbox",
-          "start": 15256
+          "name": "OffchainReception::load_all",
+          "start": 9026
         },
         {
-          "name": "test::multiple_messages_mixed_expiration",
-          "start": 16150
+          "name": "OffchainReception::read_message",
+          "start": 9375
+        },
+        {
+          "name": "OffchainReception::id_for",
+          "start": 10076
+        },
+        {
+          "name": "OffchainReception::is_active",
+          "start": 10395
+        },
+        {
+          "name": "OffchainReception::step",
+          "start": 11055
+        },
+        {
+          "name": "OffchainReception::is_processed",
+          "start": 12512
+        },
+        {
+          "name": "OffchainReception::mark_processed",
+          "start": 13080
+        },
+        {
+          "name": "OffchainReception::terminate",
+          "start": 13648
+        },
+        {
+          "name": "to_payload",
+          "start": 14022
+        },
+        {
+          "name": "test::setup",
+          "start": 14579
+        },
+        {
+          "name": "test::make_msg",
+          "start": 14909
+        },
+        {
+          "name": "test::resolved_tx",
+          "start": 15140
         },
         {
-          "name": "test::resolved_msg_is_ready_to_process",
-          "start": 17889
+          "name": "test::expired_reception_is_terminated",
+          "start": 15419
+        },
+        {
+          "name": "test::unresolved_reception_stays_active",
+          "start": 16101
+        },
+        {
+          "name": "test::resolved_reception_is_ready_to_process",
+          "start": 16896
+        },
+        {
+          "name": "test::already_processed_reception_is_not_re_pushed",
+          "start": 17946
+        },
+        {
+          "name": "test::expired_resolved_reception_is_processed_once_before_termination",
+          "start": 19064
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain.nr",
-      "source": "use crate::{\n    capsules::CapsuleArray,\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithContext},\n    oracle::contract_sync::set_contract_sync_cache_invalid,\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::sha256_to_field,\n        traits::{Deserialize, Serialize},\n    },\n};\n\n/// Base capsule slot for the persistent inbox of [`PendingOffchainMsg`] entries.\n///\n/// This is the slot where we accumulate messages received through [`receive`].\nglobal OFFCHAIN_INBOX_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_INBOX_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to pass tx hash resolution requests to PXE.\nglobal OFFCHAIN_CONTEXT_REQUESTS_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_CONTEXT_REQUESTS_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to collect messages ready for processing.\nglobal OFFCHAIN_READY_MESSAGES_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_READY_MESSAGES_SLOT\".as_bytes());\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// Tolerance added to the `MAX_TX_LIFETIME` cap for message expiration.\nglobal TX_EXPIRATION_TOLERANCE: u64 = 7200; // 2 hours\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\nglobal MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + TX_EXPIRATION_TOLERANCE;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an `OffchainInboxSync` is [`sync_inbox`], which manages an inbox with expiration\n/// based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\n/// An offchain message awaiting processing (or re-processing) in the inbox.\n///\n/// Messages remain in the inbox until they expire, even if they have already been processed. This is necessary to\n/// handle reorgs: a processed message may need to be re-processed if the transaction that provided its context is\n/// reverted. On each sync, resolved messages are promoted to [`OffchainMessageWithContext`] for processing.\n#[derive(Serialize, Deserialize)]\nstruct PendingOffchainMsg {\n    /// The encrypted message payload.\n    ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. A value of 0 indicates a tx-less message.\n    tx_hash: Field,\n    /// Anchor block timestamp at message emission. Used to compute the effective expiration: messages are evicted\n    /// after `anchor_block_timestamp + MAX_MSG_TTL`.\n    anchor_block_timestamp: u64,\n}\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Each message is routed to the inbox scoped to its `recipient` field, so messages for different accounts are\n/// automatically isolated.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The effective expiration is\n/// `anchor_block_timestamp + MAX_MSG_TTL`.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // May contain duplicates if multiple messages target the same recipient. This is harmless since\n    // cache invalidation on the TS side is idempotent (deleting an already-deleted key is a no-op).\n    let mut scopes: BoundedVec<AztecAddress, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n    let mut i = 0;\n    let messages_len = messages.len();\n    while i < messages_len {\n        let msg = messages.get(i);\n        let tx_hash = if msg.tx_hash.is_some() {\n            msg.tx_hash.unwrap()\n        } else {\n            0\n        };\n        let inbox: CapsuleArray<PendingOffchainMsg> =\n            CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, msg.recipient);\n        inbox.push(\n            PendingOffchainMsg {\n                ciphertext: msg.ciphertext,\n                recipient: msg.recipient,\n                tx_hash,\n                anchor_block_timestamp: msg.anchor_block_timestamp,\n            },\n        );\n        scopes.push(msg.recipient);\n        i += 1;\n    }\n\n    set_contract_sync_cache_invalid(contract_address, scopes);\n}\n\n/// Returns offchain-delivered messages to process during sync.\n///\n/// Messages remain in the inbox and are reprocessed on each sync until their originating transaction is no longer at\n/// risk of being dropped by a reorg.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, scope);\n    let context_resolution_requests: EphemeralArray<Field> = EphemeralArray::empty_at(OFFCHAIN_CONTEXT_REQUESTS_SLOT);\n    let ready_to_process: EphemeralArray<OffchainMessageWithContext> =\n        EphemeralArray::empty_at(OFFCHAIN_READY_MESSAGES_SLOT);\n\n    // Build a request list aligned with the inbox indices.\n    let mut i = 0;\n    let inbox_len = inbox.len();\n    while i < inbox_len {\n        let msg = inbox.get(i);\n        context_resolution_requests.push(msg.tx_hash);\n        i += 1;\n    }\n\n    // Ask PXE to resolve contexts for all requested tx hashes. The oracle returns responses in a new\n    // ephemeral array.\n    let resolved_contexts =\n        crate::oracle::message_processing::get_message_contexts_by_tx_hash(context_resolution_requests);\n\n    assert_eq(resolved_contexts.len(), inbox_len);\n\n    let now = UtilityContext::new().timestamp();\n\n    let mut j = inbox_len;\n    while j > 0 {\n        // This loop decides what to do with each message in the offchain message inbox. We need to handle 3\n        // different scenarios for each message.\n        //\n        // 1. The TX that emitted this message is still not known to PXE: in this case we can't yet process this\n        // message, as any notes or events discovered will fail to be validated. So we leave the message in the inbox,\n        // awaiting for future syncs to detect that the TX became available.\n        //\n        // 2. The message is not associated to a TX to begin with. The current version of offchain message processing\n        // does not support this case, but in the future it will. Right now, a message without an associated TX will\n        // sit in the inbox until it expires.\n        //\n        // 3. The TX that emitted this message has been found by PXE. That gives us all the information needed to\n        // process the message. We add the message to the `ready_to_process` EphemeralArray so that the `sync_state`\n        // loop\n        // processes it.\n        //\n        // In all cases, if the message has expired (i.e. `now > anchor_block_timestamp + MAX_MSG_TTL`), we remove it\n        // from the inbox.\n        //\n        // Note: the loop runs backwards because it might call `inbox.remove(j)` to purge expired messages and we also\n        // need to align it with `resolved_contexts.get(j)`. Going from last to first simplifies the algorithm as\n        // not yet visited element indexes remain stable.\n        j -= 1;\n        let maybe_ctx = resolved_contexts.get(j);\n        let msg = inbox.get(j);\n\n        // Compute the message's effective expiration timestamp to determine if we can purge it from the inbox.\n        let effective_expiration = msg.anchor_block_timestamp + MAX_MSG_TTL;\n\n        // Message expired. We remove it from the inbox.\n        if now > effective_expiration {\n            inbox.remove(j);\n        }\n\n        // Scenario 1: associated TX not yet available. We keep the message in the inbox, as it might become\n        // processable as new blocks get mined.\n        // Scenario 2: no TX associated to message. The message will sit in the inbox until it expires.\n        if maybe_ctx.is_none() {\n            continue;\n        }\n\n        // Scenario 3: Message is ready to process, add to result array. Note we still keep it in the inbox unless we\n        // consider it has expired: this is because we need to account for reorgs. If reorg occurs after we processed\n        // a message, the effects of processing the message get rewind. However, the associated TX can be included in\n        // a subsequent block. Should that happen, the message must be re-processed to ensure consistency.\n        let message_context = maybe_ctx.unwrap();\n        ready_to_process.push(OffchainMessageWithContext { message_ciphertext: msg.ciphertext, message_context });\n    }\n\n    ready_to_process\n}\n\nmod test {\n    use crate::{\n        capsules::CapsuleArray, oracle::random::random, protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{\n        MAX_MSG_TTL, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OFFCHAIN_INBOX_SLOT, OffchainMessage, PendingOffchainMsg,\n        receive, sync_inbox,\n    };\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let result = sync_inbox(context.this_address(), scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> =\n                CapsuleArray::at(context.this_address(), OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(inbox.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_not_expired_before_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance, but not past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_less_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::none(), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_tx_stays_in_inbox() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // not resolved, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let survivor_tx_hash = random();\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor_ts in the past so it expires at\n            // anchor_ts + MAX_MSG_TTL. We set anchor to 0 so it expires quickly.\n            msgs.push(make_msg(scope, Option::some(random()), 0));\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(make_msg(scope, Option::some(survivor_tx_hash), anchor_ts));\n            // Message 2: tx-less, anchor_ts=0 so it also expires.\n            msgs.push(make_msg(scope, Option::none(), 0));\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor_ts=0, but not for anchor_ts=anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            // Message 0 expired (anchor=0), message 1 survived (anchor=anchor_ts),\n            // Message 2 expired (anchor=0).\n            assert_eq(inbox.len(), 1);\n            assert_eq(inbox.get(0).tx_hash, survivor_tx_hash);\n        });\n    }\n\n    // -- Resolved context (ready to process) ------------------------------\n\n    #[test]\n    unconstrained fn resolved_msg_is_ready_to_process() {\n        let (env, scope) = setup();\n        // TestEnvironment::new() deploys protocol contracts, creating blocks with tx effects.\n        // In TXE, tx hashes equal Fr(blockNumber), so Fr(1) is the tx effect from block 1.\n        // We use this as a \"known resolvable\" tx hash.\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(known_tx_hash), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            // The message should be ready to process since its tx context was resolved.\n            assert_eq(result.len(), 1);\n\n            let ctx = result.get(0).message_context;\n            assert_eq(ctx.tx_hash, known_tx_hash);\n            assert(ctx.first_nullifier_in_tx != 0, \"resolved context must have a first nullifier\");\n\n            // Message stays in inbox (not expired) for potential reorg reprocessing.\n            assert_eq(inbox.len(), 1);\n        });\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/reception.nr",
+      "source": "//! The state machine of a single offchain message reception process.\n//!\n//! Offchain processing needs to handle some complexity, including the possibility of reorgs reverting message effects,\n//! and the need to reprocess messages in that case. The state chart below summarizes the current behavior.\n//!\n//! ```text\n//!                   offchain_receive() (process starts)\n//!                         |\n//!                         v\n//!                     +-----------+     tx found onchain        +-----------+\n//!                ---- |           | --------------------------> |           |\n//!  tx not found  |    |           |                             |           |     discover notes,\n//!                |--> | RECEIVED  |                             | PROCESSED | ~~> events, etc\n//!                     |           | <-------------------------- |           |\n//!                     |           |   tx block re-orged         |           |\n//!                     +-----------+                             +-----------+\n//!                         |                                         |\n//!                         |  TTL expired                            |  TTL expired\n//!                         v                                         v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Received**: the message is stored but its originating transaction has not been found onchain yet (or the\n//!   message is tx-less; see below). While the reception process is in this state, it keeps looking for the\n//    transaction onchain.\n//! - **Processed**: the message has been handed off for processing. If there weren't reorgs, reaching this state would\n//!   be equivalent to terminating the reception process. Since reorgs are a possibility, this state is not terminal.\n//! - **Terminated**: the message has reached its TTL which means nothing else can be done with it. This is the\n//!   terminal state of this process.\n//!\n//! ## Transitions (each evaluated by [`OffchainReception::step`])\n//!\n//! - **Received -> Processed**: the originating transaction is found onchain. The message (packaged with its\n//!   transaction context) is queued to have its actual contents processed (which can lead for example to the discovery\n//!   of notes and events).\n//! - **Processed -> Received**: the block where the message transaction was originally found is re-orged out.\n//! - **Received -> Terminated**: the message TTL has elapsed (see below), so the message is no longer processable.\n//! - **Processed -> Terminated**: the message TTL has elapsed (see below), so the effects of its processing are\n//!   permanent.\n//!\n//! # Message reception lifecycle and the TTL\n//!\n//! A reception expires once `now > anchor_block_timestamp + MAX_MSG_TTL`, where `MAX_MSG_TTL = MAX_TX_LIFETIME + 2h`.\n//! A transaction anchored at a given block can only be mined within\n//! [`MAX_TX_LIFETIME`](crate::protocol::constants::MAX_TX_LIFETIME) of that block, so once that\n//! window (plus a safety margin of 2 hours) has elapsed the originating transaction can no longer appear, and it is\n//! safe to stop looking for it.\n//!\n//! Already-processed receptions reuse the same TTL: we could instead wait for the block that included the transaction\n//! to finalize, but we currently do not have the primitives to reliably get that information.\n//!\n//! # Current limitations, future plans\n//!\n//! - Tx-less messages never reach `Processed` and are only ever removed by expiry. This will be supported in the\n//!   future.\n//! - Already-processed receptions stay active longer than needed. As discussed, we need access to block finality\n//!   information to properly implement that case, which will be added in the future.\n//!\n//! # Implementation\n//!\n//! [`OffchainReception::init`] creates a [fact collection](crate::facts::FactCollection) of type\n//! `OFFCHAIN_RECEPTION_TYPE_ID`. The fact collection is identified by a hash of the `OffchainMessage` it tracks, which\n//! makes duplicate calls to `init` idempotent.\n//!\n//! Upon reception, an `OFFCHAIN_MESSAGE_RECEIVED` [non-retractable fact](crate::facts::record_non_retractable_fact) is\n//! recorded. The fact's payload is the `OffchainMessage` itself, which persists it to be subsequently processed.\n//! A fact collection with just an `OFFCHAIN_MESSAGE_RECEIVED` fact represents an active reception process in the\n//! RECEIVED state from our state chart above.\n//!\n//! The message reception state machine is driven externally, advancing one step at a time each time\n//! [`OffchainReception::step`] is invoked. [`OffchainReception::step`] implements the rest of the reception state\n//! machine described above.\n//!\n//! When stepping, if the transaction to the message is found onchain, an `OFFCHAIN_MESSAGE_PROCESSED`\n//! [retractable fact](crate::facts::record_retractable_fact) associated to the block where the transaction was found is\n//! recorded.\n//! Note that since this fact is retractable, a reorg dropping said block would result in the fact being automatically\n//! removed by PXE, effectively pushing the reception process back to `RECEIVED` state.\n//!\n//! To determine in which state of the reception process we are we just need to analyze the recorded facts available\n//! in combination with the TTL:\n//!\n//! - If the TTL has elapsed, we reached the end of the process and the [fact collection](crate::facts::FactCollection)\n//! can (and should) be deleted.\n//! - Otherwise:\n//!     - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state and there is nothing to do.\n//!     - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we need to check if the\n//!       message transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition.\n//!\n//! The PROCESSED->RECEIVED transition is transparently handled by PXE: if a re-org caused the message transaction to\n//! fall off the chain, the `OFFCHAIN_MESSAGE_PROCESSED` fact disappears, taking us back to the RECEIVED state.\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    facts::{\n        delete_fact_collection, Fact, FactCollection, get_fact_collection, get_fact_collections_by_type, OriginBlock,\n        record_non_retractable_fact, record_retractable_fact,\n    },\n    messages::processing::{MessageContext, OffchainMessageWithContext},\n    oracle::tx_resolution::ResolvedTx,\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::{poseidon2_hash, sha256_to_field},\n        traits::{Deserialize, Serialize},\n    },\n};\nuse super::OffchainMessage;\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\n/// (7200 == 2 hours)\npub(crate) global MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Fact type id of the fact that stores the offchain message body inside a reception collection.\nglobal OFFCHAIN_MESSAGE_RECEIVED: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_RECEIVED\".as_bytes());\n\n/// Fact type id to mark an offchain message as processed.\n///\n/// A reception is in \"processed state\" exactly when its collection carries a fact of this type.\npub(crate) global OFFCHAIN_MESSAGE_PROCESSED: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_PROCESSED\".as_bytes());\n\n/// Fact-collection type id shared by every offchain message reception in the [fact store](crate::facts).\npub(crate) global OFFCHAIN_RECEPTION_TYPE_ID: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_RECEPTION_TYPE_ID\".as_bytes());\n\n/// A single offchain message reception machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n///\n/// Wraps the fact collection that tracks one message's progress through the reception state machine (see the\n/// [module documentation](super)); the [`OffchainMessage`] it carries is decoded on demand.\n#[derive(Deserialize, Serialize)]\npub(crate) struct OffchainReception {\n    collection: FactCollection,\n}\n\nimpl OffchainReception {\n    /// Initializes a new reception for a freshly received message, in the `Received` state.\n    ///\n    /// Re-initializing the same message is a no-op, which makes redelivery idempotent.\n    pub(crate) unconstrained fn init(contract_address: AztecAddress, message: OffchainMessage) {\n        record_non_retractable_fact(\n            contract_address,\n            message.recipient,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n            OFFCHAIN_MESSAGE_RECEIVED,\n            to_payload(message),\n        );\n    }\n\n    /// Loads every active reception for the given contract and scope, decoding each message body.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<OffchainReception> {\n        get_fact_collections_by_type(contract_address, scope, OFFCHAIN_RECEPTION_TYPE_ID)\n            .map(|collection: FactCollection| OffchainReception { collection })\n    }\n\n    /// Reads and returns the message this reception carries, decoding it from its fact collection.\n    pub(crate) unconstrained fn read_message(self) -> OffchainMessage {\n        let message_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_RECEIVED).unwrap();\n        let n = <OffchainMessage as Deserialize>::N;\n        let mut fields = [0; <OffchainMessage as Deserialize>::N];\n        for i in 0..n {\n            fields[i] = message_fact.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Computes the fact-collection id that identifies a message's reception machine in the [fact store](crate::facts).\n    ///\n    /// The id is a hash of the message, which makes duplicate receptions of the same message collapse onto a single\n    /// reception.\n    pub(crate) fn id_for(message: OffchainMessage) -> Field {\n        poseidon2_hash(message.serialize())\n    }\n\n    /// Returns `true` if a reception for `message` is currently active for the given contract and scope.\n    pub(crate) unconstrained fn is_active(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        get_fact_collection(\n            contract_address,\n            scope,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        )\n            .is_some()\n    }\n\n    /// Advances this reception by one step of its state machine. See the [module documentation](super) for the\n    /// states, transitions, and expiry rules.\n    ///\n    /// Returns `Some` with the message and its resolved context when this step determines the message is ready to be\n    /// processed.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_resolved_tx: Option<ResolvedTx>,\n        now: u64,\n    ) -> Option<OffchainMessageWithContext> {\n        // TODO(@mverzilli): we could annotate retractable facts as \"final\" when their corresponding blocks are below\n        // the final tip. Then we could use that as termination condition instead of relying on timestamp arithmetics.\n        let message = self.read_message();\n        let expired = now > message.anchor_block_timestamp + MAX_MSG_TTL;\n        let already_processed = self.collection.facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n        if !already_processed & maybe_resolved_tx.is_some() {\n            let resolved = maybe_resolved_tx.unwrap();\n            self.mark_processed(resolved.block_number, resolved.block_hash);\n            let message_context = MessageContext {\n                tx_hash: resolved.tx_hash,\n                unique_note_hashes_in_tx: resolved.unique_note_hashes_in_tx,\n                first_nullifier_in_tx: resolved.first_nullifier_in_tx,\n            };\n            Option::some(\n                OffchainMessageWithContext { message_ciphertext: message.ciphertext, message_context },\n            )\n        } else if expired {\n            self.terminate();\n            Option::none()\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `true` if the reception for `message` has been marked processed.\n    pub(crate) unconstrained fn is_processed(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        let maybe_collection = get_fact_collection(\n            contract_address,\n            scope,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        );\n        if maybe_collection.is_some() {\n            maybe_collection.unwrap().facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED)\n        } else {\n            false\n        }\n    }\n\n    /// Records the retractable processed marker for this reception, originated at the resolved block.\n    unconstrained fn mark_processed(self, block_number: u32, block_hash: Field) {\n        let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n        record_retractable_fact(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n            OFFCHAIN_MESSAGE_PROCESSED,\n            empty_payload,\n            OriginBlock { block_number, block_hash },\n        );\n    }\n\n    /// Terminates this reception by deleting its [fact collection](crate::facts::FactCollection).\n    unconstrained fn terminate(self) {\n        delete_fact_collection(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n        );\n    }\n}\n\n/// Serializes an [`OffchainMessage`] into a fact payload.\nunconstrained fn to_payload(message: OffchainMessage) -> EphemeralArray<Field> {\n    let fields = message.serialize();\n    let payload: EphemeralArray<Field> = EphemeralArray::empty();\n    for i in 0..fields.len() {\n        payload.push(fields[i]);\n    }\n    payload\n}\n\nmod test {\n    use crate::{\n        messages::processing::offchain::OffchainMessage,\n        oracle::{random::random, tx_resolution::ResolvedTx},\n        protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Builds the resolved-tx context PXE would return for `tx_hash`.\n    fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n        ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: BoundedVec::new(),\n            first_nullifier_in_tx: 0,\n            block_number: 1,\n            block_hash: 0,\n        }\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_terminated() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Past the TTL with no resolved tx: the reception is terminated.\n            assert(reception.step(Option::none(), MAX_MSG_TTL + 1).is_none());\n            assert(!OffchainReception::is_active(address, scope, msg), \"expired reception should be terminated\");\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_reception_stays_active() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Within the TTL with no resolved tx: nothing to process, the reception stays.\n            assert(reception.step(Option::none(), 100).is_none());\n            assert(OffchainReception::is_active(address, scope, msg), \"unresolved reception should stay active\");\n            assert(!OffchainReception::is_processed(address, scope, msg), \"should still be unprocessed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn resolved_reception_is_ready_to_process() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // A resolved tx within the TTL: the message is handed off with its tx context attached.\n            let processable = reception.step(Option::some(resolved_tx(tx_hash)), 100);\n            assert(processable.is_some());\n            assert_eq(processable.unwrap().message_context.tx_hash, tx_hash);\n\n            // It stays active for reorg safety and is now marked processed.\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should stay active\");\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn already_processed_reception_is_not_re_pushed() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // First step processes the message.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Second step (still resolved, not expired) recognizes it as processed and does not re-push it.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none(), \"already processed\");\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n        });\n    }\n\n    #[test]\n    unconstrained fn expired_resolved_reception_is_processed_once_before_termination() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // Expired but resolved: the message is processed once (not terminated yet).\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Next step: still expired and now processed, so the reception is terminated.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_none());\n            assert(\n                !OffchainReception::is_active(address, scope, msg),\n                \"expired processed reception is terminated on the next step\",\n            );\n        });\n    }\n}\n"
     },
     "17": {
       "function_locations": [
@@ -1202,7 +1264,7 @@
       "path": "std/hash/mod.nr",
       "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A> Hash for (A,)\nwhere\n    A: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_> Hash for (A, B, C, D, E, F, G, H_)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I> Hash for (A, B, C, D, E, F, G, H_, I)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J> Hash for (A, B, C, D, E, F, G, H_, I, J)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K> Hash for (A, B, C, D, E, F, G, H_, I, J, K)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K, L> Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n    L: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n        self.11.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n        },\n    );\n}\n"
     },
-    "177": {
+    "181": {
       "function_locations": [
         {
           "name": "compute_note_hash",
@@ -1228,7 +1290,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/note/utils.nr",
       "source": "use crate::{context::NoteExistenceRequest, note::{ConfirmedNote, HintedNote, note_interface::NoteHash}};\n\nuse crate::protocol::{\n    constants::{DOM_SEP__NOTE_HASH, DOM_SEP__NOTE_NULLIFIER},\n    hash::{compute_siloed_note_hash, compute_unique_note_hash, poseidon2_hash_with_separator},\n};\n\n/// Computes a domain-separated note hash.\n///\n/// Receives the `storage_slot` of the [`crate::state_vars::StateVariable`] that holds the note, plus any arbitrary\n/// note `data`. This typically includes randomness, owner, and domain specific values (e.g. numeric amount, address,\n/// id, etc.).\n///\n/// Usage of this function guarantees that different state variables will never produce colliding note hashes, even if\n/// their underlying notes have different implementations.\npub fn compute_note_hash<let N: u32>(storage_slot: Field, data: [Field; N]) -> Field {\n    // All state variables have different storage slots, so by placing this at a fixed first position in the preimage\n    // we prevent collisions.\n    poseidon2_hash_with_separator([storage_slot].concat(data), DOM_SEP__NOTE_HASH)\n}\n\n/// Computes a domain-separated note nullifier.\n///\n/// Receives the `note_hash_for_nullification` of the note (usually returned by\n/// [`compute_confirmed_note_hash_for_nullification`]), plus any arbitrary note `data`. This typically includes\n/// secrets, such as the app-siloed nullifier hiding key of the note's owner.\n///\n/// Usage of this function guarantees that different state variables will never produce colliding note nullifiers, even\n/// if their underlying notes have different implementations.\npub fn compute_note_nullifier<let N: u32>(note_hash_for_nullification: Field, data: [Field; N]) -> Field {\n    // All notes have different note hashes for nullification (i.e. transient or settled), so by placing this at a\n    // fixed first position in the preimage we prevent collisions.\n    poseidon2_hash_with_separator(\n        [note_hash_for_nullification].concat(data),\n        DOM_SEP__NOTE_NULLIFIER,\n    )\n}\n\n/// Returns the [`NoteExistenceRequest`] used to prove a note exists.\npub fn compute_note_existence_request<Note>(hinted_note: HintedNote<Note>) -> NoteExistenceRequest\nwhere\n    Note: NoteHash,\n{\n    let note_hash =\n        hinted_note.note.compute_note_hash(hinted_note.owner, hinted_note.storage_slot, hinted_note.randomness);\n\n    if hinted_note.metadata.is_settled() {\n        // Settled notes are read by siloing with contract address and nonce (resulting in the final unique note hash,\n        // which is already in the note hash tree).\n        let siloed_note_hash = compute_siloed_note_hash(hinted_note.contract_address, note_hash);\n        NoteExistenceRequest::for_settled(compute_unique_note_hash(\n            hinted_note.metadata.to_settled().note_nonce(),\n            siloed_note_hash,\n        ))\n    } else {\n        // Pending notes (both same phase and previous phase ones) are read by their non-siloed hash (not even by\n        // contract address), which is what is stored in the new note hashes array (at the position hinted by note hash\n        // counter).\n        NoteExistenceRequest::for_pending(note_hash, hinted_note.contract_address)\n    }\n}\n\n/// Unconstrained variant of [`compute_confirmed_note_hash_for_nullification`].\npub unconstrained fn compute_note_hash_for_nullification<Note>(hinted_note: HintedNote<Note>) -> Field\nwhere\n    Note: NoteHash,\n{\n    // Creating a ConfirmedNote like we do here is typically unsafe, as we've not confirmed existence. We can do it\n    // here because this is an unconstrained function, so the returned value should not make its way to a constrained\n    // function. This lets us reuse the `compute_confirmed_note_hash_for_nullification` implementation.\n    compute_confirmed_note_hash_for_nullification(ConfirmedNote::new(\n        hinted_note,\n        compute_note_existence_request(hinted_note).note_hash(),\n    ))\n}\n\n/// Returns the note hash to use when computing its nullifier.\n///\n/// The `note_hash_for_nullification` parameter [`NoteHash::compute_nullifier`] takes depends on the note's stage, e.g.\n/// settled notes use the unique note hash, but pending notes cannot as they have no nonce. This function returns the\n/// correct note hash to use.\n///\n/// Use [`compute_note_hash_for_nullification`] when computing this value in unconstrained functions.\npub fn compute_confirmed_note_hash_for_nullification<Note>(confirmed_note: ConfirmedNote<Note>) -> Field {\n    // There is just one instance in which the note hash for nullification does not match the note hash used for a read\n    // request, which is when dealing with pending previous phase notes. These had their existence proven using their\n    // non-siloed note hash along with the note hash counter (like all pending notes), but since they will be\n    // unconditionally inserted in the note hash tree (since they cannot be squashed) they must be nullified using the\n    // *unique* note hash. If we didn't, it'd be possible to emit a second different nullifier for the same note in a\n    // follow up transaction, once the note is settled, resulting in a double spend.\n\n    if confirmed_note.metadata.is_pending_previous_phase() {\n        let siloed_note_hash = compute_siloed_note_hash(\n            confirmed_note.contract_address,\n            confirmed_note.proven_note_hash,\n        );\n        let note_nonce = confirmed_note.metadata.to_pending_previous_phase().note_nonce();\n\n        compute_unique_note_hash(note_nonce, siloed_note_hash)\n    } else {\n        confirmed_note.proven_note_hash\n    }\n}\n"
     },
-    "180": {
+    "184": {
       "function_locations": [
         {
           "name": "aes128_decrypt_oracle",
@@ -1250,21 +1312,21 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/aes128_decrypt.nr",
       "source": "#[oracle(aztec_utl_decryptAes128)]\nunconstrained fn aes128_decrypt_oracle<let N: u32>(\n    ciphertext: BoundedVec<u8, N>,\n    iv: [u8; 16],\n    sym_key: [u8; 16],\n) -> Option<BoundedVec<u8, N>> {}\n\n/// Attempts to decrypt a ciphertext using AES128.\n///\n/// Returns `Option::some(plaintext)` on success, or `Option::none()` if decryption fails (e.g. due to malformed\n/// ciphertext or invalid PKCS#7 padding). Note that decryption with the wrong key will almost always return `None`\n/// because the decrypted garbage data will have invalid PKCS#7 padding.\n///\n/// Note that we accept ciphertext as a BoundedVec, not as an array. This is because this function is typically used\n/// when processing logs and at that point we don't have comptime information about the length of the ciphertext as\n/// the log is not specific to any individual note.\n// TODO(F-498): review naming consistency\npub unconstrained fn try_aes128_decrypt<let N: u32>(\n    ciphertext: BoundedVec<u8, N>,\n    iv: [u8; 16],\n    sym_key: [u8; 16],\n) -> Option<BoundedVec<u8, N>> {\n    aes128_decrypt_oracle(ciphertext, iv, sym_key)\n}\n\nmod test {\n    use crate::{\n        keys::ecdh_shared_secret::compute_app_siloed_shared_secret,\n        messages::encryption::aes128::derive_aes_symmetric_key_and_iv_from_shared_secret,\n        utils::{array::subarray::subarray, point::point_from_x_coord},\n    };\n    use crate::protocol::address::AztecAddress;\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::try_aes128_decrypt;\n    use std::aes128::aes128_encrypt;\n\n    global CONTRACT_ADDRESS: AztecAddress = AztecAddress { inner: 42 };\n    global TEST_PLAINTEXT_LENGTH: u32 = 10;\n    global TEST_CIPHERTEXT_LENGTH: u32 = 16;\n    global TEST_PADDING_LENGTH: u32 = TEST_CIPHERTEXT_LENGTH - TEST_PLAINTEXT_LENGTH;\n\n    #[test]\n    unconstrained fn aes_encrypt_then_decrypt() {\n        let env = TestEnvironment::new();\n\n        env.utility_context(|_| {\n            let shared_secret_point = point_from_x_coord(1).unwrap();\n            let s_app = compute_app_siloed_shared_secret(shared_secret_point, CONTRACT_ADDRESS);\n\n            let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_shared_secret::<1>(s_app)[0];\n\n            let plaintext: [u8; TEST_PLAINTEXT_LENGTH] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n\n            let ciphertext: [u8; TEST_CIPHERTEXT_LENGTH] = aes128_encrypt(plaintext, iv, sym_key);\n\n            let ciphertext_bvec = BoundedVec::<u8, TEST_CIPHERTEXT_LENGTH>::from_array(ciphertext);\n\n            let received_plaintext = try_aes128_decrypt(ciphertext_bvec, iv, sym_key).unwrap();\n            assert_eq(received_plaintext.len(), TEST_PLAINTEXT_LENGTH);\n            assert_eq(received_plaintext.max_len(), TEST_CIPHERTEXT_LENGTH);\n            assert_eq(subarray::<_, _, TEST_PLAINTEXT_LENGTH>(received_plaintext.storage(), 0), plaintext);\n            assert_eq(\n                subarray::<_, _, TEST_PADDING_LENGTH>(received_plaintext.storage(), TEST_PLAINTEXT_LENGTH),\n                [0 as u8; TEST_PADDING_LENGTH],\n            );\n        })\n    }\n\n    #[test]\n    unconstrained fn aes_encrypt_then_decrypt_with_bad_sym_key_is_caught() {\n        let env = TestEnvironment::new();\n\n        env.utility_context(|_| {\n            // Decrypting with the wrong key results in garbage data with invalid PKCS#7 padding,\n            // so the oracle returns None.\n            let shared_secret_point = point_from_x_coord(1).unwrap();\n            let s_app = compute_app_siloed_shared_secret(shared_secret_point, CONTRACT_ADDRESS);\n\n            let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_shared_secret::<1>(s_app)[0];\n\n            let plaintext: [u8; TEST_PLAINTEXT_LENGTH] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n            let ciphertext: [u8; TEST_CIPHERTEXT_LENGTH] = aes128_encrypt(plaintext, iv, sym_key);\n\n            let mut bad_sym_key = sym_key;\n            bad_sym_key[0] = 0;\n\n            let ciphertext_bvec = BoundedVec::<u8, TEST_CIPHERTEXT_LENGTH>::from_array(ciphertext);\n            // Decryption with wrong key returns None because the garbage output has invalid PKCS#7 padding.\n            let result = try_aes128_decrypt(ciphertext_bvec, iv, bad_sym_key);\n            assert(result.is_none(), \"decryption with bad key should return None\");\n        });\n    }\n}\n"
     },
-    "184": {
+    "188": {
       "function_locations": [
         {
           "name": "call_private_function_oracle",
-          "start": 383
+          "start": 362
         },
         {
           "name": "call_private_function_internal",
-          "start": 619
+          "start": 598
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
-      "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader};\n\n#[oracle(aztec_prv_callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
+      "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(aztec_prv_callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> (u32, Field) {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    )\n}\n"
     },
-    "185": {
+    "189": {
       "function_locations": [
         {
           "name": "call_utility_function_oracle",
@@ -1278,7 +1340,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_utility_function.nr",
       "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(aztec_utl_callUtilityFunction)]\nunconstrained fn call_utility_function_oracle<let M: u32, let N: u32>(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args: [Field; M],\n) -> [Field; N] {}\n\npub unconstrained fn call_utility_function<let M: u32, let N: u32>(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args: [Field; M],\n) -> [Field; N] {\n    call_utility_function_oracle(contract_address, function_selector, args)\n}\n"
     },
-    "186": {
+    "190": {
       "function_locations": [
         {
           "name": "store",
@@ -1372,7 +1434,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\n// TODO(F-498): review naming consistency\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T, scope: AztecAddress)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    set_capsule_oracle(contract_address, slot, serialized, scope);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns\n/// Option::none() if nothing was stored at the given slot.\n// TODO(F-498): review naming consistency\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field, scope: AztecAddress) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = get_capsule_oracle(contract_address, slot, <T as Deserialize>::N, scope);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field, scope: AztecAddress) {\n    delete_oracle(contract_address, slot, scope);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`. Supports overlapping source and\n/// destination regions (which will result in the overlapped source values being overwritten). All copied slots must\n/// exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n    scope: AztecAddress,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries, scope);\n}\n\n#[oracle(aztec_utl_setCapsule)]\nunconstrained fn set_capsule_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n    scope: AztecAddress,\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the\n/// expected shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(aztec_utl_getCapsule)]\nunconstrained fn get_capsule_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n    scope: AztecAddress,\n) -> Option<[Field; N]> {}\n\n#[oracle(aztec_utl_deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field, scope: AztecAddress) {}\n\n#[oracle(aztec_utl_copyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n    scope: AztecAddress,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::MockStruct},\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n\n            assert_eq(load(contract_address, SLOT, scope).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value, scope);\n\n            assert_eq(load(contract_address, SLOT, scope).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n            delete(contract_address, SLOT, scope);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT, scope);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src, scope).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1, scope).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2, scope).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src, scope).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1, scope).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2, scope).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0, scope);\n        });\n    }\n}\n"
     },
-    "187": {
+    "191": {
       "function_locations": [
         {
           "name": "set_contract_sync_cache_invalid_oracle",
@@ -1386,7 +1448,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/contract_sync.nr",
       "source": "use crate::protocol::address::AztecAddress;\n\n#[oracle(aztec_utl_setContractSyncCacheInvalid)]\nunconstrained fn set_contract_sync_cache_invalid_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    scopes: BoundedVec<AztecAddress, N>,\n) {}\n\n/// Forces the PXE to re-sync the given contract for a set of scopes on the next query.\n///\n/// Call this after writing data (e.g. offchain messages) that the contract's `sync_state` function needs to discover.\n/// Without invalidation, the sync cache would skip re-running `sync_state` until the next block.\npub unconstrained fn set_contract_sync_cache_invalid<let N: u32>(\n    contract_address: AztecAddress,\n    scopes: BoundedVec<AztecAddress, N>,\n) {\n    set_contract_sync_cache_invalid_oracle(contract_address, scopes);\n}\n"
     },
-    "189": {
+    "193": {
       "function_locations": [
         {
           "name": "get_utility_context_oracle",
@@ -1400,7 +1462,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use crate::context::UtilityContext;\n\n#[oracle(aztec_utl_getUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContext {}\n\n/// Returns a utility context built from the global variables of anchor block and the contract address of the function\n/// being executed.\npub unconstrained fn get_utility_context() -> UtilityContext {\n    get_utility_context_oracle()\n}\n"
     },
-    "190": {
+    "194": {
       "function_locations": [
         {
           "name": "store",
@@ -1426,7 +1488,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\n// TODO(F-498): review naming consistency\npub fn store<let N: u32>(values: [Field; N], hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { set_hash_preimage_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn set_hash_preimage_oracle_wrapper<let N: u32>(values: [Field; N], hash: Field) {\n    set_hash_preimage_oracle(values, hash);\n}\n\n// TODO(F-498): review naming consistency\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    get_hash_preimage_oracle(hash)\n}\n\n#[oracle(aztec_prv_setHashPreimage)]\nunconstrained fn set_hash_preimage_oracle<let N: u32>(_values: [Field; N], _hash: Field) {}\n\n#[oracle(aztec_prv_getHashPreimage)]\nunconstrained fn get_hash_preimage_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "196": {
+    "201": {
       "function_locations": [
         {
           "name": "get_key_validation_request_oracle",
@@ -1440,71 +1502,63 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr",
       "source": "use crate::protocol::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(aztec_utl_getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(_pk_m_hash: Field, _key_index: Field) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(pk_m_hash: Field, key_index: Field) -> KeyValidationRequest {\n    get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n"
     },
-    "197": {
+    "202": {
       "function_locations": [
         {
           "name": "get_public_keys_and_partial_address",
-          "start": 295
+          "start": 244
         },
         {
           "name": "get_public_keys_and_partial_address_oracle",
-          "start": 947
+          "start": 781
         },
         {
           "name": "try_get_public_keys_and_partial_address",
-          "start": 1124
+          "start": 958
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/keys.nr",
-      "source": "use crate::protocol::{\n    address::{AztecAddress, PartialAddress},\n    point::EmbeddedCurvePoint,\n    public_keys::{IvpkM, PublicKeys},\n};\n\n// TODO(F-498): review naming consistency\npub unconstrained fn get_public_keys_and_partial_address(address: AztecAddress) -> (PublicKeys, PartialAddress) {\n    try_get_public_keys_and_partial_address(address).expect(f\"Public keys not registered for account {address}\")\n}\n\n/// Oracle wire format:\n/// `[npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash, partial_address]`.\n///\n/// Five of the six master public keys are exposed only as hashes; `ivpk_m` is sent\n/// as its affine coordinates because address derivation and encrypt-to-address require the point\n/// in-circuit. This point is assumed to be non-infinite.\n#[oracle(aztec_utl_getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> Option<[Field; 8]> {}\n\n// TODO(F-498): review naming consistency\npub unconstrained fn try_get_public_keys_and_partial_address(\n    address: AztecAddress,\n) -> Option<(PublicKeys, PartialAddress)> {\n    get_public_keys_and_partial_address_oracle(address).map(|result: [Field; 8]| {\n        let keys = PublicKeys {\n            npk_m_hash: result[0],\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: result[1], y: result[2] } },\n            ovpk_m_hash: result[3],\n            tpk_m_hash: result[4],\n            mspk_m_hash: result[5],\n            fbpk_m_hash: result[6],\n        };\n\n        let partial_address = PartialAddress::from_field(result[7]);\n\n        (keys, partial_address)\n    })\n}\n"
+      "source": "use crate::protocol::{address::{AztecAddress, PartialAddress}, public_keys::PublicKeys};\n\n// TODO(F-498): review naming consistency\npub unconstrained fn get_public_keys_and_partial_address(address: AztecAddress) -> (PublicKeys, PartialAddress) {\n    try_get_public_keys_and_partial_address(address).expect(f\"Public keys not registered for account {address}\")\n}\n\n/// Five of the six master public keys are exposed only as hashes; `ivpk_m` is sent as its affine coordinates because\n/// address derivation and encrypt-to-address require the point in-circuit. This point is assumed to be non-infinite.\n#[oracle(aztec_utl_getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(\n    _address: AztecAddress,\n) -> Option<(PublicKeys, PartialAddress)> {}\n\n// TODO(F-498): review naming consistency\npub unconstrained fn try_get_public_keys_and_partial_address(\n    address: AztecAddress,\n) -> Option<(PublicKeys, PartialAddress)> {\n    get_public_keys_and_partial_address_oracle(address)\n}\n"
     },
-    "199": {
+    "204": {
       "function_locations": [
         {
           "name": "get_pending_tagged_logs",
-          "start": 1064
+          "start": 1048
         },
         {
           "name": "get_pending_tagged_logs_oracle",
-          "start": 1337
+          "start": 1321
         },
         {
           "name": "validate_and_store_enqueued_notes_and_events",
-          "start": 1644
+          "start": 1628
         },
         {
           "name": "validate_and_store_enqueued_notes_and_events_oracle",
-          "start": 2063
+          "start": 2047
         },
         {
           "name": "get_logs_by_tag",
-          "start": 2503
+          "start": 2487
         },
         {
           "name": "get_logs_by_tag_oracle",
-          "start": 2729
-        },
-        {
-          "name": "get_message_contexts_by_tx_hash",
-          "start": 2989
-        },
-        {
-          "name": "get_message_contexts_by_tx_hash_oracle",
-          "start": 3233
+          "start": 2713
         },
         {
           "name": "get_tx_effect",
-          "start": 3370
+          "start": 2850
         },
         {
           "name": "get_tx_effect_oracle",
-          "start": 3516
+          "start": 2996
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
-      "source": "use crate::ephemeral::EphemeralArray;\nuse crate::messages::processing::{\n    event_validation_request::EventValidationRequest, log_retrieval_request::LogRetrievalRequest,\n    log_retrieval_response::LogRetrievalResponse, MessageContext, NoteValidationRequest,\n    pending_tagged_log::PendingTaggedLog, provided_secret::ProvidedSecret,\n};\nuse crate::protocol::address::AztecAddress;\nuse crate::protocol::blob_data::TxEffect;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and\n/// returns them in an ephemeral array with an oracle-allocated base slot.\n///\n/// # Arguments\n///\n/// * `scope` - The account scope to search under.\n/// * `provided_secrets` - Tagging secrets the app supplies explicitly, searched alongside the secrets PXE manages\n///   internally. Used for secrets PXE cannot derive itself (e.g. handshake-derived ones).\npub(crate) unconstrained fn get_pending_tagged_logs(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {\n    get_pending_tagged_logs_oracle(scope, provided_secrets)\n}\n\n#[oracle(aztec_utl_getPendingTaggedLogs)]\nunconstrained fn get_pending_tagged_logs_oracle(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {}\n\n/// Validates note/event requests stored in ephemeral arrays.\npub(crate) unconstrained fn validate_and_store_enqueued_notes_and_events(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {\n    validate_and_store_enqueued_notes_and_events_oracle(note_validation_requests, event_validation_requests, scope);\n}\n\n#[oracle(aztec_utl_validateAndStoreEnqueuedNotesAndEvents)]\nunconstrained fn validate_and_store_enqueued_notes_and_events_oracle(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {}\n\n/// Fetches all logs matching each request's tag and returns a nested ephemeral array.\n///\n/// Each element in the outer array is an inner `EphemeralArray<LogRetrievalResponse>` containing all matching logs for\n/// the request at the same index (which may be empty if no logs were found).\npub unconstrained fn get_logs_by_tag(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    get_logs_by_tag_oracle(requests)\n}\n\n#[oracle(aztec_utl_getLogsByTag)]\nunconstrained fn get_logs_by_tag_oracle(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {}\n\n/// Resolves message contexts for tx hashes in an ephemeral request array and returns a response ephemeral array.\npub(crate) unconstrained fn get_message_contexts_by_tx_hash(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {\n    get_message_contexts_by_tx_hash_oracle(requests)\n}\n\n#[oracle(aztec_utl_getMessageContextsByTxHash)]\nunconstrained fn get_message_contexts_by_tx_hash_oracle(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {}\n\n/// Fetches all effects of a settled transaction by its hash.\npub unconstrained fn get_tx_effect(tx_hash: Field) -> Option<TxEffect> {\n    get_tx_effect_oracle(tx_hash)\n}\n\n#[oracle(aztec_utl_getTxEffect)]\nunconstrained fn get_tx_effect_oracle(tx_hash: Field) -> Option<TxEffect> {}\n"
+      "source": "use crate::ephemeral::EphemeralArray;\nuse crate::messages::processing::{\n    event_validation_request::EventValidationRequest, log_retrieval_request::LogRetrievalRequest,\n    log_retrieval_response::LogRetrievalResponse, NoteValidationRequest, pending_tagged_log::PendingTaggedLog,\n    provided_secret::ProvidedSecret,\n};\nuse crate::protocol::address::AztecAddress;\nuse crate::protocol::blob_data::TxEffect;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and\n/// returns them in an ephemeral array with an oracle-allocated base slot.\n///\n/// # Arguments\n///\n/// * `scope` - The account scope to search under.\n/// * `provided_secrets` - Tagging secrets the app supplies explicitly, searched alongside the secrets PXE manages\n///   internally. Used for secrets PXE cannot derive itself (e.g. handshake-derived ones).\npub(crate) unconstrained fn get_pending_tagged_logs(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {\n    get_pending_tagged_logs_oracle(scope, provided_secrets)\n}\n\n#[oracle(aztec_utl_getPendingTaggedLogs)]\nunconstrained fn get_pending_tagged_logs_oracle(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {}\n\n/// Validates note/event requests stored in ephemeral arrays.\npub(crate) unconstrained fn validate_and_store_enqueued_notes_and_events(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {\n    validate_and_store_enqueued_notes_and_events_oracle(note_validation_requests, event_validation_requests, scope);\n}\n\n#[oracle(aztec_utl_validateAndStoreEnqueuedNotesAndEvents)]\nunconstrained fn validate_and_store_enqueued_notes_and_events_oracle(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {}\n\n/// Fetches all logs matching each request's tag and returns a nested ephemeral array.\n///\n/// Each element in the outer array is an inner `EphemeralArray<LogRetrievalResponse>` containing all matching logs for\n/// the request at the same index (which may be empty if no logs were found).\npub unconstrained fn get_logs_by_tag(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    get_logs_by_tag_oracle(requests)\n}\n\n#[oracle(aztec_utl_getLogsByTag)]\nunconstrained fn get_logs_by_tag_oracle(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {}\n\n/// Fetches all effects of a settled transaction by its hash.\npub unconstrained fn get_tx_effect(tx_hash: Field) -> Option<TxEffect> {\n    get_tx_effect_oracle(tx_hash)\n}\n\n#[oracle(aztec_utl_getTxEffect)]\nunconstrained fn get_tx_effect_oracle(tx_hash: Field) -> Option<TxEffect> {}\n"
     },
-    "202": {
+    "207": {
       "function_locations": [
         {
           "name": "notify_created_nullifier",
@@ -1534,7 +1588,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/nullifiers.nr",
       "source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns `true` if the nullifier has been emitted in the same transaction, i.e. if [`notify_created_nullifier`] has\n/// been\n/// called for this inner nullifier from the contract with the specified address.\n///\n/// Note that despite sharing pending transaction information with the app, this is not a privacy leak: anyone in the\n/// network can always determine in which transaction a inner nullifier was emitted by a given contract by simply\n/// inspecting transaction effects. What _would_ constitute a leak would be to share the list of inner pending\n/// nullifiers, as that would reveal their preimages.\npub unconstrained fn is_nullifier_pending(inner_nullifier: Field, contract_address: AztecAddress) -> bool {\n    is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(_inner_nullifier: Field, _contract_address: AztecAddress) -> bool {}\n\n/// Returns `true` if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before\n/// the current transaction is included in a block. While this might seem of little use at first, certain design\n/// patterns benefit from this abstraction (see e.g. `PrivateMutable`).\n// TODO(F-498): review naming consistency\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    does_nullifier_exist_oracle(inner_nullifier)\n}\n\n#[oracle(aztec_utl_doesNullifierExist)]\nunconstrained fn does_nullifier_exist_oracle(_inner_nullifier: Field) -> bool {}\n"
     },
-    "204": {
+    "209": {
       "function_locations": [
         {
           "name": "assert_valid_public_call_data",
@@ -1552,7 +1606,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/public_call.nr",
       "source": "/// Validates public calldata by checking that the preimage exists and the cumulative size is within limits.\n///\n/// The check is unconstrained and the only purpose of it is to fail early in case of calldata overflow or a bug in\n/// calldata hashing.\npub(crate) fn assert_valid_public_call_data(calldata_hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects (validating the calldata).\n    // It is therefore always safe to call.\n    unsafe {\n        assert_valid_public_call_data_oracle_wrapper(calldata_hash)\n    }\n}\n\nunconstrained fn assert_valid_public_call_data_oracle_wrapper(calldata_hash: Field) {\n    assert_valid_public_call_data_oracle(calldata_hash)\n}\n\n#[oracle(aztec_prv_assertValidPublicCalldata)]\nunconstrained fn assert_valid_public_call_data_oracle(_calldata_hash: Field) {}\n"
     },
-    "205": {
+    "210": {
       "function_locations": [
         {
           "name": "random",
@@ -1566,7 +1620,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
       "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values. In some applications this\n/// behavior might not be acceptable and other techniques might be more suitable, such as producing pseudo-random\n/// values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n    rand_oracle()\n}\n\n#[oracle(aztec_misc_getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
     },
-    "206": {
+    "212": {
       "function_locations": [
         {
           "name": "get_shared_secrets_oracle",
@@ -1600,7 +1654,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, point::EmbeddedCurvePoint};\n\nglobal GET_SHARED_SECRET_SINGLE_SLOT: Field = sha256_to_field(\"AZTEC_NR::GET_SHARED_SECRET_SINGLE_SLOT\".as_bytes());\n\n#[oracle(aztec_utl_getSharedSecrets)]\nunconstrained fn get_shared_secrets_oracle(\n    address: AztecAddress,\n    eph_pks: EphemeralArray<EmbeddedCurvePoint>,\n    contract_address: AztecAddress,\n) -> EphemeralArray<Field> {}\n\n/// Convenience wrapper around [`get_shared_secrets`] for a single ephemeral public key.\npub unconstrained fn get_shared_secret(\n    address: AztecAddress,\n    eph_pk: EmbeddedCurvePoint,\n    contract_address: AztecAddress,\n) -> Field {\n    let eph_pks: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(GET_SHARED_SECRET_SINGLE_SLOT);\n    eph_pks.push(eph_pk);\n    let secrets = get_shared_secrets(address, eph_pks, contract_address);\n    secrets.get(0)\n}\n\n/// Returns app-siloed shared secrets between `address` and someone who knows the secret keys behind the given\n/// ephemeral public keys.\n///\n/// Each returned Field `s_app` is computed as:\n///\n/// ```text\n/// S     = address_secret * ephPk          (raw ECDH point)\n/// s_app = h(DOM_SEP, S.x, S.y, contract)  (app-siloed scalar)\n/// ```\n///\n/// where `contract` is the address of the calling contract. The oracle host validates this matches its execution\n/// context.\n///\n/// Without app-siloing, a malicious contract could call this oracle with public information (address, ephPk) and\n/// obtain the same raw secret as the legitimate contract, enabling cross-contract decryption. By including the\n/// contract address in the hash, each contract receives a different `s_app`, preventing this attack.\n///\n/// Callers derive indexed subkeys from `s_app` via\n/// [`derive_shared_secret_subkey`](crate::keys::ecdh_shared_secret::derive_shared_secret_subkey).\npub unconstrained fn get_shared_secrets(\n    address: AztecAddress,\n    eph_pks: EphemeralArray<EmbeddedCurvePoint>,\n    contract_address: AztecAddress,\n) -> EphemeralArray<Field> {\n    let response = get_shared_secrets_oracle(address, eph_pks, contract_address);\n    assert(response.len() == eph_pks.len(), \"get_shared_secrets: response length does not match request length\");\n    response\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::oracle::shared_secret::get_shared_secrets;\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use crate::utils::point::point_from_x_coord;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn preserves_ephemeral_key_ordering() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([100, 200, 300]);\n\n            let pk_a = point_from_x_coord(1).unwrap();\n            let pk_b = point_from_x_coord(2).unwrap();\n            let pk_c = point_from_x_coord(8).unwrap();\n\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk_a);\n            eph_pks.push(pk_b);\n            eph_pks.push(pk_c);\n\n            let _: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(eph_pks.get(0), pk_a);\n            assert_eq(eph_pks.get(1), pk_b);\n            assert_eq(eph_pks.get(2), pk_c);\n        });\n    }\n\n    #[test]\n    unconstrained fn returns_secrets_in_order() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111, 222, 333]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk);\n            eph_pks.push(pk);\n            eph_pks.push(pk);\n\n            let results: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(results.get(0), 111);\n            assert_eq(results.get(1), 222);\n            assert_eq(results.get(2), 333);\n        });\n    }\n\n    #[test(should_fail_with = \"response length does not match request length\")]\n    unconstrained fn cannot_return_mismatched_length() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111, 222]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk);\n\n            let _: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n        });\n    }\n\n    unconstrained fn mock_get_shared_secrets<let N: u32>(response_values: [Field; N]) -> Field {\n        let response_slot: Field = 99;\n        let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n        for value in response_values {\n            response_array.push(value);\n        }\n        let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n        response_slot\n    }\n}\n"
     },
-    "209": {
+    "215": {
       "function_locations": [
         {
           "name": "notify_revertible_phase_start",
@@ -1626,7 +1680,25 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/tx_phase.nr",
       "source": "/// Notifies PXE of the side effect counter at which the revertible phase begins.\n///\n/// PXE uses it to classify notes and nullifiers as revertible or non-revertible in its note cache. This information is\n/// then fed to kernels as hints.\npub(crate) fn notify_revertible_phase_start(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_revertible_phase_start_oracle_wrapper(counter) };\n}\n\n/// Returns whether a side effect counter falls in the revertible phase of the transaction.\npub(crate) unconstrained fn is_execution_in_revertible_phase(current_counter: u32) -> bool {\n    is_execution_in_revertible_phase_oracle(current_counter)\n}\n\nunconstrained fn notify_revertible_phase_start_oracle_wrapper(counter: u32) {\n    notify_revertible_phase_start_oracle(counter);\n}\n\n#[oracle(aztec_prv_notifyRevertiblePhaseStart)]\nunconstrained fn notify_revertible_phase_start_oracle(_counter: u32) {}\n\n#[oracle(aztec_prv_isExecutionInRevertiblePhase)]\nunconstrained fn is_execution_in_revertible_phase_oracle(current_counter: u32) -> bool {}\n"
     },
-    "210": {
+    "216": {
+      "function_locations": [
+        {
+          "name": "get_resolved_txs",
+          "start": 608
+        },
+        {
+          "name": "get_resolved_txs_oracle",
+          "start": 799
+        },
+        {
+          "name": "test::resolved_tx_serialization_matches_typescript",
+          "start": 991
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/tx_resolution.nr",
+      "source": "use crate::ephemeral::EphemeralArray;\nuse crate::protocol::{constants::MAX_NOTE_HASHES_PER_TX, traits::{Deserialize, Serialize}};\n\n/// The resolved on-chain context of a transaction.\n#[derive(Serialize, Deserialize, Eq)]\npub struct ResolvedTx {\n    pub tx_hash: Field,\n    pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    pub first_nullifier_in_tx: Field,\n    pub block_number: u32,\n    pub block_hash: Field,\n}\n\n/// Resolves the on-chain context of each tx hash.\npub(crate) unconstrained fn get_resolved_txs(requests: EphemeralArray<Field>) -> EphemeralArray<Option<ResolvedTx>> {\n    get_resolved_txs_oracle(requests)\n}\n\n#[oracle(aztec_utl_getResolvedTxs)]\nunconstrained fn get_resolved_txs_oracle(requests: EphemeralArray<Field>) -> EphemeralArray<Option<ResolvedTx>> {}\n\nmod test {\n    use crate::oracle::tx_resolution::ResolvedTx;\n    use crate::protocol::traits::Deserialize;\n\n    #[test]\n    unconstrained fn resolved_tx_serialization_matches_typescript() {\n        // Setup test data\n        let tx_hash = 123;\n        let unique_note_hashes = BoundedVec::from_array([4, 5]);\n        let first_nullifier = 6;\n        let block_number: u32 = 7;\n        let block_hash = 8;\n\n        // Create a ResolvedTx instance\n        let resolved_tx = ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: unique_note_hashes,\n            first_nullifier_in_tx: first_nullifier,\n            block_number,\n            block_hash,\n        };\n\n        // Expected output generated from TypeScript's `ResolvedTx.toFields()`\n        let serialized_resolved_tx_from_typescript = [\n            0x000000000000000000000000000000000000000000000000000000000000007b,\n            0x0000000000000000000000000000000000000000000000000000000000000004,\n            0x0000000000000000000000000000000000000000000000000000000000000005,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000000,\n            0x0000000000000000000000000000000000000000000000000000000000000002,\n            0x0000000000000000000000000000000000000000000000000000000000000006,\n            0x0000000000000000000000000000000000000000000000000000000000000007,\n            0x0000000000000000000000000000000000000000000000000000000000000008,\n        ];\n\n        let deserialized = ResolvedTx::deserialize(serialized_resolved_tx_from_typescript);\n\n        assert_eq(deserialized, resolved_tx);\n    }\n}\n"
+    },
+    "217": {
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
@@ -1650,9 +1722,9 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
-      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 29;\npub global ORACLE_VERSION_MINOR: Field = 1;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
+      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 30;\npub global ORACLE_VERSION_MINOR: Field = 1;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
     },
-    "260": {
+    "270": {
       "function_locations": [
         {
           "name": "UnconstrainedArray<T, Oracle>::at",
@@ -1696,33 +1768,33 @@
         },
         {
           "name": "UnconstrainedArray<T, Oracle>::for_each",
-          "start": 6141
+          "start": 6201
         },
         {
           "name": "UnconstrainedArray<T, Oracle>::map",
-          "start": 6517
+          "start": 6555
         },
         {
           "name": "UnconstrainedArray<T, Oracle>::filter",
-          "start": 6937
+          "start": 6975
         },
         {
           "name": "UnconstrainedArray<T, Oracle>::any",
-          "start": 7397
+          "start": 7435
         },
         {
           "name": "UnconstrainedArray<T, Oracle>::all",
-          "start": 7682
+          "start": 7720
         },
         {
           "name": "UnconstrainedArray<T, Oracle>::find",
-          "start": 7957
+          "start": 7995
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/unconstrained_array/mod.nr",
-      "source": "pub(crate) mod test_helpers;\npub(crate) mod test_suite;\n\nuse crate::oracle::random::random;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\n/// Oracle backend for an [`UnconstrainedArray`]: the set of PXE-side operations that implement its storage.\n///\n/// Each implementor routes these operations to a distinct family of oracles, and the oracle family determines the\n/// array's lifetime and visibility (e.g. [`EphemeralArray`](crate::ephemeral::EphemeralArray) arrays live for one\n/// contract call frame, while [`TransientArray`](crate::transient::TransientArray) arrays are shared across all frames\n/// of the same contract within one top-level PXE call).\npub(crate) trait ArrayOracles {\n    /// Returns the number of elements in the array at `slot`.\n    unconstrained fn len_oracle(slot: Field) -> u32;\n\n    /// Appends a serialized element to the array at `slot` and returns the new length.\n    unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32;\n\n    /// Removes and returns the last serialized element of the array at `slot`. Implementors must panic if the\n    /// array is empty.\n    unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N];\n\n    /// Returns the serialized element at the given index of the array at `slot`. Implementors must panic if `index`\n    /// is out of bounds.\n    unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N];\n\n    /// Overwrites the serialized element at the given index of the array at `slot`. Implementors must panic if\n    /// `index` is out of bounds.\n    unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]);\n\n    /// Removes the element at the given index of the array at `slot`, shifting subsequent elements backward.\n    /// Implementors must panic if `index` is out of bounds.\n    unconstrained fn remove_oracle(slot: Field, index: u32);\n\n    /// Removes all elements from the array at `slot`.\n    unconstrained fn clear_oracle(slot: Field);\n}\n\n/// A dynamically sized array backed by PXE-side in-memory storage via an [`ArrayOracles`] backend.\n///\n/// Arrays are identified by a slot, and each logical operation (push, pop, get, etc.) is a single oracle call. The\n/// `Oracle` backend determines the array's lifetime and visibility; contracts should not use this type directly but\n/// rather one of its aliases: [`EphemeralArray`](crate::ephemeral::EphemeralArray) (scoped to a single contract call\n/// frame) or [`TransientArray`](crate::transient::TransientArray) (shared across all frames of the same contract\n/// within one top-level PXE call).\npub struct UnconstrainedArray<T, Oracle> {\n    pub(crate) slot: Field,\n}\n\nimpl<T, Oracle> UnconstrainedArray<T, Oracle>\nwhere\n    Oracle: ArrayOracles,\n{\n    /// Returns a handle to the array at the given slot, which may already contain data (e.g. populated by an oracle\n    /// or by an earlier frame, depending on the backend's visibility).\n    pub unconstrained fn at(slot: Field) -> Self {\n        Self { slot }\n    }\n\n    /// Returns an empty array at the given slot, clearing any pre-existing data.\n    ///\n    /// For backends whose arrays are visible beyond a single call frame (e.g. transient arrays), this wipes data\n    /// other frames of the same contract may have written at the slot.\n    pub unconstrained fn empty_at(slot: Field) -> Self {\n        Self::at(slot).clear()\n    }\n\n    /// Returns an empty array at a fresh, randomly allocated slot.\n    ///\n    /// Use this when the caller does not need a specific slot: the random slot is isolated from every other array of\n    /// the same backend with overwhelming probability. Prefer [`UnconstrainedArray::empty_at`] when the slot must be a\n    /// known value (e.g. one shared with an oracle or another call frame).\n    pub unconstrained fn empty() -> Self {\n        Self::at(random())\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        Oracle::len_oracle(self.slot)\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        let _ = Oracle::push_oracle(self.slot, serialized);\n    }\n\n    /// Removes and returns the last element. Implementors are required to panic if the array is empty.\n    pub unconstrained fn pop(self) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::pop_oracle(self.slot);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Retrieves the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::get_oracle(self.slot, index);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Overwrites the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn set(self, index: u32, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        Oracle::set_oracle(self.slot, index, serialized);\n    }\n\n    /// Removes the element at `index`, shifting subsequent elements backward. Implementors are required to panic if\n    /// the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        Oracle::remove_oracle(self.slot, index);\n    }\n\n    /// Removes all elements from the array and returns self for chaining.\n    pub unconstrained fn clear(self) -> Self {\n        Oracle::clear_oracle(self.slot);\n        self\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index. Iteration proceeds\n    /// backwards so that it is safe to remove the current element (and only the current element) inside the\n    /// callback.\n    ///\n    /// It is **not** safe to push new elements from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n\n    /// Applies `f` to every element and collects the results into a fresh array.\n    pub unconstrained fn map<U, Env>(self, f: unconstrained fn[Env](T) -> U) -> UnconstrainedArray<U, Oracle>\n    where\n        T: Deserialize,\n        U: Serialize,\n    {\n        let dest: UnconstrainedArray<U, Oracle> = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            dest.push(f(self.get(i)));\n        }\n        dest\n    }\n\n    /// Collects every element satisfying the predicate `f` into a fresh array.\n    pub unconstrained fn filter<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Self\n    where\n        T: Serialize + Deserialize,\n    {\n        let dest: Self = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            let value = self.get(i);\n            if f(value) {\n                dest.push(value);\n            }\n        }\n        dest\n    }\n\n    /// Returns `true` if at least one element satisfies the predicate `f`.\n    pub unconstrained fn any<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() != 0\n    }\n\n    /// Returns `true` if every element satisfies the predicate `f` (vacuously `true` for an empty array).\n    pub unconstrained fn all<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() == self.len()\n    }\n\n    /// Returns the first element satisfying the predicate `f`, or `Option::none` if none do.\n    pub unconstrained fn find<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Option<T>\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        let mut result: Option<T> = Option::none();\n        let mut i = 0;\n        while (i < n) & result.is_none() {\n            let value = self.get(i);\n            if f(value) {\n                result = Option::some(value);\n            }\n            i += 1;\n        }\n        result\n    }\n}\n"
+      "source": "pub(crate) mod test_helpers;\npub(crate) mod test_suite;\n\nuse crate::oracle::random::random;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\n/// Oracle backend for an [`UnconstrainedArray`]: the set of PXE-side operations that implement its storage.\n///\n/// Each implementor routes these operations to a distinct family of oracles, and the oracle family determines the\n/// array's lifetime and visibility (e.g. [`EphemeralArray`](crate::ephemeral::EphemeralArray) arrays live for one\n/// contract call frame, while [`TransientArray`](crate::transient::TransientArray) arrays are shared across all frames\n/// of the same contract within one top-level PXE call).\npub(crate) trait ArrayOracles {\n    /// Returns the number of elements in the array at `slot`.\n    unconstrained fn len_oracle(slot: Field) -> u32;\n\n    /// Appends a serialized element to the array at `slot` and returns the new length.\n    unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32;\n\n    /// Removes and returns the last serialized element of the array at `slot`. Implementors must panic if the\n    /// array is empty.\n    unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N];\n\n    /// Returns the serialized element at the given index of the array at `slot`. Implementors must panic if `index`\n    /// is out of bounds.\n    unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N];\n\n    /// Overwrites the serialized element at the given index of the array at `slot`. Implementors must panic if\n    /// `index` is out of bounds.\n    unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]);\n\n    /// Removes the element at the given index of the array at `slot`, shifting subsequent elements backward.\n    /// Implementors must panic if `index` is out of bounds.\n    unconstrained fn remove_oracle(slot: Field, index: u32);\n\n    /// Removes all elements from the array at `slot`.\n    unconstrained fn clear_oracle(slot: Field);\n}\n\n/// A dynamically sized array backed by PXE-side in-memory storage via an [`ArrayOracles`] backend.\n///\n/// Arrays are identified by a slot, and each logical operation (push, pop, get, etc.) is a single oracle call. The\n/// `Oracle` backend determines the array's lifetime and visibility; contracts should not use this type directly but\n/// rather one of its aliases: [`EphemeralArray`](crate::ephemeral::EphemeralArray) (scoped to a single contract call\n/// frame) or [`TransientArray`](crate::transient::TransientArray) (shared across all frames of the same contract\n/// within one top-level PXE call).\npub struct UnconstrainedArray<T, Oracle> {\n    pub(crate) slot: Field,\n}\n\nimpl<T, Oracle> UnconstrainedArray<T, Oracle>\nwhere\n    Oracle: ArrayOracles,\n{\n    /// Returns a handle to the array at the given slot, which may already contain data (e.g. populated by an oracle\n    /// or by an earlier frame, depending on the backend's visibility).\n    pub unconstrained fn at(slot: Field) -> Self {\n        Self { slot }\n    }\n\n    /// Returns an empty array at the given slot, clearing any pre-existing data.\n    ///\n    /// For backends whose arrays are visible beyond a single call frame (e.g. transient arrays), this wipes data\n    /// other frames of the same contract may have written at the slot.\n    pub unconstrained fn empty_at(slot: Field) -> Self {\n        Self::at(slot).clear()\n    }\n\n    /// Returns an empty array at a fresh, randomly allocated slot.\n    ///\n    /// Use this when the caller does not need a specific slot: the random slot is isolated from every other array of\n    /// the same backend with overwhelming probability. Prefer [`UnconstrainedArray::empty_at`] when the slot must be a\n    /// known value (e.g. one shared with an oracle or another call frame).\n    pub unconstrained fn empty() -> Self {\n        Self::at(random())\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        Oracle::len_oracle(self.slot)\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        let _ = Oracle::push_oracle(self.slot, serialized);\n    }\n\n    /// Removes and returns the last element. Implementors are required to panic if the array is empty.\n    pub unconstrained fn pop(self) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::pop_oracle(self.slot);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Retrieves the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::get_oracle(self.slot, index);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Overwrites the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn set(self, index: u32, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        Oracle::set_oracle(self.slot, index, serialized);\n    }\n\n    /// Removes the element at `index`, shifting subsequent elements backward. Implementors are required to panic if\n    /// the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        Oracle::remove_oracle(self.slot, index);\n    }\n\n    /// Removes all elements from the array and returns self for chaining.\n    pub unconstrained fn clear(self) -> Self {\n        Oracle::clear_oracle(self.slot);\n        self\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index, in order (from the first\n    /// element to the last).\n    ///\n    /// Structurally mutating the array from inside the callback (e.g. via `push`, `pop`, `remove` or `clear`) is\n    /// **not** supported: it can cause elements to be skipped, visited more than once, or read out of bounds.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        for i in 0..n {\n            f(i, self.get(i));\n        }\n    }\n\n    /// Applies `f` to every element and collects the results into a fresh array.\n    pub unconstrained fn map<U, Env>(self, f: unconstrained fn[Env](T) -> U) -> UnconstrainedArray<U, Oracle>\n    where\n        T: Deserialize,\n        U: Serialize,\n    {\n        let dest: UnconstrainedArray<U, Oracle> = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            dest.push(f(self.get(i)));\n        }\n        dest\n    }\n\n    /// Collects every element satisfying the predicate `f` into a fresh array.\n    pub unconstrained fn filter<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Self\n    where\n        T: Serialize + Deserialize,\n    {\n        let dest: Self = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            let value = self.get(i);\n            if f(value) {\n                dest.push(value);\n            }\n        }\n        dest\n    }\n\n    /// Returns `true` if at least one element satisfies the predicate `f`.\n    pub unconstrained fn any<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() != 0\n    }\n\n    /// Returns `true` if every element satisfies the predicate `f` (vacuously `true` for an empty array).\n    pub unconstrained fn all<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() == self.len()\n    }\n\n    /// Returns the first element satisfying the predicate `f`, or `Option::none` if none do.\n    pub unconstrained fn find<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Option<T>\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        let mut result: Option<T> = Option::none();\n        let mut i = 0;\n        while (i < n) & result.is_none() {\n            let value = self.get(i);\n            if f(value) {\n                result = Option::some(value);\n            }\n            i += 1;\n        }\n        result\n    }\n}\n"
     },
-    "263": {
+    "273": {
       "function_locations": [
         {
           "name": "append",
@@ -1744,7 +1816,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends the elements of the second `BoundedVec` to the end of the first one. The resulting `BoundedVec` can have\n/// any arbitrary maximum length, but it must be large enough to fit all of the elements of both the first and second\n/// vectors.\npub fn append<T, let ALen: u32, let BLen: u32, let DstLen: u32>(\n    a: BoundedVec<T, ALen>,\n    b: BoundedVec<T, BLen>,\n) -> BoundedVec<T, DstLen> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "266": {
+    "276": {
       "function_locations": [
         {
           "name": "subarray",
@@ -1774,7 +1846,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DstLen` elements from a source array, starting at `offset`. `DstLen` must not be larger than the number of\n/// elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SrcLen: u32, let DstLen: u32>(src: [T; SrcLen], offset: u32) -> [T; DstLen] {\n    assert(offset + DstLen <= SrcLen, \"DstLen too large for offset\");\n\n    let mut dst: [T; DstLen] = std::mem::zeroed();\n    for i in 0..DstLen {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DstLen to be 0, so we always get back an empty array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "267": {
+    "277": {
       "function_locations": [
         {
           "name": "subbvec",
@@ -1816,7 +1888,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DstMaxLen` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DstLen` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DstLen` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SrcMaxLen: u32, let DstMaxLen: u32>(\n    bvec: BoundedVec<T, SrcMaxLen>,\n    offset: u32,\n) -> BoundedVec<T, DstMaxLen> {\n    // The new storage array is a subarray of the original one (which has zeroed storage past len), so elements past\n    // the new len remain zeroed: `subarray` does not allow extending arrays past their original length.\n    BoundedVec::from_parts(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not support capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "270": {
+    "280": {
       "function_locations": [
         {
           "name": "encode_bytes_as_fields",
@@ -1842,7 +1914,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_as_fields.nr",
       "source": "use std::static_assert;\n\n/// Encodes an array of bytes as fields.\n///\n/// Use\n/// [`decode_bytes_from_fields`](crate::utils::conversion::bytes_as_fields::decode_bytes_from_fields) to recover\n/// the original bytes.\n///\n/// The `bytes` array length must be a multiple of 31. If padding is added, it will need to be manually removed\n/// after decoding.\n///\n/// ## Encoding\n///\n/// Each 31-byte chunk is interpreted as a big-endian integer and stored in a `Field`. For input `[1, 10, 3, ..., 0]`\n/// (31 bytes), the resulting `Field` is `1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0`.\npub fn encode_bytes_as_fields<let N: u32>(bytes: [u8; N]) -> [Field; N / 31] {\n    static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n    let mut fields = [0; N / 31];\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    fields\n}\n\n/// Decodes fields back into bytes.\n///\n/// Inverse of\n/// [`encode_bytes_as_fields`](crate::utils::conversion::bytes_as_fields::encode_bytes_as_fields).\n/// Each input `Field` must fit in 248 bits; `Field::to_be_bytes::<31>()` fails the proof otherwise.\npub fn decode_bytes_from_fields<let N: u32>(fields: BoundedVec<Field, N>) -> BoundedVec<u8, N * 31> {\n    let mut bytes = BoundedVec::new();\n    for i in 0..fields.len() {\n        let chunk: [u8; 31] = fields.get(i).to_be_bytes();\n        for j in 0..31 {\n            bytes.push(chunk[j]);\n        }\n    }\n    bytes\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{decode_bytes_from_fields, encode_bytes_as_fields};\n\n    #[test]\n    unconstrained fn round_trips_bytes(input: [u8; 93]) {\n        let fields = encode_bytes_as_fields(input);\n\n        // In production the fields fly through the system and arrive as a BoundedVec on the other end.\n        let fields_bvec = BoundedVec::<_, 6>::from_array(fields);\n        let bytes_back = decode_bytes_from_fields(fields_bvec);\n\n        assert_eq(bytes_back.len(), input.len());\n        assert_eq(subarray(bytes_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"N must be a multiple of 31\")]\n    unconstrained fn encode_rejects_length_not_multiple_of_31() {\n        let _fields = encode_bytes_as_fields([0; 32]);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 31 limbs\")]\n    unconstrained fn decode_rejects_oversized_field() {\n        // `Field::to_be_bytes::<31>()` fails the proof when a field has any bit above position 247 set.\n        let oversized: Field = (1 as Field) * 2.pow_32(249);\n        let input = BoundedVec::<_, 1>::from_array([oversized]);\n        let _bytes = decode_bytes_from_fields(input);\n    }\n}\n"
     },
-    "271": {
+    "281": {
       "function_locations": [
         {
           "name": "encode_fields_as_bytes",
@@ -1892,7 +1964,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_as_bytes.nr",
       "source": "/// Encodes an array of fields as bytes.\n///\n/// Losslessly preserves any field value; use\n/// [`try_decode_fields_from_bytes`](crate::utils::conversion::fields_as_bytes::try_decode_fields_from_bytes) to\n/// recover the original fields.\n///\n/// ## Encoding\n///\n/// Each field is written as 32 big-endian bytes and the chunks are concatenated. The field array `[5, 42]` becomes:\n///\n/// ```text\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,  // First field (32 bytes)\n///  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42] // Second field (32 bytes)\n/// ```\n///\n/// ## Privacy\n///\n/// The BN254 modulus is `< 2^254`, so every 32-byte chunk has its top bit at zero and the next bit biased. The output\n/// is therefore distinguishable from uniform random bytes; take this into account when feeding it into anything that\n/// assumes uniform randomness (e.g. ciphertexts meant to look random).\npub fn encode_fields_as_bytes<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n    for i in 0..N {\n        let chunk: [u8; 32] = fields[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[i * 32 + j] = chunk[j];\n        }\n    }\n    bytes\n}\n\n/// Decodes bytes back into fields.\n///\n/// Panics if the input length is not a multiple of 32 or if any chunk exceeds the BN254 field modulus. See\n/// [`try_decode_fields_from_bytes`](crate::utils::conversion::fields_as_bytes::try_decode_fields_from_bytes)\n/// for a non-panicking variant.\npub fn decode_fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> BoundedVec<Field, N / 32> {\n    assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n    try_decode_fields_from_bytes(bytes).expect(f\"Value does not fit in field\")\n}\n\n/// Decodes bytes back into fields, returning None on failure.\n///\n/// Inverse of\n/// [`encode_fields_as_bytes`](crate::utils::conversion::fields_as_bytes::encode_fields_as_bytes).\n/// Returns `Option::none()` if the input length is not a multiple of 32, or if any 32-byte chunk is `>=` the BN254\n/// field modulus.\npub fn try_decode_fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> Option<BoundedVec<Field, N / 32>> {\n    if bytes.len() % 32 == 0 {\n        let num_chunks = bytes.len() / 32;\n        let mut fields: BoundedVec<Field, N / 32> = BoundedVec::new();\n        for i in 0..num_chunks {\n            let maybe_field = try_decode_field_from_bytes(bytes, i * 32);\n            if maybe_field.is_some() {\n                fields.push(maybe_field.unwrap());\n            }\n        }\n        if fields.len() == num_chunks {\n            Option::some(fields)\n        } else {\n            Option::none()\n        }\n    } else {\n        Option::none()\n    }\n}\n\nfn try_decode_field_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>, offset: u32) -> Option<Field> {\n    // Field arithmetic silently wraps values >= the modulus, so we compare each chunk against the modulus\n    // byte-by-byte (big-endian) while building `field`. cmp: 0 = equal so far, 1 = less than modulus, 2 = exceeds.\n    let p = std::field::modulus_be_bytes();\n    let mut field = 0;\n    let mut cmp: u8 = 0;\n    for j in 0..32 {\n        let byte = bytes.get(offset + j);\n        field = field * 256 + byte as Field;\n        if cmp == 0 {\n            if byte < p[j] {\n                cmp = 1;\n            } else if byte > p[j] {\n                cmp = 2;\n            }\n        }\n    }\n\n    if cmp == 1 {\n        Option::some(field)\n    } else {\n        Option::none()\n    }\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{decode_fields_from_bytes, encode_fields_as_bytes, try_decode_fields_from_bytes};\n\n    #[test]\n    unconstrained fn round_trips_fields(input: [Field; 3]) {\n        let bytes = encode_fields_as_bytes(input);\n\n        // In production the bytes fly through the system and arrive as a BoundedVec on the other end. 113 is an\n        // arbitrary max length larger than the input length of 96.\n        let bytes_bvec = BoundedVec::<_, 113>::from_array(bytes);\n        let fields_back = try_decode_fields_from_bytes(bytes_bvec).unwrap();\n\n        assert_eq(fields_back.len(), input.len());\n        assert_eq(subarray(fields_back.storage(), 0), input);\n    }\n\n    #[test]\n    unconstrained fn try_decode_returns_none_on_length_not_multiple_of_32() {\n        let input = BoundedVec::<_, 64>::from_parts([0 as u8; 64], 33);\n        assert(try_decode_fields_from_bytes(input).is_none());\n    }\n\n    #[test]\n    unconstrained fn try_decode_accepts_max_field() {\n        // -1 in field arithmetic wraps to `modulus - 1`, the largest valid field value.\n        let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n        let fields = try_decode_fields_from_bytes(input).unwrap();\n\n        assert_eq(fields.get(0), -1);\n    }\n\n    // Verifies the overflow check: take the max allowed value, bump a random byte, feed it in.\n    #[test]\n    unconstrained fn try_decode_returns_none_on_chunk_above_modulus(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump as u32];\n\n        // Skip if the selected byte is already 255. Acceptable under fuzz testing.\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n            assert(try_decode_fields_from_bytes(input).is_none());\n        }\n    }\n\n    #[test]\n    unconstrained fn try_decode_returns_none_on_chunk_equal_to_modulus() {\n        // The field modulus itself is not a valid field value (it wraps to 0).\n        let p: [u8; 32] = std::field::modulus_be_bytes().as_array();\n        let input = BoundedVec::<u8, 32>::from_array(p);\n        assert(try_decode_fields_from_bytes(input).is_none());\n    }\n\n    #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n    unconstrained fn decode_asserts_length_multiple_of_32() {\n        let input = BoundedVec::<_, 143>::from_array([\n            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,\n            30, 31, 32, 33,\n        ]);\n        let _fields = decode_fields_from_bytes(input);\n    }\n\n    #[test(should_fail_with = \"Value does not fit in field\")]\n    unconstrained fn decode_panics_on_chunk_above_modulus(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump as u32];\n\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n            let _fields = decode_fields_from_bytes(input);\n        }\n    }\n}\n"
     },
-    "274": {
+    "284": {
       "function_locations": [
         {
           "name": "get_sign_of_point",
@@ -1942,7 +2014,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use crate::protocol::{point::EmbeddedCurvePoint, utils::field::sqrt};\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field = 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Returns: true if p.y <= MOD_DIV_2, else false.\npub fn get_sign_of_point(p: EmbeddedCurvePoint) -> bool {\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get the\n    // sign we check if the y coordinate is less or equal than the field's modulus minus 1 divided by 2. Ideally we'd\n    // do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is equivalent,\n    // and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\n/// Returns an `EmbeddedCurvePoint` in the Grumpkin curve given its x coordinate.\n///\n/// Because not all values in the field are valid x coordinates of points in the curve (i.e. there is no corresponding\n/// y value in the field that satisfies the curve equation), it may not be possible to reconstruct a `Point`.\n/// `Option::none()` is returned in such cases.\npub fn point_from_x_coord(x: Field) -> Option<EmbeddedCurvePoint> {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    sqrt(rhs).map(|y| EmbeddedCurvePoint { x, y })\n}\n\n/// Returns an `EmbeddedCurvePoint` in the Grumpkin curve given its x coordinate and sign for the y coordinate.\n///\n/// Because not all values in the field are valid x coordinates of points in the curve (i.e. there is no corresponding\n/// y value in the field that satisfies the curve equation), it may not be possible to reconstruct a `Point`.\n/// `Option::none()` is returned in such cases.\n///\n/// @param x - The x coordinate of the point @param sign - The \"sign\" of the y coordinate - determines whether y <=\n/// (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Option<EmbeddedCurvePoint> {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n\n    sqrt(rhs).map(|y| {\n        // If there is a square root, we need to ensure it has the correct \"sign\"\n        let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n        let final_y = if y_is_positive == sign { y } else { -y };\n        EmbeddedCurvePoint { x, y: final_y }\n    })\n}\n\nmod test {\n    use crate::protocol::point::EmbeddedCurvePoint;\n    use crate::utils::point::{\n        BN254_FR_MODULUS_DIV_2, get_sign_of_point, point_from_x_coord, point_from_x_coord_and_sign,\n    };\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign() {\n        // Test positive y coordinate\n        let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n        let sign = true;\n        let p = point_from_x_coord_and_sign(x, sign).unwrap();\n\n        assert_eq(p.x, x);\n        assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n        assert_eq(p.is_infinite(), false);\n\n        // Test negative y coordinate\n        let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n        let sign2 = false;\n        let p2 = point_from_x_coord_and_sign(x2, sign2).unwrap();\n\n        assert_eq(p2.x, x2);\n        assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n        assert_eq(p2.is_infinite(), false);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_valid() {\n        // x = 8 is a known quadratic residue - should give a valid point\n        let result = point_from_x_coord(Field::from(8));\n        assert(result.is_some());\n\n        let point = result.unwrap();\n        assert_eq(point.x, Field::from(8));\n        // Check curve equation y^2 = x^3 - 17\n        assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_invalid() {\n        // x = 3 is a non-residue for this curve - should give None\n        let x = Field::from(3);\n        let maybe_point = point_from_x_coord(x);\n        assert(maybe_point.is_none());\n    }\n\n    #[test]\n    unconstrained fn test_both_roots_satisfy_curve() {\n        // Derive a point from x = 8 (known to be valid from test_point_from_x_coord_valid)\n        let x: Field = 8;\n        let point = point_from_x_coord(x).unwrap();\n\n        // Check y satisfies curve equation\n        assert_eq(point.y * point.y, x * x * x - 17);\n\n        // Check -y also satisfies curve equation\n        let neg_y = 0 - point.y;\n        assert_eq(neg_y * neg_y, x * x * x - 17);\n\n        // Verify they are different (unless y = 0)\n        assert(point.y != neg_y);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign_invalid() {\n        // x = 3 has no valid point on the curve (from test_point_from_x_coord_invalid)\n        let x = Field::from(3);\n        let result_positive = point_from_x_coord_and_sign(x, true);\n        let result_negative = point_from_x_coord_and_sign(x, false);\n\n        assert(result_positive.is_none());\n        assert(result_negative.is_none());\n    }\n\n    #[test]\n    unconstrained fn test_get_sign_of_point() {\n        // Derive a point from x = 8, then test both possible y values\n        let point = point_from_x_coord(8).unwrap();\n        let neg_point = EmbeddedCurvePoint { x: point.x, y: 0 - point.y };\n\n        // One should be \"positive\" (y <= MOD_DIV_2) and one \"negative\"\n        let sign1 = get_sign_of_point(point);\n        let sign2 = get_sign_of_point(neg_point);\n        assert(sign1 != sign2);\n\n        // y = 0 should return true (0 <= MOD_DIV_2)\n        let zero_y_point = EmbeddedCurvePoint { x: 0, y: 0 };\n        assert(get_sign_of_point(zero_y_point) == true);\n\n        // y = MOD_DIV_2 should return true (exactly at boundary)\n        let boundary_point = EmbeddedCurvePoint { x: 0, y: BN254_FR_MODULUS_DIV_2 };\n        assert(get_sign_of_point(boundary_point) == true);\n\n        // y = MOD_DIV_2 + 1 should return false (just over boundary)\n        let over_boundary_point = EmbeddedCurvePoint { x: 0, y: BN254_FR_MODULUS_DIV_2 + 1 };\n        assert(get_sign_of_point(over_boundary_point) == false);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_zero() {\n        // x = 0: y^2 = 0^3 - 17 = -17, which is not a quadratic residue in BN254 scalar field\n        let result = point_from_x_coord(0);\n        assert(result.is_none());\n    }\n\n    #[test]\n    unconstrained fn test_bn254_fr_modulus_div_2() {\n        // Verify that BN254_FR_MODULUS_DIV_2 == (p - 1) / 2 This means: 2 * BN254_FR_MODULUS_DIV_2 + 1 == p == 0 (in\n        // the field)\n        assert_eq(2 * BN254_FR_MODULUS_DIV_2 + 1, 0);\n    }\n\n}\n"
     },
-    "284": {
+    "294": {
       "function_locations": [
         {
           "name": "Poseidon2::hash",
@@ -2162,7 +2234,7 @@
       "path": "std/array/mod.nr",
       "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a vector.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let vector = array.as_vector();\n    /// assert_eq(vector, [1, 2].as_vector());\n    /// ```\n    #[builtin(as_vector)]\n    pub fn as_vector(self) -> [T] {}\n\n    /// Returns this array as a vector.\n    /// This method is deprecated in favor of `as_vector`.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let vector = array.as_slice();\n    /// assert_eq(vector, [1, 2].as_vector());\n    /// ```\n    #[builtin(as_vector)]\n    #[deprecated(\"This method has been renamed to `as_vector`\")]\n    pub fn as_slice(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(&self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array along with its index,\n    /// returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.mapi(|i, a| i + a * 2);\n    /// assert_eq(b, [2, 5, 8]);\n    /// ```\n    pub fn mapi<U, Env>(&self, f: fn[Env](u32, T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(i, self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// let mut i = 0;\n    /// a.for_each(|x| {\n    ///     b[i] = x;\n    ///     i += 1;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_each<Env>(&self, f: fn[Env](T) -> ()) {\n        for i in 0..self.len() {\n            f(self[i]);\n        }\n    }\n\n    /// Applies a function to each element of this array along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// a.for_eachi(|i, x| {\n    ///     b[i] = x;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_eachi<Env>(&self, f: fn[Env](u32, T) -> ()) {\n        for i in 0..self.len() {\n            f(i, self[i]);\n        }\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(&self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(&self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(&self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(&self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n\n    /// Concatenates this array with another array.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr1 = [1, 2, 3, 4];\n    ///     let arr2 = [6, 7, 8, 9, 10, 11];\n    ///     let concatenated_arr = arr1.concat(arr2);\n    ///     assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    /// }\n    /// ```\n    pub fn concat<let M: u32>(&self, array2: [T; M]) -> [T; N + M] {\n        let mut result = [crate::mem::zeroed(); N + M];\n        for i in 0..N {\n            result[i] = self[i];\n        }\n        for i in 0..M {\n            result[i + N] = array2[i];\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the [`Self::sort_via`] function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(&self) -> Self {\n        self.sort_via(|a, b| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(&self, ordering: fn[Env](T, T) -> bool) -> Self {\n        if N != 0 {\n            // Safety: `sorted` array is checked to be:\n            // a. a permutation of `input`'s elements\n            // b. satisfying the predicate `ordering`\n            let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n            if !is_unconstrained() {\n                for i in 0..N - 1 {\n                    assert(\n                        ordering(sorted[i], sorted[i + 1]),\n                        \"Array has not been sorted correctly according to `ordering`.\",\n                    );\n                }\n                check_shuffle::check_shuffle(self, &sorted);\n            }\n            sorted\n        } else {\n            *self\n        }\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n\n    global arr_with_100_values: [u32; 100] = [\n        42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n        89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n        53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n        21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n        125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n    ];\n    global expected_with_100_values: [u32; 100] = [\n        0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n        32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n        62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n        86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n        119, 120, 121, 123, 123, 123, 125, 126, 127,\n    ];\n    fn sort_u32(a: u32, b: u32) -> bool {\n        a <= b\n    }\n\n    #[test]\n    fn test_sort() {\n        let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_empty() {\n        let arr: [u32; 0] = [];\n        let sorted = arr.sort();\n        assert(sorted == arr);\n    }\n\n    #[test]\n    fn test_sort_via_empty() {\n        let arr: [u32; 0] = [];\n        let sorted = arr.sort_via(sort_u32);\n        assert(sorted == arr);\n    }\n\n    #[test]\n    fn test_sort_100_values() {\n        let arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values_comptime() {\n        let sorted = arr_with_100_values.sort();\n        assert(sorted == expected_with_100_values);\n    }\n\n    #[test]\n    fn test_sort_via() {\n        let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_via_100_values() {\n        let arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn mapi_empty() {\n        assert_eq([].mapi(|i, x| i * x + 1), []);\n    }\n\n    #[test]\n    fn for_each_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_each(|_x| assert(false));\n    }\n\n    #[test]\n    fn for_eachi_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_eachi(|_i, _x| assert(false));\n    }\n\n    #[test]\n    fn map_example() {\n        let a = [1, 2, 3];\n        let b = a.map(|a| a * 2);\n        assert_eq(b, [2, 4, 6]);\n    }\n\n    #[test]\n    fn mapi_example() {\n        let a = [1, 2, 3];\n        let b = a.mapi(|i, a| i + a * 2);\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn for_each_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        let mut i = 0;\n        let i_ref = &mut i;\n        a.for_each(|x| {\n            b_ref[*i_ref] = x * 2;\n            *i_ref += 1;\n        });\n        assert_eq(b, [2, 4, 6]);\n        assert_eq(i, 3);\n    }\n\n    #[test]\n    fn for_eachi_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn concat() {\n        let arr1 = [1, 2, 3, 4];\n        let arr2 = [6, 7, 8, 9, 10, 11];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    }\n\n    #[test]\n    fn concat_zero_length_with_something() {\n        let arr1 = [];\n        let arr2 = [1];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_something_with_zero_length() {\n        let arr1 = [1];\n        let arr2 = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_zero_lengths() {\n        let arr1: [Field; 0] = [];\n        let arr2: [Field; 0] = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, []);\n    }\n\n    #[test]\n    fn test_fold() {\n        let array = [1, 2, 3];\n        let sum_plus_10 = array.fold(10, |x, y| x + y);\n        assert_eq(sum_plus_10, 16);\n    }\n\n    #[test]\n    fn test_reduce() {\n        let array = [1, 2, 3];\n        let sum = array.reduce(|x, y| x + y);\n        assert_eq(sum, 6);\n    }\n\n    #[test(should_fail_with = \"Index out of bounds\")]\n    fn test_reduce_failure_on_empty_array() {\n        let array: [Field; 0] = [];\n        let sum = array.reduce(|x, y| x + y);\n        assert_eq(sum, 6);\n    }\n\n    #[test]\n    fn test_all() {\n        let array = [1, 2, 3];\n        assert(array.all(|x| x >= 1));\n        assert(!array.all(|x| x >= 2));\n    }\n\n    #[test]\n    fn test_any() {\n        let array = [1, 2, 3];\n        assert(array.any(|x| x >= 3));\n        assert(!array.any(|x| x >= 4));\n    }\n\n    #[test]\n    fn test_to_string() {\n        let str = [78_u8, 111, 105, 114].as_str_unchecked();\n        assert_eq(str, \"Noir\");\n    }\n\n    #[test]\n    fn test_bytes_from_string() {\n        let bytes: [u8; 4] = crate::convert::From::from(\"Noir\");\n        assert_eq(bytes, [78_u8, 111, 105, 114]);\n    }\n}\n"
     },
-    "342": {
+    "352": {
       "function_locations": [
         {
           "name": "<impl Empty for AztecAddress>::empty",
@@ -2252,7 +2324,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V2, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            DOM_SEP__CONTRACT_ADDRESS_V2,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x303ffc8bd456d132463b1fc3a633aeb718a7883c268f3956c05e6fe09b5a5424;\n    assert_eq(address, expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V2);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x0fa1c698858df1a99170cd39d5f4bfad6d0d60f1f8afa3dc92281ee60b36f3bb;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
     },
-    "373": {
+    "383": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -2374,7 +2446,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
-    "375": {
+    "385": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -2448,7 +2520,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
       "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_misc_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
-    "394": {
+    "404": {
       "function_locations": [
         {
           "name": "Poseidon2Sponge::hash",
@@ -2478,353 +2550,367 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\nuse crate::traits::{Deserialize, Serialize};\nuse std::meta::derive;\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n// TODO: Poseidon is stand-alone now\n\nglobal RATE: u32 = 3;\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        sponge.squeeze()\n    }\n}\n"
     },
-    "413": {
+    "42": {
       "function_locations": [
         {
-          "name": "<impl ToField for Field>::to_field",
-          "start": 176
+          "name": "Option<T>::none",
+          "start": 389
         },
         {
-          "name": "<impl ToField for bool>::to_field",
-          "start": 276
+          "name": "Option<T>::some",
+          "start": 553
         },
         {
-          "name": "<impl ToField for u8>::to_field",
-          "start": 382
+          "name": "Option<T>::is_none",
+          "start": 672
         },
         {
-          "name": "<impl ToField for u16>::to_field",
-          "start": 468
+          "name": "Option<T>::is_some",
+          "start": 774
         },
         {
-          "name": "<impl ToField for u32>::to_field",
-          "start": 575
+          "name": "Option<T>::unwrap",
+          "start": 898
         },
         {
-          "name": "<impl ToField for u64>::to_field",
-          "start": 682
+          "name": "Option<T>::unwrap_unchecked",
+          "start": 1196
         },
         {
-          "name": "<impl ToField for u128>::to_field",
-          "start": 790
+          "name": "Option<T>::unwrap_or",
+          "start": 1368
         },
         {
-          "name": "<impl ToField for str<N>>::to_field",
-          "start": 912
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits/to_field.nr",
-      "source": "use crate::utils::field::field_from_bytes;\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u16 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u128 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n"
-    },
-    "414": {
-      "function_locations": [
+          "name": "Option<T>::unwrap_or_else",
+          "start": 1668
+        },
         {
-          "name": "<impl Packable for bool>::pack",
-          "start": 564
+          "name": "Option<T>::expect",
+          "start": 1969
         },
         {
-          "name": "<impl Packable for bool>::unpack",
-          "start": 666
+          "name": "Option<T>::map",
+          "start": 2190
         },
         {
-          "name": "<impl Packable for u8>::pack",
-          "start": 827
+          "name": "Option<T>::map_or",
+          "start": 2490
         },
         {
-          "name": "<impl Packable for u8>::unpack",
-          "start": 929
+          "name": "Option<T>::map_or_else",
+          "start": 2784
         },
         {
-          "name": "<impl Packable for u16>::pack",
-          "start": 1081
+          "name": "Option<T>::and",
+          "start": 3009
         },
         {
-          "name": "<impl Packable for u16>::unpack",
-          "start": 1183
+          "name": "Option<T>::and_then",
+          "start": 3446
         },
         {
-          "name": "<impl Packable for u32>::pack",
-          "start": 1336
+          "name": "Option<T>::or",
+          "start": 3669
         },
         {
-          "name": "<impl Packable for u32>::unpack",
-          "start": 1438
+          "name": "Option<T>::or_else",
+          "start": 3902
         },
         {
-          "name": "<impl Packable for u64>::pack",
-          "start": 1591
+          "name": "Option<T>::xor",
+          "start": 4192
         },
         {
-          "name": "<impl Packable for u64>::unpack",
-          "start": 1693
+          "name": "Option<T>::filter",
+          "start": 4636
         },
         {
-          "name": "<impl Packable for u128>::pack",
-          "start": 1848
+          "name": "Option<T>::flatten",
+          "start": 5065
         },
         {
-          "name": "<impl Packable for u128>::unpack",
-          "start": 1950
+          "name": "<impl Default for Option<T>>::default",
+          "start": 5242
         },
         {
-          "name": "<impl Packable for Field>::pack",
-          "start": 2108
+          "name": "<impl Eq for Option<T>>::eq",
+          "start": 5357
         },
         {
-          "name": "<impl Packable for Field>::unpack",
-          "start": 2201
+          "name": "<impl Hash for Option<T>>::hash",
+          "start": 5706
         },
         {
-          "name": "<impl Packable for i8>::pack",
-          "start": 2345
+          "name": "<impl Ord for Option<T>>::cmp",
+          "start": 5975
         },
         {
-          "name": "<impl Packable for i8>::unpack",
-          "start": 2453
+          "name": "tests::some_and_none",
+          "start": 6447
         },
         {
-          "name": "<impl Packable for i16>::pack",
-          "start": 2611
+          "name": "tests::unwrap_succeeds",
+          "start": 6677
         },
         {
-          "name": "<impl Packable for i16>::unpack",
-          "start": 2720
+          "name": "tests::unwrap_fails",
+          "start": 6781
         },
         {
-          "name": "<impl Packable for i32>::pack",
-          "start": 2880
+          "name": "tests::unwrap_or",
+          "start": 6868
         },
         {
-          "name": "<impl Packable for i32>::unpack",
-          "start": 2989
+          "name": "tests::unwrap_or_else",
+          "start": 7016
         },
         {
-          "name": "<impl Packable for i64>::pack",
-          "start": 3149
+          "name": "tests::expect_succeeds",
+          "start": 7181
         },
         {
-          "name": "<impl Packable for i64>::unpack",
-          "start": 3258
+          "name": "tests::expect_fails",
+          "start": 7328
         },
         {
-          "name": "<impl Packable for super::point::EmbeddedCurvePoint>::pack",
-          "start": 3427
+          "name": "tests::map",
+          "start": 7427
         },
         {
-          "name": "<impl Packable for super::point::EmbeddedCurvePoint>::unpack",
-          "start": 3509
+          "name": "tests::map_or",
+          "start": 7595
         },
         {
-          "name": "<impl Packable for [T; M]>::pack",
-          "start": 3720
+          "name": "tests::map_or_else",
+          "start": 7762
         },
         {
-          "name": "<impl Packable for [T; M]>::unpack",
-          "start": 4082
+          "name": "tests::and",
+          "start": 7937
         },
         {
-          "name": "test_u16_packing",
-          "start": 4327
+          "name": "tests::and_then",
+          "start": 8277
         },
         {
-          "name": "test_i8_packing",
-          "start": 4423
+          "name": "tests::or",
+          "start": 8663
         },
         {
-          "name": "test_i16_packing",
-          "start": 4519
+          "name": "tests::or_else",
+          "start": 9000
         },
         {
-          "name": "test_i32_packing",
-          "start": 4617
+          "name": "tests::xor",
+          "start": 9365
         },
         {
-          "name": "test_i64_packing",
-          "start": 4715
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
-      "source": "use crate::traits::{Deserialize, Packable, Serialize};\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\nglobal POINT_PACKED_LEN: u32 = 2;\n\nimpl Packable for bool {\n    let N: u32 = BOOL_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> bool {\n        (fields[0] as u8) % 2 != 0\n    }\n}\n\nimpl Packable for u8 {\n    let N: u32 = U8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable for u16 {\n    let N: u32 = U16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable for u32 {\n    let N: u32 = U32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable for u64 {\n    let N: u32 = U64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable for u128 {\n    let N: u32 = U128_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable for Field {\n    let N: u32 = FIELD_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable for i8 {\n    let N: u32 = I8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u8 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Packable for i16 {\n    let N: u32 = I16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u16 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Packable for i32 {\n    let N: u32 = I32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u32 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Packable for i64 {\n    let N: u32 = I64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u64 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl Packable for super::point::EmbeddedCurvePoint {\n    let N: u32 = POINT_PACKED_LEN;\n    fn pack(self) -> [Field; Self::N] {\n        self.serialize()\n    }\n\n    fn unpack(packed: [Field; Self::N]) -> Self {\n        Self::deserialize(packed)\n    }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n    T: Packable,\n{\n    let N: u32 = M * <T as Packable>::N;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n        for i in 0..M {\n            let serialized = self[i].pack();\n            for j in 0..<T as Packable>::N {\n                result[i * <T as Packable>::N + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let result: [T; M] = std::mem::zeroed();\n        reader.read_struct_array::<T, <T as Packable>::N, M>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
-    },
-    "42": {
-      "function_locations": [
+          "name": "tests::filter",
+          "start": 9704
+        },
         {
-          "name": "Option<T>::none",
-          "start": 389
+          "name": "tests::flatten",
+          "start": 10030
         },
         {
-          "name": "Option<T>::some",
-          "start": 553
+          "name": "tests::default",
+          "start": 10301
         },
         {
-          "name": "Option<T>::is_none",
-          "start": 672
+          "name": "tests::eq",
+          "start": 10394
         },
         {
-          "name": "Option<T>::is_some",
-          "start": 774
+          "name": "tests::cmp",
+          "start": 10714
+        }
+      ],
+      "path": "std/option.nr",
+      "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nmod tests {\n    use crate::cmp::Ord;\n    use crate::cmp::Ordering;\n    use crate::default::Default as _;\n    use super::Option;\n\n    #[test]\n    fn some_and_none() {\n        assert(Option::<u8>::none().is_none());\n        assert(!Option::<u8>::none().is_some());\n        assert(Option::some(1).is_some());\n        assert(!Option::some(1).is_none());\n    }\n\n    #[test]\n    fn unwrap_succeeds() {\n        assert_eq(Option::some(1).unwrap(), 1);\n    }\n\n    #[test(should_fail)]\n    fn unwrap_fails() {\n        let _ = Option::<u8>::none().unwrap();\n    }\n\n    #[test]\n    fn unwrap_or() {\n        assert_eq(Option::some(1).unwrap_or(2), 1);\n        assert_eq(Option::none().unwrap_or(2), 2);\n    }\n\n    #[test]\n    fn unwrap_or_else() {\n        assert_eq(Option::some(1).unwrap_or_else(|| 2), 1);\n        assert_eq(Option::none().unwrap_or_else(|| 2), 2);\n    }\n\n    #[test]\n    fn expect_succeeds() {\n        assert_eq(Option::some(1).expect(f\"Should be there\"), 1);\n    }\n\n    #[test(should_fail_with = \"Should be there\")]\n    fn expect_fails() {\n        let _ = Option::<u8>::none().expect(f\"Should be there\");\n    }\n\n    #[test]\n    fn map() {\n        assert(Option::<u8>::none().map(|x| x + 1).is_none());\n        assert_eq(Option::some(1).map(|x| x + 1), Option::some(2));\n    }\n\n    #[test]\n    fn map_or() {\n        assert_eq(Option::<u8>::none().map_or(0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or(0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn map_or_else() {\n        assert_eq(Option::<u8>::none().map_or_else(|| 0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or_else(|| 0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn and() {\n        assert_eq(Option::<u8>::none().and(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().and(Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and(Option::some(2)), Option::some(2));\n        assert_eq(Option::some(1).and(Option::none()), Option::none());\n    }\n\n    #[test]\n    fn and_then() {\n        assert_eq(Option::<u8>::none().and_then(|_| Option::<u8>::none()), Option::none());\n        assert_eq(Option::<u8>::none().and_then(|_| Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and_then(|x| Option::some(x + 1)), Option::some(2));\n        assert_eq(Option::some(1).and_then(|_| Option::<u8>::none()), Option::none());\n    }\n\n    #[test]\n    fn or() {\n        assert_eq(Option::<u8>::none().or(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn or_else() {\n        assert_eq(Option::<u8>::none().or_else(|| Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or_else(|| Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn xor() {\n        assert_eq(Option::<u8>::none().xor(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().xor(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).xor(Option::some(2)), Option::none());\n        assert_eq(Option::some(1).xor(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn filter() {\n        assert_eq(Option::<u8>::none().filter(|_| true), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 1), Option::some(1));\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n    }\n\n    #[test]\n    fn flatten() {\n        assert_eq(Option::<Option<u8>>::none().flatten(), Option::none());\n        assert_eq(Option::some(Option::<u8>::none()).flatten(), Option::none());\n        assert_eq(Option::some(Option::some(1)).flatten(), Option::some(1));\n    }\n\n    #[test]\n    fn default() {\n        assert_eq(Option::<u8>::default(), Option::none());\n    }\n\n    #[test]\n    fn eq() {\n        assert(Option::<u8>::none() == Option::none());\n        assert(Option::<u8>::some(1) != Option::none());\n        assert(Option::<u8>::none() != Option::some(1));\n        assert(Option::<u8>::some(1) == Option::some(1));\n        assert(Option::<u8>::some(1) != Option::some(2));\n    }\n\n    #[test]\n    fn cmp() {\n        let none = Option::<u8>::none();\n        let one = Option::<u8>::some(1);\n        let two = Option::<u8>::some(2);\n        assert_eq(none.cmp(none), Ordering::equal());\n        assert_eq(none.cmp(one), Ordering::less());\n        assert_eq(one.cmp(none), Ordering::greater());\n        assert_eq(one.cmp(one), Ordering::equal());\n        assert_eq(one.cmp(two), Ordering::less());\n        assert_eq(two.cmp(one), Ordering::greater());\n    }\n}\n"
+    },
+    "423": {
+      "function_locations": [
+        {
+          "name": "<impl ToField for Field>::to_field",
+          "start": 176
         },
         {
-          "name": "Option<T>::unwrap",
-          "start": 898
+          "name": "<impl ToField for bool>::to_field",
+          "start": 276
         },
         {
-          "name": "Option<T>::unwrap_unchecked",
-          "start": 1196
+          "name": "<impl ToField for u8>::to_field",
+          "start": 382
         },
         {
-          "name": "Option<T>::unwrap_or",
-          "start": 1368
+          "name": "<impl ToField for u16>::to_field",
+          "start": 468
         },
         {
-          "name": "Option<T>::unwrap_or_else",
-          "start": 1668
+          "name": "<impl ToField for u32>::to_field",
+          "start": 575
         },
         {
-          "name": "Option<T>::expect",
-          "start": 1969
+          "name": "<impl ToField for u64>::to_field",
+          "start": 682
         },
         {
-          "name": "Option<T>::map",
-          "start": 2190
+          "name": "<impl ToField for u128>::to_field",
+          "start": 790
         },
         {
-          "name": "Option<T>::map_or",
-          "start": 2490
+          "name": "<impl ToField for str<N>>::to_field",
+          "start": 912
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits/to_field.nr",
+      "source": "use crate::utils::field::field_from_bytes;\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u16 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u128 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n"
+    },
+    "424": {
+      "function_locations": [
+        {
+          "name": "<impl Packable for bool>::pack",
+          "start": 564
         },
         {
-          "name": "Option<T>::map_or_else",
-          "start": 2784
+          "name": "<impl Packable for bool>::unpack",
+          "start": 666
         },
         {
-          "name": "Option<T>::and",
-          "start": 3009
+          "name": "<impl Packable for u8>::pack",
+          "start": 827
         },
         {
-          "name": "Option<T>::and_then",
-          "start": 3446
+          "name": "<impl Packable for u8>::unpack",
+          "start": 929
         },
         {
-          "name": "Option<T>::or",
-          "start": 3669
+          "name": "<impl Packable for u16>::pack",
+          "start": 1081
         },
         {
-          "name": "Option<T>::or_else",
-          "start": 3902
+          "name": "<impl Packable for u16>::unpack",
+          "start": 1183
         },
         {
-          "name": "Option<T>::xor",
-          "start": 4192
+          "name": "<impl Packable for u32>::pack",
+          "start": 1336
         },
         {
-          "name": "Option<T>::filter",
-          "start": 4636
+          "name": "<impl Packable for u32>::unpack",
+          "start": 1438
         },
         {
-          "name": "Option<T>::flatten",
-          "start": 5065
+          "name": "<impl Packable for u64>::pack",
+          "start": 1591
         },
         {
-          "name": "<impl Default for Option<T>>::default",
-          "start": 5242
+          "name": "<impl Packable for u64>::unpack",
+          "start": 1693
         },
         {
-          "name": "<impl Eq for Option<T>>::eq",
-          "start": 5357
+          "name": "<impl Packable for u128>::pack",
+          "start": 1848
         },
         {
-          "name": "<impl Hash for Option<T>>::hash",
-          "start": 5706
+          "name": "<impl Packable for u128>::unpack",
+          "start": 1950
         },
         {
-          "name": "<impl Ord for Option<T>>::cmp",
-          "start": 5975
+          "name": "<impl Packable for Field>::pack",
+          "start": 2108
         },
         {
-          "name": "tests::some_and_none",
-          "start": 6447
+          "name": "<impl Packable for Field>::unpack",
+          "start": 2201
         },
         {
-          "name": "tests::unwrap_succeeds",
-          "start": 6677
+          "name": "<impl Packable for i8>::pack",
+          "start": 2345
         },
         {
-          "name": "tests::unwrap_fails",
-          "start": 6781
+          "name": "<impl Packable for i8>::unpack",
+          "start": 2453
         },
         {
-          "name": "tests::unwrap_or",
-          "start": 6868
+          "name": "<impl Packable for i16>::pack",
+          "start": 2611
         },
         {
-          "name": "tests::unwrap_or_else",
-          "start": 7016
+          "name": "<impl Packable for i16>::unpack",
+          "start": 2720
         },
         {
-          "name": "tests::expect_succeeds",
-          "start": 7181
+          "name": "<impl Packable for i32>::pack",
+          "start": 2880
         },
         {
-          "name": "tests::expect_fails",
-          "start": 7328
+          "name": "<impl Packable for i32>::unpack",
+          "start": 2989
         },
         {
-          "name": "tests::map",
-          "start": 7427
+          "name": "<impl Packable for i64>::pack",
+          "start": 3149
         },
         {
-          "name": "tests::map_or",
-          "start": 7595
+          "name": "<impl Packable for i64>::unpack",
+          "start": 3258
         },
         {
-          "name": "tests::map_or_else",
-          "start": 7762
+          "name": "<impl Packable for super::point::EmbeddedCurvePoint>::pack",
+          "start": 3427
         },
         {
-          "name": "tests::and",
-          "start": 7937
+          "name": "<impl Packable for super::point::EmbeddedCurvePoint>::unpack",
+          "start": 3509
         },
         {
-          "name": "tests::and_then",
-          "start": 8277
+          "name": "<impl Packable for [T; M]>::pack",
+          "start": 3720
         },
         {
-          "name": "tests::or",
-          "start": 8663
+          "name": "<impl Packable for [T; M]>::unpack",
+          "start": 4082
         },
         {
-          "name": "tests::or_else",
-          "start": 9000
+          "name": "test_u16_packing",
+          "start": 4327
         },
         {
-          "name": "tests::xor",
-          "start": 9365
+          "name": "test_i8_packing",
+          "start": 4423
         },
         {
-          "name": "tests::filter",
-          "start": 9704
+          "name": "test_i16_packing",
+          "start": 4519
         },
         {
-          "name": "tests::flatten",
-          "start": 10030
+          "name": "test_i32_packing",
+          "start": 4617
         },
         {
-          "name": "tests::default",
-          "start": 10301
-        },
+          "name": "test_i64_packing",
+          "start": 4715
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
+      "source": "use crate::traits::{Deserialize, Packable, Serialize};\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\nglobal POINT_PACKED_LEN: u32 = 2;\n\nimpl Packable for bool {\n    let N: u32 = BOOL_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> bool {\n        (fields[0] as u8) % 2 != 0\n    }\n}\n\nimpl Packable for u8 {\n    let N: u32 = U8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable for u16 {\n    let N: u32 = U16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable for u32 {\n    let N: u32 = U32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable for u64 {\n    let N: u32 = U64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable for u128 {\n    let N: u32 = U128_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable for Field {\n    let N: u32 = FIELD_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable for i8 {\n    let N: u32 = I8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u8 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Packable for i16 {\n    let N: u32 = I16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u16 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Packable for i32 {\n    let N: u32 = I32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u32 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Packable for i64 {\n    let N: u32 = I64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u64 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl Packable for super::point::EmbeddedCurvePoint {\n    let N: u32 = POINT_PACKED_LEN;\n    fn pack(self) -> [Field; Self::N] {\n        self.serialize()\n    }\n\n    fn unpack(packed: [Field; Self::N]) -> Self {\n        Self::deserialize(packed)\n    }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n    T: Packable,\n{\n    let N: u32 = M * <T as Packable>::N;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n        for i in 0..M {\n            let serialized = self[i].pack();\n            for j in 0..<T as Packable>::N {\n                result[i * <T as Packable>::N + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let result: [T; M] = std::mem::zeroed();\n        reader.read_struct_array::<T, <T as Packable>::N, M>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
+    },
+    "43": {
+      "function_locations": [
         {
-          "name": "tests::eq",
-          "start": 10394
+          "name": "panic",
+          "start": 196
         },
         {
-          "name": "tests::cmp",
-          "start": 10714
+          "name": "tests::panics",
+          "start": 469
         }
       ],
-      "path": "std/option.nr",
-      "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nmod tests {\n    use crate::cmp::Ord;\n    use crate::cmp::Ordering;\n    use crate::default::Default as _;\n    use super::Option;\n\n    #[test]\n    fn some_and_none() {\n        assert(Option::<u8>::none().is_none());\n        assert(!Option::<u8>::none().is_some());\n        assert(Option::some(1).is_some());\n        assert(!Option::some(1).is_none());\n    }\n\n    #[test]\n    fn unwrap_succeeds() {\n        assert_eq(Option::some(1).unwrap(), 1);\n    }\n\n    #[test(should_fail)]\n    fn unwrap_fails() {\n        let _ = Option::<u8>::none().unwrap();\n    }\n\n    #[test]\n    fn unwrap_or() {\n        assert_eq(Option::some(1).unwrap_or(2), 1);\n        assert_eq(Option::none().unwrap_or(2), 2);\n    }\n\n    #[test]\n    fn unwrap_or_else() {\n        assert_eq(Option::some(1).unwrap_or_else(|| 2), 1);\n        assert_eq(Option::none().unwrap_or_else(|| 2), 2);\n    }\n\n    #[test]\n    fn expect_succeeds() {\n        assert_eq(Option::some(1).expect(f\"Should be there\"), 1);\n    }\n\n    #[test(should_fail_with = \"Should be there\")]\n    fn expect_fails() {\n        let _ = Option::<u8>::none().expect(f\"Should be there\");\n    }\n\n    #[test]\n    fn map() {\n        assert(Option::<u8>::none().map(|x| x + 1).is_none());\n        assert_eq(Option::some(1).map(|x| x + 1), Option::some(2));\n    }\n\n    #[test]\n    fn map_or() {\n        assert_eq(Option::<u8>::none().map_or(0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or(0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn map_or_else() {\n        assert_eq(Option::<u8>::none().map_or_else(|| 0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or_else(|| 0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn and() {\n        assert_eq(Option::<u8>::none().and(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().and(Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and(Option::some(2)), Option::some(2));\n        assert_eq(Option::some(1).and(Option::none()), Option::none());\n    }\n\n    #[test]\n    fn and_then() {\n        assert_eq(Option::<u8>::none().and_then(|_| Option::<u8>::none()), Option::none());\n        assert_eq(Option::<u8>::none().and_then(|_| Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and_then(|x| Option::some(x + 1)), Option::some(2));\n        assert_eq(Option::some(1).and_then(|_| Option::<u8>::none()), Option::none());\n    }\n\n    #[test]\n    fn or() {\n        assert_eq(Option::<u8>::none().or(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn or_else() {\n        assert_eq(Option::<u8>::none().or_else(|| Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or_else(|| Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn xor() {\n        assert_eq(Option::<u8>::none().xor(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().xor(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).xor(Option::some(2)), Option::none());\n        assert_eq(Option::some(1).xor(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn filter() {\n        assert_eq(Option::<u8>::none().filter(|_| true), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 1), Option::some(1));\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n    }\n\n    #[test]\n    fn flatten() {\n        assert_eq(Option::<Option<u8>>::none().flatten(), Option::none());\n        assert_eq(Option::some(Option::<u8>::none()).flatten(), Option::none());\n        assert_eq(Option::some(Option::some(1)).flatten(), Option::some(1));\n    }\n\n    #[test]\n    fn default() {\n        assert_eq(Option::<u8>::default(), Option::none());\n    }\n\n    #[test]\n    fn eq() {\n        assert(Option::<u8>::none() == Option::none());\n        assert(Option::<u8>::some(1) != Option::none());\n        assert(Option::<u8>::none() != Option::some(1));\n        assert(Option::<u8>::some(1) == Option::some(1));\n        assert(Option::<u8>::some(1) != Option::some(2));\n    }\n\n    #[test]\n    fn cmp() {\n        let none = Option::<u8>::none();\n        let one = Option::<u8>::some(1);\n        let two = Option::<u8>::some(2);\n        assert_eq(none.cmp(none), Ordering::equal());\n        assert_eq(none.cmp(one), Ordering::less());\n        assert_eq(one.cmp(none), Ordering::greater());\n        assert_eq(one.cmp(one), Ordering::equal());\n        assert_eq(one.cmp(two), Ordering::less());\n        assert_eq(two.cmp(one), Ordering::greater());\n    }\n}\n"
+      "path": "std/panic.nr",
+      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
     },
-    "421": {
+    "431": {
       "function_locations": [
         {
           "name": "field_from_bytes",
@@ -2938,7 +3024,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n    if f1.lt(f2) {\n        f1\n    } else {\n        f2\n    }\n}\n\n// TODO: write doc-comments and tests for these magic constants.\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// @dev: only use this for _huge_ exponents y, when writing a constrained function.\n// If you're only exponentiating by a small value, first consider writing-out the multiplications by hand.\n// Only after you've measured the gates of that approach, consider using the native Field::pow_32 function.\n// Only if your exponent is larger than 32 bits, resort to using this function.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [bool; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n/// Returns Option::some(sqrt) if there is a square root, and Option::none() if there isn't.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\nunconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field2.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n\n#[test]\nunconstrained fn sqrt_valid_test() {\n    let x = 16; // examples: 16, 9, 25, 81\n    let result = sqrt(x);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), x);\n}\n\n#[test]\nunconstrained fn sqrt_invalid_test() {\n    let x = KNOWN_NON_RESIDUE; // has no square root in the field\n    let result = sqrt(x);\n    assert(result.is_none());\n}\n\n#[test]\nunconstrained fn sqrt_zero_test() {\n    let result = sqrt(0);\n    assert(result.is_some());\n    assert_eq(result.unwrap(), 0);\n}\n\n#[test]\nunconstrained fn sqrt_one_test() {\n    let result = sqrt(1);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), 1);\n}\n\n#[test]\nunconstrained fn field_from_bytes_empty_test() {\n    let empty: [u8; 0] = [];\n    let result = field_from_bytes(empty, true);\n    assert_eq(result, 0);\n\n    let result_le = field_from_bytes(empty, false);\n    assert_eq(result_le, 0);\n}\n\n#[test]\nunconstrained fn field_from_bytes_little_endian_test() {\n    // Test little-endian conversion: [0x01, 0x02] should be 0x0201 = 513\n    let bytes = [0x01, 0x02];\n    let result_le = field_from_bytes(bytes, false);\n    assert_eq(result_le, 0x0201);\n\n    // Compare with big-endian: [0x01, 0x02] should be 0x0102 = 258\n    let result_be = field_from_bytes(bytes, true);\n    assert_eq(result_be, 0x0102);\n}\n\n#[test]\nunconstrained fn pow_test() {\n    assert_eq(pow(2, 0), 1);\n    assert_eq(pow(2, 1), 2);\n    assert_eq(pow(2, 10), 1024);\n    assert_eq(pow(3, 5), 243);\n    assert_eq(pow(0, 5), 0);\n    assert_eq(pow(1, 100), 1);\n}\n\n#[test]\nunconstrained fn min_test() {\n    assert_eq(min(5, 10), 5);\n    assert_eq(min(10, 5), 5);\n    assert_eq(min(7, 7), 7);\n    assert_eq(min(0, 1), 0);\n}\n\n#[test]\nunconstrained fn sqrt_has_two_roots_test() {\n    // Every square has two roots: r and -r (i.e., p - r)\n    // sqrt(16) can return 4 or -4\n    let x = 16;\n    let result = sqrt(x).unwrap();\n    assert(result * result == x);\n    // The other root is -result\n    let other_root = 0 - result;\n    assert(other_root * other_root == x);\n    // Verify they are different (unless x = 0)\n    assert(result != other_root);\n\n    // Same for 9: roots are 3 and -3\n    let y = 9;\n    let result_y = sqrt(y).unwrap();\n    assert(result_y * result_y == y);\n    let other_root_y = 0 - result_y;\n    assert(other_root_y * other_root_y == y);\n    assert(result_y != other_root_y);\n}\n\n#[test]\nunconstrained fn sqrt_negative_one_test() {\n    let x = 0 - 1;\n    let result = sqrt(x);\n    assert(result.unwrap() == 0x30644e72e131a029048b6e193fd841045cea24f6fd736bec231204708f703636);\n}\n\n#[test]\nunconstrained fn validate_sqrt_hint_valid_test() {\n    // 4 is a valid sqrt of 16\n    validate_sqrt_hint(16, 4);\n    // -4 is also a valid sqrt of 16\n    validate_sqrt_hint(16, 0 - 4);\n    // 0 is a valid sqrt of 0\n    validate_sqrt_hint(0, 0);\n    // 1 is a valid sqrt of 1\n    validate_sqrt_hint(1, 1);\n    // -1 is also a valid sqrt of 1\n    validate_sqrt_hint(1, 0 - 1);\n}\n\n#[test(should_fail_with = \"is not the sqrt of x\")]\nunconstrained fn validate_sqrt_hint_invalid_test() {\n    // 5 is not a valid sqrt of 16\n    validate_sqrt_hint(16, 5);\n}\n\n#[test]\nunconstrained fn validate_not_sqrt_hint_valid_test() {\n    // 5 (KNOWN_NON_RESIDUE) is not a square.\n    let x = KNOWN_NON_RESIDUE;\n    let hint = tonelli_shanks_sqrt(x * KNOWN_NON_RESIDUE);\n    validate_not_sqrt_hint(x, hint);\n}\n\n#[test(should_fail_with = \"0 has a square root\")]\nunconstrained fn validate_not_sqrt_hint_zero_test() {\n    // 0 has a square root, so we cannot claim it is not square\n    validate_not_sqrt_hint(0, 0);\n}\n\n#[test(should_fail_with = \"does not demonstrate that\")]\nunconstrained fn validate_not_sqrt_hint_wrong_hint_test() {\n    // Provide a wrong hint for a non-square\n    let x = KNOWN_NON_RESIDUE;\n    validate_not_sqrt_hint(x, 123);\n}\n"
     },
-    "427": {
+    "437": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -2988,7 +3074,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_u64(&mut self) -> u64 {\n        self.read() as u64\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() != 0\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn peek_offset(&mut self, offset: u32) -> Field {\n        self.data[self.offset + offset]\n    }\n\n    pub fn advance_offset(&mut self, offset: u32) {\n        self.offset += offset;\n    }\n\n    pub fn finish(self) {\n        assert_eq(self.offset, self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "428": {
+    "438": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -3014,21 +3100,7 @@
       "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/// 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"
     },
-    "43": {
-      "function_locations": [
-        {
-          "name": "panic",
-          "start": 196
-        },
-        {
-          "name": "tests::panics",
-          "start": 469
-        }
-      ],
-      "path": "std/panic.nr",
-      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
-    },
-    "430": {
+    "440": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -3342,7 +3414,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
       "source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\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        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\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>) -> bool {\n        reader.read() != 0\n    }\n}\n\nimpl Serialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\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        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\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        reader.read() as u8\n    }\n}\n\nimpl Serialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\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        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\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        reader.read() as u16\n    }\n}\n\nimpl Serialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\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        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\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        reader.read() as u32\n    }\n}\n\nimpl Serialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\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        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\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        reader.read() as u64\n    }\n}\n\nimpl Serialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\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        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\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        reader.read() as u128\n    }\n}\n\nimpl Serialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\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        writer.write(self);\n    }\n}\n\nimpl Deserialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\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        reader.read()\n    }\n}\n\nimpl Serialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\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        writer.write(self as u8 as Field);\n    }\n}\n\nimpl Deserialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\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        reader.read() as u8 as i8\n    }\n}\n\nimpl Serialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\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        writer.write(self as u16 as Field);\n    }\n}\n\nimpl Deserialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\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        reader.read() as u16 as i16\n    }\n}\n\nimpl Serialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\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        writer.write(self as u32 as Field);\n    }\n}\n\nimpl Deserialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\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        reader.read() as u32 as i32\n    }\n}\n\nimpl Serialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\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        writer.write(self as u64 as Field);\n    }\n}\n\nimpl Deserialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\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        reader.read() as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M;\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        for i in 0..M {\n            self[i].stream_serialize(writer);\n        }\n    }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * 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    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut result: [T; M] = std::mem::zeroed();\n        for i in 0..M {\n            result[i] = T::stream_deserialize(reader);\n        }\n        result\n    }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N + 1;\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        writer.write_bool(self.is_some());\n        if self.is_some() {\n            self.unwrap_unchecked().stream_serialize(writer);\n        } else {\n            writer.advance_offset(<T as Serialize>::N);\n        }\n    }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N + 1;\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        if reader.read_bool() {\n            Option::some(<T as Deserialize>::stream_deserialize(reader))\n        } else {\n            reader.advance_offset(<T as Deserialize>::N);\n            Option::none()\n        }\n    }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n    let N: u32 = SCALAR_SIZE;\n\n    fn serialize(self) -> [Field; SCALAR_SIZE] {\n        [self.lo, self.hi]\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.lo);\n        writer.write(self.hi);\n    }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n    let N: u32 = SCALAR_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { lo: fields[0], hi: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { lo: reader.read(), hi: reader.read() }\n    }\n}\n\nglobal POINT_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.x, self.y]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.x);\n        writer.write(self.y);\n    }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { x: fields[0], y: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { x: reader.read(), y: reader.read() }\n    }\n}\n\nimpl<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    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n        str::<Self::N>::from(u8_arr)\n    }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n    let N: u32 = M;\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        self.as_bytes().stream_serialize(writer);\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M + 1;\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 mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n        let payload_len = Self::N - 1;\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        let len = reader.peek_offset(payload_len) as u32;\n\n        for i in 0..M {\n            if i < len {\n                new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n            }\n        }\n\n        // +1 for the length of the BoundedVec\n        reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n        new_bounded_vec\n    }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n    let N: u32 = 0;\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        ()\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\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        self.storage().stream_serialize(writer);\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        writer.write_u32(self.len() as u32);\n    }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n    let mut slice = @[];\n    for i in 0..length {\n        slice = slice.push_back(f(i));\n    }\n    slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n    // `T0`, `T1`, `T2`\n    let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n    // `result0`, `result1`, `result2`\n    let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n    // `T0, T1, T2`\n    let field_generics = type_names.join(quote [,]);\n\n    // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n    let full_size_serialize = type_names\n        .map(|type_name| quote {\n            <$type_name as Serialize>::N\n        })\n        .join(quote [+]);\n\n    // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n    let full_size_deserialize = type_names\n        .map(|type_name| quote {\n            <$type_name as Deserialize>::N\n        })\n        .join(quote [+]);\n\n    // `T0: Serialize, T1: Serialize, T2: Serialize,`\n    let serialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Serialize,\n    })\n        .join(quote []);\n\n    // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n    let deserialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Deserialize,\n    })\n        .join(quote []);\n\n    // Statements to serialize each field\n    let serialized_fields = type_names\n        .mapi(|i, _type_name| quote {\n            $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n        })\n        .join(quote []);\n\n    // Statements to deserialize each field\n    let deserialized_fields = type_names\n        .mapi(|i, type_name| {\n            let result_name = result_names[i];\n            quote {\n            let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n        }\n        })\n        .join(quote []);\n    let deserialize_results = result_names.join(quote [,]);\n\n    quote {\n        impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n            let N: u32 = $full_size_serialize;\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::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 $crate::writer::Writer<K>) {\n\n                $serialized_fields\n            }\n        }\n\n        impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n            let N: u32 = $full_size_deserialize;\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                $deserialized_fields\n                ($deserialize_results)\n            }\n        }\n    }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n    T1: Serialize,\n{\n    let N: u32 = <T1 as Serialize>::N;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: crate::writer::Writer<Self::N> = crate::writer::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        self.0.stream_serialize(writer);\n    }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n    T1: Deserialize,\n{\n    let N: u32 = <T1 as Deserialize>::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 Reader<K>) -> Self {\n        (<T1 as Deserialize>::stream_deserialize(reader),)\n    }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n    use crate::serialization::{Deserialize, Serialize};\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n    // Test empty BoundedVec\n    let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n    let serialized = empty_vec.serialize();\n    let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n    assert_eq(empty_vec, deserialized);\n    assert_eq(deserialized.len(), 0);\n\n    // Test partially filled BoundedVec\n    let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n    let serialized = partial_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(partial_vec, deserialized);\n    assert_eq(deserialized.len(), 1);\n    assert_eq(deserialized.get(0), [1, 2]);\n\n    // Test full BoundedVec\n    let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n    let serialized = full_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(full_vec, deserialized);\n    assert_eq(deserialized.len(), 3);\n    assert_eq(deserialized.get(0), [1, 2]);\n    assert_eq(deserialized.get(1), [3, 4]);\n    assert_eq(deserialized.get(2), [5, 6]);\n}\n"
     },
-    "431": {
+    "441": {
       "function_locations": [
         {
           "name": "Writer<N>::new",
@@ -3852,63 +3924,51 @@
         },
         {
           "name": "CapsuleArray<T>::for_each",
-          "start": 5345
+          "start": 4963
         },
         {
           "name": "CapsuleArray<T>::slot_at",
-          "start": 6413
+          "start": 5121
         },
         {
           "name": "test::empty_array",
-          "start": 6789
+          "start": 5497
         },
         {
           "name": "test::empty_array_read",
-          "start": 7263
+          "start": 5971
         },
         {
           "name": "test::array_push",
-          "start": 7638
+          "start": 6346
         },
         {
           "name": "test::read_past_len",
-          "start": 8156
+          "start": 6864
         },
         {
           "name": "test::array_remove_last",
-          "start": 8559
+          "start": 7267
         },
         {
           "name": "test::array_remove_some",
-          "start": 8997
+          "start": 7705
         },
         {
           "name": "test::array_remove_all",
-          "start": 9729
-        },
-        {
-          "name": "test::for_each_called_with_all_elements",
-          "start": 10296
+          "start": 8437
         },
         {
-          "name": "test::for_each_remove_some",
-          "start": 11389
-        },
-        {
-          "name": "test::for_each_remove_all",
-          "start": 12081
-        },
-        {
-          "name": "test::for_each_remove_all_no_copy",
-          "start": 12619
+          "name": "test::for_each_called_with_all_elements_in_order",
+          "start": 9013
         },
         {
           "name": "test::different_scopes_are_isolated",
-          "start": 13383
+          "start": 9802
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
-      "source": "use crate::oracle::capsules;\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n    /// Scope for capsule isolation. Capsule operations are scoped to the given address, allowing multiple independent\n    /// namespaces within the same contract.\n    scope: AztecAddress,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray scoped to a specific address.\n    ///\n    /// Array elements are stored in contiguous slots\n    /// following the base slot, so there should be sufficient space between array base slots to accommodate elements.\n    /// A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field, scope: AztecAddress) -> Self {\n        Self { contract_address, base_slot, scope }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot, self.scope).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(\n            self.contract_address,\n            self.slot_at(current_length),\n            value,\n            self.scope,\n        );\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            new_length,\n            self.scope,\n        );\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index), self.scope).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n                self.scope,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(\n            self.contract_address,\n            self.slot_at(current_length - 1),\n            self.scope,\n        );\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            current_length - 1,\n            self.scope,\n        );\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index. The order in which values\n    /// are processed is arbitrary.\n    ///\n    /// ## Array Mutation\n    ///\n    /// It is safe to delete the current element (and only the current element) from inside the callback via `remove`:\n    /// ```noir\n    /// array.for_each(|index, value| {\n    ///   if some_condition(value) {\n    ///     array.remove(index); // safe only for this index\n    ///   }\n    /// }\n    /// ```\n    ///\n    /// If all elements in the array need to iterated over and then removed, then using `for_each` results in optimal\n    /// efficiency.\n    ///\n    /// It is **not** safe to push new elements into the array from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        // Iterating over all elements is simple, but we want to do it in such a way that a) deleting the current\n        // element is safe to do, and b) deleting *all* elements is optimally efficient. This is because CapsuleArrays\n        // are typically used to hold pending tasks, so iterating them while clearing completed tasks (sometimes\n        // unconditionally, resulting in a full clear) is a very common access pattern.\n        //\n        // The way we achieve this is by iterating backwards: each element can always be deleted since it won't change\n        // any preceding (lower) indices, and if every element is deleted then every element will (in turn) be the last\n        // element. This results in an optimal full clear since `remove` will be able to skip the `capsules::copy` call\n        // to shift any elements past the deleted one (because there will be none).\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n\n    global SLOT: Field = 1230;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT, scope);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(5);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 8);\n            assert_eq(array.get(2), 9);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We store all values that we were called with and check that all (value, index) tuples are present. Note\n            // that we do not care about the order in which each tuple was passed to the closure.\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n            assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n            assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| {\n                if index == 1 {\n                    array.remove(index);\n                }\n            });\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 4);\n            assert_eq(array.get(1), 6);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all_no_copy() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We test that the aztec_utl_copyCapsule was never called, which is the expensive operation we want to\n            // avoid.\n            let mock = std::test::OracleMock::mock(\"aztec_utl_copyCapsule\");\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(mock.times_called(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn different_scopes_are_isolated() {\n        let mut env = TestEnvironment::new();\n        let scope_a = env.create_light_account();\n        let scope_b = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array_a = CapsuleArray::at(contract_address, SLOT, scope_a);\n            let array_b = CapsuleArray::at(contract_address, SLOT, scope_b);\n\n            array_a.push(10);\n            array_a.push(20);\n            array_b.push(99);\n\n            assert_eq(array_a.len(), 2);\n            assert_eq(array_a.get(0), 10);\n            assert_eq(array_a.get(1), 20);\n\n            assert_eq(array_b.len(), 1);\n            assert_eq(array_b.get(0), 99);\n        });\n    }\n}\n"
+      "source": "use crate::oracle::capsules;\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n    /// Scope for capsule isolation. Capsule operations are scoped to the given address, allowing multiple independent\n    /// namespaces within the same contract.\n    scope: AztecAddress,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray scoped to a specific address.\n    ///\n    /// Array elements are stored in contiguous slots\n    /// following the base slot, so there should be sufficient space between array base slots to accommodate elements.\n    /// A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field, scope: AztecAddress) -> Self {\n        Self { contract_address, base_slot, scope }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot, self.scope).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(\n            self.contract_address,\n            self.slot_at(current_length),\n            value,\n            self.scope,\n        );\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            new_length,\n            self.scope,\n        );\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index), self.scope).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n                self.scope,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(\n            self.contract_address,\n            self.slot_at(current_length - 1),\n            self.scope,\n        );\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            current_length - 1,\n            self.scope,\n        );\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index, in order (from the first\n    /// element to the last).\n    ///\n    /// Structurally mutating the array from inside the callback (e.g. via `push` or `remove`) is **not** supported:\n    /// it can cause elements to be skipped, visited more than once, or read out of bounds.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        for i in 0..n {\n            f(i, self.get(i));\n        }\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n\n    global SLOT: Field = 1230;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT, scope);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(5);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 8);\n            assert_eq(array.get(2), 9);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements_in_order() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert_eq(called_with.get(0), (0, 4));\n            assert_eq(called_with.get(1), (1, 5));\n            assert_eq(called_with.get(2), (2, 6));\n        });\n    }\n\n    #[test]\n    unconstrained fn different_scopes_are_isolated() {\n        let mut env = TestEnvironment::new();\n        let scope_a = env.create_light_account();\n        let scope_b = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array_a = CapsuleArray::at(contract_address, SLOT, scope_a);\n            let array_b = CapsuleArray::at(contract_address, SLOT, scope_b);\n\n            array_a.push(10);\n            array_a.push(20);\n            array_b.push(99);\n\n            assert_eq(array_a.len(), 2);\n            assert_eq(array_a.get(0), 10);\n            assert_eq(array_a.get(1), 20);\n\n            assert_eq(array_b.len(), 1);\n            assert_eq(array_b.get(0), 99);\n        });\n    }\n}\n"
     },
     "69": {
       "function_locations": [
@@ -4092,47 +4152,51 @@
       "function_locations": [
         {
           "name": "UtilityContext::new",
-          "start": 416
+          "start": 502
         },
         {
           "name": "UtilityContext::at",
-          "start": 523
+          "start": 609
         },
         {
           "name": "UtilityContext::block_header",
-          "start": 855
+          "start": 981
         },
         {
           "name": "UtilityContext::block_number",
-          "start": 927
+          "start": 1053
         },
         {
           "name": "UtilityContext::timestamp",
-          "start": 1011
+          "start": 1137
         },
         {
           "name": "UtilityContext::this_address",
-          "start": 1104
+          "start": 1230
+        },
+        {
+          "name": "UtilityContext::maybe_msg_sender",
+          "start": 2019
         },
         {
           "name": "UtilityContext::version",
-          "start": 1177
+          "start": 2223
         },
         {
           "name": "UtilityContext::chain_id",
-          "start": 1257
+          "start": 2303
         },
         {
           "name": "UtilityContext::raw_storage_read",
-          "start": 1404
+          "start": 2450
         },
         {
           "name": "UtilityContext::storage_read",
-          "start": 1596
+          "start": 2642
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
-      "source": "use crate::oracle::{execution::get_utility_context, storage::storage_read};\nuse crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress, traits::Packable};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n    block_header: BlockHeader,\n    contract_address: AztecAddress,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        get_utility_context()\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        // We get a context with default contract address, and then we construct the final context with the provided\n        // contract address.\n        let default_context = get_utility_context();\n\n        Self { block_header: default_context.block_header, contract_address }\n    }\n\n    pub fn block_header(self) -> BlockHeader {\n        self.block_header\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_header.block_number()\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.block_header.timestamp()\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.block_header.version()\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.block_header.chain_id()\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        storage_read(self.block_header, self.this_address(), storage_slot)\n    }\n\n    pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
+      "source": "use crate::oracle::{execution::get_utility_context, storage::storage_read};\nuse crate::protocol::{\n    abis::block_header::BlockHeader, address::AztecAddress, constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    traits::Packable,\n};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n    block_header: BlockHeader,\n    contract_address: AztecAddress,\n    msg_sender: AztecAddress,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        get_utility_context()\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        // We get a context with default contract address, and then we construct the final context with the provided\n        // contract address.\n        let default_context = get_utility_context();\n\n        Self { block_header: default_context.block_header, contract_address, msg_sender: default_context.msg_sender }\n    }\n\n    pub fn block_header(self) -> BlockHeader {\n        self.block_header\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_header.block_number()\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.block_header.timestamp()\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    /// Returns the address that initiated this utility call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name). A utility function called by another contract\n    /// (via a nested utility call) sees that contract's address. A utility function invoked directly (e.g. by a wallet\n    /// or dApp) has no caller and sees `Option::none`.\n    ///\n    /// Important Note: utility functions are simulated client-side and never proven, so this value is whatever the\n    /// simulator (PXE) set it to: nothing about it is verified onchain. It exists to assist simulation in a\n    /// cooperative environment and must not be relied on as a security guarantee.\n    pub unconstrained fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        if self.msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(self.msg_sender)\n        }\n    }\n\n    pub fn version(self) -> Field {\n        self.block_header.version()\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.block_header.chain_id()\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        storage_read(self.block_header, self.this_address(), storage_slot)\n    }\n\n    pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
     "77": {
       "function_locations": [
@@ -4237,6 +4301,84 @@
       "source": "use crate::protocol::{hash::poseidon2_hash_bytes, traits::{Deserialize, Empty, FromField, Serialize, ToField}};\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct EventSelector {\n    // Low 32 bits of the poseidon2 hash of the event signature.\n    inner: u32,\n}\n\nimpl FromField for EventSelector {\n    fn from_field(field: Field) -> Self {\n        Self { inner: field as u32 }\n    }\n}\n\nimpl ToField for EventSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl Empty for EventSelector {\n    fn empty() -> Self {\n        Self { inner: 0 as u32 }\n    }\n}\n\nimpl EventSelector {\n    pub fn from_u32(value: u32) -> Self {\n        Self { inner: value }\n    }\n\n    pub fn from_signature<let N: u32>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = poseidon2_hash_bytes(bytes);\n\n        // `hash` is automatically truncated to fit within 32 bits.\n        EventSelector::from_field(hash)\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n"
     },
     "83": {
+      "function_locations": [
+        {
+          "name": "record_retractable_fact",
+          "start": 2468
+        },
+        {
+          "name": "record_non_retractable_fact",
+          "start": 3104
+        },
+        {
+          "name": "delete_fact_collection",
+          "start": 3741
+        },
+        {
+          "name": "get_fact_collection",
+          "start": 4119
+        },
+        {
+          "name": "get_fact_collections_by_type",
+          "start": 4512
+        },
+        {
+          "name": "test::setup",
+          "start": 5239
+        },
+        {
+          "name": "test::make_payload",
+          "start": 5454
+        },
+        {
+          "name": "test::assert_payload",
+          "start": 5688
+        },
+        {
+          "name": "test::record_fact",
+          "start": 5929
+        },
+        {
+          "name": "test::records_and_reads_a_fact",
+          "start": 6204
+        },
+        {
+          "name": "test::reads_collections_by_type",
+          "start": 7081
+        },
+        {
+          "name": "test::records_a_retractable_fact",
+          "start": 7805
+        },
+        {
+          "name": "test::deletes_a_fact_collection",
+          "start": 8798
+        },
+        {
+          "name": "test::reading_unknown_collection_returns_none",
+          "start": 9304
+        },
+        {
+          "name": "test::cannot_record_for_other_contract",
+          "start": 9713
+        },
+        {
+          "name": "test::re_recording_an_identical_fact_is_a_no_op",
+          "start": 10015
+        },
+        {
+          "name": "test::deleting_a_non_existing_collection_is_a_no_op",
+          "start": 10511
+        },
+        {
+          "name": "test::recording_a_fact_after_delete_recreates_the_collection",
+          "start": 10943
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/facts/mod.nr",
+      "source": "//! Storage of immutable facts grouped into collections.\n//!\n//! A fact is a contract-defined, typed, immutable datum. Facts are grouped into collections identified by a\n//! `(collection type, collection id)` tuple.\n//!\n//! They are stored in PXE's FactStore, which automatically deals with reorgs by removing any facts\n//! associated with blocks that have been pruned.\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::fact_store::{\n    delete_fact_collection_oracle, get_fact_collection_oracle, get_fact_collections_by_type_oracle, record_fact_oracle,\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// The block a retractable fact originates from.\n#[derive(Deserialize, Eq, Serialize)]\npub struct OriginBlock {\n    pub block_number: u32,\n    pub block_hash: Field,\n}\n\n/// A single immutable fact in a collection.\n#[derive(Deserialize, Serialize)]\npub struct Fact {\n    /// A user-defined identifier for fact kinds. Typically used to determine how to deserialize `payload`.\n    pub fact_type_id: Field,\n    pub payload: EphemeralArray<Field>,\n    /// The block the fact is associated to, if any. A fact with an origin block is said to be a 'retractable' fact,\n    /// and will be automatically deleted if its origin block gets pruned in a reorg. Typically used by facts\n    /// associated with a transaction (e.g. 'processed entry X using data from tx Y in block Z').\n    pub origin_block: Option<OriginBlock>,\n}\n\n/// A fact collection as returned by the store.\n#[derive(Deserialize, Serialize)]\npub struct FactCollection {\n    pub contract_address: AztecAddress,\n    pub scope: AztecAddress,\n    /// The collection's type. A single contract may have facts in collections of different types (e.g. one for the\n    /// processing offchain messages, another for partial notes, etc.).\n    pub fact_collection_type_id: Field,\n    /// The collection's unique identifier among the other collections of this type in this contract and scope.\n    pub fact_collection_id: Field,\n    pub facts: EphemeralArray<Fact>,\n}\n\n/// Records a retractable fact into a collection: PXE prunes it if `origin_block` is reorg'd away. Re-recording an\n/// identical fact is a no-op.\npub unconstrained fn record_retractable_fact(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n    origin_block: OriginBlock,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::some(origin_block),\n    );\n}\n\n/// Records a non-retractable fact into a collection: it survives reorgs and will persist until the fact collection\n/// itself is deleted. Re-recording an identical fact is a no-op.\npub unconstrained fn record_non_retractable_fact(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::none(),\n    );\n}\n\n/// Deletes a fact collection, removing all its facts from PXE storage.\n///\n/// Collections must be eventually deleted to reclaim storage and to stop reprocessing past the lifespan of the\n/// workflows they enable.\n///\n/// A no-op if no such collection exists.\npub unconstrained fn delete_fact_collection(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) {\n    delete_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    );\n}\n\n/// Fetches a fact collection.\npub unconstrained fn get_fact_collection(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) -> Option<FactCollection> {\n    get_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    )\n}\n\n/// Returns every fact collection of `fact_collection_type_id`.\npub unconstrained fn get_fact_collections_by_type(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n) -> EphemeralArray<FactCollection> {\n    get_fact_collections_by_type_oracle(contract_address, scope, fact_collection_type_id)\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::facts::{\n        delete_fact_collection, get_fact_collection, get_fact_collections_by_type, OriginBlock,\n        record_non_retractable_fact, record_retractable_fact,\n    };\n    use crate::protocol::address::AztecAddress;\n    use crate::protocol::traits::{FromField, ToField};\n    use crate::test::helpers::test_environment::TestEnvironment;\n\n    global TYPE_ID: Field = 42;\n    global COLLECTION_ID: Field = 7;\n    global FACT_TYPE_ID: Field = 99;\n    global PAYLOAD: [Field; 3] = [123, 456, 789];\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    unconstrained fn make_payload<let N: u32>(values: [Field; N]) -> EphemeralArray<Field> {\n        let payload: EphemeralArray<Field> = EphemeralArray::empty();\n        for i in 0..N {\n            payload.push(values[i]);\n        }\n        payload\n    }\n\n    unconstrained fn assert_payload(payload: EphemeralArray<Field>) {\n        assert_eq(payload.len(), PAYLOAD.len());\n        for i in 0..PAYLOAD.len() {\n            assert_eq(payload.get(i), PAYLOAD[i]);\n        }\n    }\n\n    unconstrained fn record_fact(contract_address: AztecAddress, scope: AztecAddress) {\n        record_non_retractable_fact(\n            contract_address,\n            scope,\n            TYPE_ID,\n            COLLECTION_ID,\n            FACT_TYPE_ID,\n            make_payload(PAYLOAD),\n        );\n    }\n\n    #[test]\n    unconstrained fn records_and_reads_a_fact() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.contract_address, contract_address);\n            assert_eq(collection.scope, scope);\n            assert_eq(collection.fact_collection_type_id, TYPE_ID);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n            assert(fact.origin_block.is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn reads_collections_by_type() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 1);\n\n            let collection = collections.get(0);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n        });\n    }\n\n    #[test]\n    unconstrained fn records_a_retractable_fact() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_retractable_fact(\n                contract_address,\n                scope,\n                TYPE_ID,\n                COLLECTION_ID,\n                FACT_TYPE_ID,\n                make_payload(PAYLOAD),\n                OriginBlock { block_number: 5, block_hash: 0xabc },\n            );\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n\n            let origin_block = fact.origin_block.unwrap();\n            assert_eq(origin_block.block_number, 5);\n            assert_eq(origin_block.block_hash, 0xabc);\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_a_fact_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn reading_unknown_collection_returns_none() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(collection.is_none());\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_record_for_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let other = AztecAddress::from_field(context.this_address().to_field() + 1);\n            record_fact(other, scope);\n        });\n    }\n\n    #[test]\n    unconstrained fn re_recording_an_identical_fact_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn deleting_a_non_existing_collection_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn recording_a_fact_after_delete_recreates_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            record_fact(contract_address, scope);\n            let collection_before_delete =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_before_delete.facts.len(), 1);\n\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n\n            record_fact(contract_address, scope);\n            let collection_after_recreate =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_after_recreate.facts.len(), 1);\n        });\n    }\n}\n"
+    },
+    "84": {
       "function_locations": [
         {
           "name": "compute_secret_hash",
@@ -4282,7 +4424,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE, DOM_SEP__PUBLIC_CALLDATA,\n        DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the prepended field.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n\n#[test]\nunconstrained fn secret_hash_matches_typescript() {\n    let secret = 8;\n    let hash = compute_secret_hash(secret);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let secret_hash_from_ts = 0x1848b066724ab0ffb50ecb0ee3398eb839f162823d262bad959721a9c13d1e96;\n\n    assert_eq(hash, secret_hash_from_ts);\n}\n\n#[test]\nunconstrained fn var_args_hash_matches_typescript() {\n    let mut input = [0; 100];\n    for i in 0..100 {\n        input[i] = i as Field;\n    }\n    let hash = hash_args(input);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let var_args_hash_from_ts = 0x262e5e121a8efc0382566ab42f0ae2a78bd85db88484f83018fe07fc2552ba0c;\n\n    assert_eq(hash, var_args_hash_from_ts);\n}\n\n#[test]\nunconstrained fn compute_calldata_hash() {\n    let mut input = [0; 100];\n    for i in 0..input.len() {\n        input[i] = i as Field;\n    }\n    let hash = hash_calldata_array(input);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let calldata_hash_from_ts = 0x14a1539bdb1d26e03097cf4d40c87e02ca03f0bb50a3e617ace5a7bfd3943944;\n\n    // Used in cpp vm2 tests:\n    assert_eq(hash, calldata_hash_from_ts);\n}\n\n#[test]\nunconstrained fn public_bytecode_commitment() {\n    let mut input = [0; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS];\n    let len = 99;\n    for i in 1..len + 1 {\n        input[i] = i as Field;\n    }\n    input[0] = (len as Field) * 31;\n    let hash = compute_public_bytecode_commitment(input);\n    // Used in cpp vm2 tests:\n    assert_eq(hash, 0x09348974e76c3602893d7a4b4bb52c2ec746f1ade5004ac471d0fbb4587a81a6);\n}\n"
     },
-    "94": {
+    "95": {
       "function_locations": [
         {
           "name": "derive_ecdh_shared_secret",
@@ -4320,7 +4462,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/keys/ecdh_shared_secret.nr",
       "source": "use crate::protocol::{\n    address::aztec_address::AztecAddress,\n    constants::{DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET, DOM_SEP__ECDH_FIELD_MASK, DOM_SEP__ECDH_SUBKEY},\n    hash::poseidon2_hash_with_separator,\n    point::EmbeddedCurvePoint,\n    scalar::Scalar,\n    traits::{FromField, ToField},\n};\nuse std::{embedded_curve_ops::multi_scalar_mul, ops::Neg};\n\n/// Computes a standard ECDH shared secret: secret * public_key = shared_secret.\n///\n/// The input secret is known only to one party. The output shared secret can be derived given knowledge of\n/// `public_key`'s key-pair and the public ephemeral secret, using this same function (with reversed inputs).\n///\n/// E.g.: Epk = esk * G // ephemeral key-pair\n///       Pk = sk * G // recipient key-pair\n///       Shared secret S = esk * Pk = sk * Epk\n///\n/// See also: https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman\npub fn derive_ecdh_shared_secret(secret: Scalar, public_key: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n    multi_scalar_mul([public_key], [secret])\n}\n\n/// Computes an app-siloed shared secret from a raw ECDH shared secret point and a contract address.\n///\n/// `s_app = h(DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET, S.x, S.y, contract_address)`\npub fn compute_app_siloed_shared_secret(shared_secret: EmbeddedCurvePoint, contract_address: AztecAddress) -> Field {\n    poseidon2_hash_with_separator(\n        [shared_secret.x, shared_secret.y, contract_address.to_field()],\n        DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET,\n    )\n}\n\n/// Derives an indexed subkey from an app-siloed shared secret, used for AES key/IV derivation.\n///\n/// `s_i = h(DOM_SEP__ECDH_SUBKEY + i, s_app)`\npub(crate) fn derive_shared_secret_subkey(s_app: Field, index: u32) -> Field {\n    poseidon2_hash_with_separator([s_app], DOM_SEP__ECDH_SUBKEY + index)\n}\n\n/// Derives an indexed field mask from an app-siloed shared secret, used for masking ciphertext fields.\n///\n/// `m_i = h(DOM_SEP__ECDH_FIELD_MASK + i, s_app)`\npub(crate) fn derive_shared_secret_field_mask(s_app: Field, index: u32) -> Field {\n    poseidon2_hash_with_separator([s_app], DOM_SEP__ECDH_FIELD_MASK + index)\n}\n\n#[test]\nunconstrained fn test_consistency_with_typescript() {\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = EmbeddedCurvePoint {\n        x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n        y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n    };\n\n    let shared_secret = derive_ecdh_shared_secret(secret, point);\n\n    // This is just pasted from a test run. The original typescript code from which this could be generated seems to\n    // have been deleted by someone, and soon the typescript code for encryption and decryption won't be needed, so\n    // this will have to do.\n    let hard_coded_shared_secret = EmbeddedCurvePoint {\n        x: 0x15d55a5b3b2caa6a6207f313f05c5113deba5da9927d6421bcaa164822b911bc,\n        y: 0x0974c3d0825031ae933243d653ebb1a0b08b90ee7f228f94c5c74739ea3c871e,\n    };\n    assert_eq(shared_secret, hard_coded_shared_secret);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_in_both_directions() {\n    let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n    let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n    let pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n    let pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n    let shared_secret = derive_ecdh_shared_secret(secret_a, pk_b);\n    let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n    assert_eq(shared_secret, shared_secret_alt);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_from_address_in_both_directions() {\n    let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n    let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n    let mut pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n    let mut pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n    let address_b = AztecAddress::from_field(pk_b.x);\n\n    // We were lazy in deriving the secret keys, and didn't check the resulting y-coordinates of the pk_a or pk_b to be\n    // less than half the field modulus. If needed, we negate the pk's so that they yield valid address points. (We\n    // could also have negated the secrets, but there's no negate method for EmbeddedCurvesScalar).\n    pk_a = if (AztecAddress::from_field(pk_a.x).to_address_point().unwrap().inner == pk_a) {\n        pk_a\n    } else {\n        pk_a.neg()\n    };\n    pk_b = if (address_b.to_address_point().unwrap().inner == pk_b) {\n        pk_b\n    } else {\n        pk_b.neg()\n    };\n\n    let shared_secret = derive_ecdh_shared_secret(secret_a, address_b.to_address_point().unwrap().inner);\n    let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n    assert_eq(shared_secret, shared_secret_alt);\n}\n\n#[test]\nunconstrained fn test_app_siloed_shared_secret_differs_per_contract() {\n    let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n    let pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(Scalar { lo: 0x3456, hi: 0x4567 });\n\n    let shared_secret = derive_ecdh_shared_secret(secret_a, pk_b);\n\n    let contract_a = AztecAddress::from_field(0xAAAA);\n    let contract_b = AztecAddress::from_field(0xBBBB);\n\n    let s_app_a = compute_app_siloed_shared_secret(shared_secret, contract_a);\n    let s_app_b = compute_app_siloed_shared_secret(shared_secret, contract_b);\n\n    assert(s_app_a != s_app_b, \"app-siloed secrets must differ for different contracts\");\n}\n"
     },
-    "96": {
+    "97": {
       "function_locations": [
         {
           "name": "get_nhk_app",
@@ -4340,81 +4482,11 @@
         },
         {
           "name": "test::get_public_keys_fails_with_bad_hint",
-          "start": 2256
+          "start": 2270
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr",
-      "source": "use crate::{\n    keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n    oracle::{\n        key_validation_request::get_key_validation_request,\n        keys::{get_public_keys_and_partial_address, try_get_public_keys_and_partial_address},\n    },\n};\nuse crate::protocol::{address::AztecAddress, public_keys::PublicKeys};\n\npub unconstrained fn get_nhk_app(npk_m_hash: Field) -> Field {\n    get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used in\n// unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n    get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all keys at once\n// since the constraints for reading them all are actually fewer than if we read them one at a time - any read keys\n// that are not required by the caller can simply be discarded.\n// Fails if the public keys are not registered\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n    // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n    let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n    assert_eq(account, AztecAddress::compute(public_keys, partial_address), \"Invalid public keys hint for address\");\n\n    public_keys\n}\n\n/// Returns all public keys for a given account, or `None` if the public keys are not registered in the PXE.\npub unconstrained fn try_get_public_keys(account: AztecAddress) -> Option<PublicKeys> {\n    try_get_public_keys_and_partial_address(account).map(|(public_keys, _)| public_keys)\n}\n\nmod test {\n    use super::get_public_keys;\n\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use std::test::OracleMock;\n\n    global KEY_ORACLE_RESPONSE_LENGTH: u32 = 8; // 5 key hashes + 1 key point + 1 partial address\n\n    #[test(should_fail_with = \"Invalid public keys hint for address\")]\n    unconstrained fn get_public_keys_fails_with_bad_hint() {\n        let mut env = TestEnvironment::new();\n        let account = env.create_light_account();\n\n        // Instead of querying for some unknown account, which would result in the oracle erroring out, we mock a bad\n        // oracle response to check that the circuit properly checks the address derivation.\n        // Wire shape: [npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash,\n        // partial_address].\n        let mut random_keys_and_partial_address = [0; KEY_ORACLE_RESPONSE_LENGTH];\n        // npk_m_hash\n        random_keys_and_partial_address[0] = 0x292364b852c6c6f01472951e76a39cbcf074591fd0e063a81965e7b51ad868a5;\n        // ivpk_m (x, y) -- arbitrary, doesn't have to be on-curve to make this test fail\n        random_keys_and_partial_address[1] = 0x173c5229a00c5425255680dd6edc27e278c48883991f348fe6985de43b4ec25f;\n        random_keys_and_partial_address[2] = 0x1698608e23b5f6c2f43c49a559108bb64e2247b8fc2da842296a416817f40b7f;\n        // ovpk_m_hash\n        random_keys_and_partial_address[3] = 0x1bad2f7d1ad960a1bd0fe4d2c8d17f5ab4a86ef8b103e0a9e7f67ec0d3b4795e;\n        // tpk_m_hash\n        random_keys_and_partial_address[4] = 0x05e3bd9cfe6b47daa139613619cf7d7fd8bb0112b6f2908caa6d9b536ed948ed;\n        // mspk_m_hash\n        random_keys_and_partial_address[5] = 0x1a4f87ed20a8ce7e8d2b2c731f9b3d39f37e2d4ab2c6db66f7c8e3e9f1b6b39d;\n        // fbpk_m_hash\n        random_keys_and_partial_address[6] = 0x0fbb9c2bf6cb4d4a1d4ee2f8b3a2c5e3d4b9c1a8e5f2d6b7c8e3f4a5b6c7d8e9;\n        // partial address\n        random_keys_and_partial_address[7] = 0x236703e2cb00a182e024e98e9f759231b556d25ff19f98896cebb69e9e678cc9;\n\n        let _ = OracleMock::mock(\"aztec_utl_getPublicKeysAndPartialAddress\").returns(Option::some(\n            random_keys_and_partial_address,\n        ));\n        let _ = get_public_keys(account);\n    }\n}\n"
-    },
-    "99": {
-      "function_locations": [
-        {
-          "name": "log_prefix",
-          "start": 525
-        },
-        {
-          "name": "aztecnr_fatal_log",
-          "start": 717
-        },
-        {
-          "name": "aztecnr_error_log",
-          "start": 943
-        },
-        {
-          "name": "aztecnr_warn_log",
-          "start": 1168
-        },
-        {
-          "name": "aztecnr_info_log",
-          "start": 1392
-        },
-        {
-          "name": "aztecnr_verbose_log",
-          "start": 1619
-        },
-        {
-          "name": "aztecnr_debug_log",
-          "start": 1847
-        },
-        {
-          "name": "aztecnr_trace_log",
-          "start": 2073
-        },
-        {
-          "name": "aztecnr_fatal_log_format",
-          "start": 2367
-        },
-        {
-          "name": "aztecnr_error_log_format",
-          "start": 2622
-        },
-        {
-          "name": "aztecnr_warn_log_format",
-          "start": 2876
-        },
-        {
-          "name": "aztecnr_info_log_format",
-          "start": 3129
-        },
-        {
-          "name": "aztecnr_verbose_log_format",
-          "start": 3385
-        },
-        {
-          "name": "aztecnr_debug_log_format",
-          "start": 3642
-        },
-        {
-          "name": "aztecnr_trace_log_format",
-          "start": 3897
-        },
-        {
-          "name": "resolve_fn",
-          "start": 4151
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/logging.nr",
-      "source": "// Not all log levels are currently used, but we provide the full set so that new call sites can use any level. Because\n// of that we tag all with `#[allow(dead_code)]` to prevent warnings.\n//\n// All wrappers resolve function paths at comptime via `resolve_fn` so that the emitted `Quoted` code works both inside\n// aztec-nr (where `crate::` = aztec) and inside macro-generated contract code (where `crate::` = the contract).\n\nuse std::meta::ctstring::AsCtString;\n\ncomptime fn log_prefix<let N: u32>(msg: str<N>) -> CtString {\n    \"[aztec-nr] \".as_ctstring().append_str(msg)\n}\n\n// --- No-args variants (direct call) ---\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_fatal_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::fatal_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_error_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::error_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_warn_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::warn_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_info_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::info_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_verbose_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::verbose_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_debug_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::debug_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_trace_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::trace_log });\n    quote { $f($msg) }\n}\n\n// --- Format variants (return lambda for runtime args) ---\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_fatal_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::fatal_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_error_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::error_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_warn_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::warn_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_info_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::info_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_verbose_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::verbose_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_debug_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::debug_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_trace_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::trace_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n// See module-level comment for why this is needed.\ncomptime fn resolve_fn(path: Quoted) -> TypedExpr {\n    path.as_expr().unwrap().resolve(Option::none())\n}\n"
+      "source": "use crate::{\n    keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n    oracle::{\n        key_validation_request::get_key_validation_request,\n        keys::{get_public_keys_and_partial_address, try_get_public_keys_and_partial_address},\n    },\n};\nuse crate::protocol::{address::AztecAddress, public_keys::PublicKeys};\n\npub unconstrained fn get_nhk_app(npk_m_hash: Field) -> Field {\n    get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used in\n// unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n    get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all keys at once\n// since the constraints for reading them all are actually fewer than if we read them one at a time - any read keys\n// that are not required by the caller can simply be discarded.\n// Fails if the public keys are not registered\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n    // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n    let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n    assert_eq(account, AztecAddress::compute(public_keys, partial_address), \"Invalid public keys hint for address\");\n\n    public_keys\n}\n\n/// Returns all public keys for a given account, or `None` if the public keys are not registered in the PXE.\npub unconstrained fn try_get_public_keys(account: AztecAddress) -> Option<PublicKeys> {\n    try_get_public_keys_and_partial_address(account).map(|(public_keys, _)| public_keys)\n}\n\nmod test {\n    use super::get_public_keys;\n\n    use crate::protocol::{address::PartialAddress, point::EmbeddedCurvePoint, public_keys::{IvpkM, PublicKeys}};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use std::test::OracleMock;\n\n    #[test(should_fail_with = \"Invalid public keys hint for address\")]\n    unconstrained fn get_public_keys_fails_with_bad_hint() {\n        let mut env = TestEnvironment::new();\n        let account = env.create_light_account();\n\n        // Instead of querying for some unknown account, which would result in the oracle erroring out, we mock a bad\n        // oracle response to check that the circuit properly checks the address derivation. The values below are\n        // arbitrary; `ivpk_m` does not have to be on-curve to make this test fail.\n        let public_keys = PublicKeys {\n            npk_m_hash: 0x292364b852c6c6f01472951e76a39cbcf074591fd0e063a81965e7b51ad868a5,\n            ivpk_m: IvpkM {\n                inner: EmbeddedCurvePoint {\n                    x: 0x173c5229a00c5425255680dd6edc27e278c48883991f348fe6985de43b4ec25f,\n                    y: 0x1698608e23b5f6c2f43c49a559108bb64e2247b8fc2da842296a416817f40b7f,\n                },\n            },\n            ovpk_m_hash: 0x1bad2f7d1ad960a1bd0fe4d2c8d17f5ab4a86ef8b103e0a9e7f67ec0d3b4795e,\n            tpk_m_hash: 0x05e3bd9cfe6b47daa139613619cf7d7fd8bb0112b6f2908caa6d9b536ed948ed,\n            mspk_m_hash: 0x1a4f87ed20a8ce7e8d2b2c731f9b3d39f37e2d4ab2c6db66f7c8e3e9f1b6b39d,\n            fbpk_m_hash: 0x0fbb9c2bf6cb4d4a1d4ee2f8b3a2c5e3d4b9c1a8e5f2d6b7c8e3f4a5b6c7d8e9,\n        };\n        let partial_address = PartialAddress::from_field(\n            0x236703e2cb00a182e024e98e9f759231b556d25ff19f98896cebb69e9e678cc9,\n        );\n\n        let _ = OracleMock::mock(\"aztec_utl_getPublicKeysAndPartialAddress\").returns(Option::some((\n            public_keys, partial_address,\n        )));\n        let _ = get_public_keys(account);\n    }\n}\n"
     }
   },
   "functions": [
@@ -6188,11 +6260,11 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "tZfdbuowDMffpddcxLGdD17l6GhirJuQKkAdTDqa9u7HYU5aJiWCbrvh3zTkV8d2nOS9e+ofzy8Pu/3z4bVb/3nvHsfdMOxeHobDdnPaHfby9r0z6QeoW9PHqoNLA7s1SsNeGvIKpIG5YT+klQkPp7HvU88MKR86bsZ+f+rW+/MwrLq3zXC+/On1uNlf9LQZpdesun7/JCrA593Qp6eP1TTa1IeSJx1MwZfh1vCtgG9820XUwZ7i7NvxVgCw8UoAjpMFFm62IViMigg2Th4A8FcIbliBIWQrCBdZYdHliVgCW7XCNxDgshXW2mkiAa8IoU6IaFgJEWkyAv01IjYQhnJIo5kF5CsCGr7AghC/Ts4MdE2ABsFA9iYay8sYYHJmI2CDgY21BT4zyJpZbvnbzXDkshmOadlUXOpVhsUqo5WfRFTyM4ZqfkIjQUFCYfM6MXYWWxfvgBDHAmHgGqQxGWbMec7s6kvethwSqJQeeWZXs6MN8cUj4g8ICyYDkfNygeigEBhujq2ZYmt8qBEstYxANMUKSdSqNxpllEsVdehmu4G9wwyish9EclQ1o5FhwQSb55KeYUFQpAC7UouRlgQFIkzVnGsEND8QFITvBqVtxo1BQfzloEzukMewJCiymxSCjdWguIY3ApRDD4R0Qqh547dTVIpWKT2MS7zhY6kbAauVh1qVmEw598hzqOYGwe96g73PUeFguLolEP7AltCGsJm8yrPA3AfxE2S+cO+0BGcQvwzy/R2OfTmWciSoxqaBkEzNhwYf3Zfjy19pbra78foyByw2yjXOpUO9qFcNqjGtX7nZGdV0uZNvWKuKqYaLkiqnQi7qVL1q0PEx1RS5HAov7R2Y7ofyHq1quknK/5HSAVmUVV06Jot61ZDOmqLxU0l4aXsnUBVeWviEqqTKqsJLJ07yqkE1fionnmQ5wyefrSqqJp7YwazqVL2q2sdqnzOqynOJlyrr22bcbR6HPgUjxeu83+bYSPP075h78lX8OB62/dN57FMcL30S2f8=",
+      "debug_symbols": "tZfdTuswDMffpddcxLGdj73K0REqo6BJ1TaVDekI8e7HGU7aISUaBW72b5rlV8d2nOStexwezs/3u/3T4aXb/HnrHqbdOO6e78fDtj/tDnt5+9aZ9APUbej9roNLA7sNSsNeGvIKpIG5Yd+llQn3p2kYUs8CKR869tOwP3Wb/Xkc77rXfjxf/vRy7PcXPfWT9Jq7btg/igrwaTcO6en9bh5t6kPJkw6m4MtwCzcDvvFtF1EHe4qLb/OtAGDjlQAczQLhb0UEi1ERwcbZAwDhCsENKzCEbAXhKissujwRS2CrVvgGAly2wlo7TyTQFSHUCRENKyEizUZgwCtEbCAM5ZBGswjIZwQ0fIEFIX6dnRmv5wHQIBjI3kRjeR0DTM5sBGwwsLG2wGcGWbPILX+7GY5cNsMxrZuKS73KsFhltPKTiEp+xlDNT2gkKEgobF4nxi5i6+IXIMSxQBi4BmlMhhlznjO7+pK3LYcEKqVHntnV7GhDfPGI+APCislA5LxcIDooBIabY2vm2BofagRLLSMQTbFCErXqjUYZ5VJFHc7uTOvmdjOIyn4QyVHVjEaGBRNsnkt6hhVBkQLsSi1GWhMUiDBXc64R0PxAUBC+G5S2GTcGBfGXgzK7Qx7DmqDIblIINlaD4hreCFAOPRDSMavmjd9OUSlapfQwrvGGj6VuBKxWHmpVYjLl3CPPoZobBL/rDfY+R4WD4eqWQPgDW0Ibwmb2Ki8C8zWInyHLhftFS3AB8esg39/h2JdjKUeCamwaCMnUfGjw0X06vvyVZr/dTdeXOWCxUa5xLh3qRb1qUI1p/crNzqimy518w1pVTDVclFQ5FXJRp+pVg46PqabI5VB4ae/AdD+U92hV001S/o+UDsiirOrSMVnUq4Z01hSNH0rCS9s7garw0sInVCVVVhVeOnGSVw2q8UM58STLGT74bFVRNfHEDmZVp+pV1T5W+5xRVZ5LvFRZX/tp1z+MQwpGitd5v82xkebp3zH35Kv4cTpsh8fzNKQ4Xvoksv8B",
       "is_unconstrained": false,
       "name": "constructor",
       "verification_key": "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"
@@ -8057,11 +8129,11 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "tZ3RrhvXkUX/Rc9+4K46p84p/8ogCJxECQwYTuDYAwwC//uwyd6LV5ohI+s6CJAuWdKuZrMXm6d63da/Pvzl459++dsfv//xr3//54dv/+tfH/700/c//PD93/74w9///N3P3//9x+t//deHy/F/Gh++Vfz6zQcdv9px/ZW++bDz3I5zO4/t9U/F7e9o3f+ztF30WcTl/JN5+5NH3uX6q3H/ex++7esv5vGL4w/GNVD3Tdw3ed+M+2beN/Xh23ndrPtm3zfXhnXtcrlvdN9cU/Z1k/fNNWVf25V769frr3wI/vjzTx8/Hr/z5phcj9Q/vvvp448/f/j2x19++OGbD//93Q+/3P7QP//x3Y+37c/f/XT93cs3Hz7++Jfr9hr41+9/+HhUv37z+NuX/8hfrdznX96XwV/XHl8asHc6oPfTgHwekDXPgFyPPRixPgkYzwNiOCBqPQ34sj3Y+TTgxTHocEBnPT0G670v4dXbOOsMWJdHQFy+/G1M78HelzcB/aUBEXP4NcRuInLNL43QvKwzQrPf7IW++HTeke3XEf04EtePl08i9OJ0UG4zoZFftRsRSg7Gm7M6Oz7djfk8Y8Tx4XfLuJ4I/eas2J9m1Iszew1xauvyPOPFudl18SHt0uP0Pg7NV2VkPs/o97+WuPwOGXqREeXXkrHj6Wt5tR+dPtF7Xp4fjfmKlXywMvfzvXjxwaklI6sV66v2Y5UvPmvr+V7Ue4/FK9iynBBD8ZT52C8yVBtg3xyK6/Xgk4h+9Touj6vAiDcfgJ9m5Kvz4jL8udGXN5+A/yfj1flJxPVz7PHh9fkFOV4kXOQDmpeYX5ehi0+MVL7IeHF+Dq0Ln4BvLmufva+vX0oA62XW172UGr64Xr8pjK/MmJuM+sq3pbggZEV+XUaDfPbopxnj8p99W3rxUno9341X1I/B943x9pvnZ7sxXl3pr2d3+BPwEm9wqf4NIWM2IVPzWcir61I0b0u++Qib+nQ3Xl3qL5f+/6Cdn35yjJdX6eJ1jMeH+fzsgO73fwaOfv9n4Ly89zNw6v2wvXxLdOGDQ2++VX/+lryKuH59dsR4s0D7LGK+Wh7tC0u02JKenZ//JiT2m5CnJ/ms9y8RXh/T5oBEPD8g+/d4LS/O0vG4sFzfl8eZ3p9G1Kvlzn4sd/aYTw9HvThN47L9WRzXOcnXHdIYXKqj4tkhrXx5pj/elmtdzw7p65DrCouQeH6ivg7JsR9fPL56TyIIGZen14Va7z/bX2V86VnW7z/L1uX9Z9nrYzr0eGPG82vtevG94XHNH72eTilen+yb77ZZTz+TX32MfeGbsubv8KbUfxj9EVyhxtSzo7FefJoqmBzpk0+PT781rH41tGEvdrz54nF8g/ji3cjwRU65Ls92Y7/4LF0qrtfX+s1r+ewMfR0y5yRkruchL1i5XrHjwlh2h75uT2ole3L939OQV0Oo9nk6366ePpsrvnxjHl+ktHo8PT9eRey8QMt6GrFfRNR4rGlrxJsR1OcH41XIfEwJrnXPr3tbun1AVlyev7etVy9ni1fzZvFTvyFhDV7K25348oSZQcKbZfFvSeCL6bV8lvD6bX1cZK/1fvqOdL37YNa7D2a9+2DWew/my4vBDBahdXl6adRF718AXlfb718B6pLvXQJeF7rvH/z8m5AvW0i+DvnCsY0u691zm3+zI182uHl5ntXjxVzZe3qe6dXaqfNxTbjedHsKvvTibJ3c6Kl8e3WL37IjY/BVrkeN5zvye1zwX+zJ9eLqr6Wr67OB2B+uv/zuz9//9Ond+jzuuV/fi9wH/ddt37fjcm51buPc5rkd53ae2zq369yeeePMm2fePPPmmTfPvHnmzTNvnnnzzJtn3jzz6syrM6/OvDrz6syrM6/OvDrz6syrM2+deevMW2feOvPWmbfOvHXmrTNvnXnrzNtn3tZB3Tc3BWKcCsSxgjkUiNv2mnfc+d11bg8d4Xqa7H1u+77tw0i4fmD2oSRc/17Huc3jw/66Hed2Ht8vrttr3vHdr695x5Wp97nt+/Y6m78W6yh0nHBHES7SxTV03/7wdFEulovtos9C1+RdR3EEHi2ULo7APorpoo5P+G/u8se9OALjlD+Ol6RD5rglHzrHvfAeHkrHvZguvIfhPQzvYXgPD73jXjj5pngc+3zYHX10z+miXCwX+7i0HcU18Jja6qDlXshFuEgXw8V0US6Wi+3CydPJ08nTydPJ08nTydPJ08nTydPJ5eRycjm5nFxOLieXk8vJ5eQDpdu7fLB0L3S+ywdN9+JIvv3WcDFdlIsjeR/FkXz7W30WB1X3Qi7CRboYLqaLcrFcOHk7uZ3cTm4nt5Pbye3kdnI7uZ3cZ3JcLi7kIlyki+FiuigXy8V24WQ5WU6Wk+VkOVlOlpPlZDn5IO5gMA6L6l7ovm6PA717kS6Gi+miXCwX20WfxYHevXByOjmdnE5OJ6eT08np5HTycPJw8nDycPJw8nDycPJw8nDycPJ08nTydPJ08nTydPJ08nTydPJ0cjm5nFxOLieXk8vJ5eRycjm5nLycvJy8nLycvJy8nLycvJy8nLycvJ28nbydvJ28nbydvJ28nbydvJ3cTm4nt5Pbye3kdnI7uZ3cTu4zOS8XF3IRLtLFcDFdlIvlYrtwspwsJ8vJcrKcLCfLyXKynCwnh5PNYJrBNINpBtMMphlMM5hmMM1gmsE0g2kG0wymGUwzmGYwzWCawTSDaQbTDKYZTDOYZjDNYJrBNINpBtMMphlMM5hmMM1gmsE0g2kG0wymGUwzmGYwzWCawTSDaQbTDKYZTDOYZjDNYJrBNINpBtMMphlMM5hmMM1gmsE0g2kG0wymGUwzmGYwzWCawTSDaQbTDKYZTDOYZjDNYJrBNINpBtMMphlMMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjM4DCDwwwOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOMzjN4DSD0wxOM1hmsMxgmcEyg+XBS3nwUrfBy+Uolovt4hxrlC4u5CJcpAsn3yYwdRTnWKNuy8Bb0WdxWwbeCt0nHhXniKAiXQwX00W5WC62i3P4UHlxIRdOTienk9PJ6eR0cjrZo5jyKKY8iimPYsqjmPIopjyKKY9iyqOY8iimPIopj2LKo5jyKKY8iimPYsqjmPIopjyKKY9iyqOY8iimPIopj2LKo5jyKKY8iimPYsqjmPIopsrJy8nLycvJy8nLycvJy8nLycvJy8nbydvJ28nbydvJ28nbydvJ28nbye3kdnI7uZ3cTm4nt5Pbye3kPpPX5eJCLsJFuhgupotysVxsF06Wk+VkOVlOlpPlZDlZTpaT5eRwcjjZDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuMzgMoPLDC4zuM3gNoPbDG4zuM3gNoPbDO4bg7f7K9tFn4XOsfO+Xf5uxTl23rfL3604x85b00W5WC6O5H0U56B13xi8FXIRLtLFcDFdlIvlYrtwcjo5nZxOTienk9PJ6eR0cjo5nTycPJw8nDycPJw8nDycPJw8nDycPJ08nTydPJ08nTydPJ08nTydPJ1cTi4nl5PLyeXkcnI5uZxcTi4nLycvJy8nLycvJy8nLycvJ/uWxPYtie1bEtu3JLZvSWzfkti+JbF9S2L7lsT2LYntWxLbtyS2b0ls35LYviWxfUti+5bE9i2J7VsS27cktm9JbN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+SaN+S6NtPgB8/NdS3HwG/V+3KdyX6huGtOL85t1eC7ZVgeyXYXgm2V4LtlWB7JdheCbZXgu2VYHsl2F4JtleC7ZVgeyXYXgm2V4LtlWB7JdheCbZXgu2VYHsl2F4JtleC7ZVgeyXYXgm2V4LtlWB7JdheCbZXgu2VYHsl2F4JtleC7ZVgeyXYXgm2V4LtlWB7JdheCbZXgu2VYHsl2F4JtleC7ZVgeyXYXgm2V4LtlWB7JdheCbZXgu2VYHsl2F4JtleC7ZVgeyXYXgm2V4LtlWB7JdheCbZXgu2VYHsl2F4JtleC7ZVgeyXYXgm2V4LXk/pCJaqgSqpBNamKalFtKnqIHqKH6CF6iB6ih+gheogeokfQI+gR9Ah6BD2CHkGPoEfQI+iR9Eh6JD2SHkmPpEfSI+mR9Eh6DHoMegx6DHoMegx6DHoMegx6DHpMekx6THpMekx6THpMekx6THpMehQ9ih5Fj6JH0aPoUfQoehQ9ih6LHoseix6LHoseix6LHoseix6LHpsemx6bHpsemx6bHpsemx6bHpseTY+mR9Oj6dH0aHo0PZoeTQ84F5wLzgXngnPBueBccC44F5wLzgXngnPBueBccC44F5wLzgXngnPBueBccC44F5wLzgXngnPBueBccC44F5wLzgXngnPBueBccC44F5wLzgXngnPBueD8Ju3cNaexqPxlRTdx5yxv35PnrRKVHaubvXNWg8qa1U3gOSu6zE2FalUXKtm6un1VvglUNagmVVEtqk11fJE71CZ51Sp52Sp53Sp54Sp55Sp56Sp57Sp58Sp59Sp5+Sptemx6bHpsemx6bHpsemx6bHpsejQ9mh5Nj6ZH06Pp0fRoejQ9vKRVeE2r8KJW4VWtwstahde1Ci9sFV7ZKjxeUni+pLjQQ/QQPUQP0UP0ED1ED9FD9BA9gh5Bj6BH0CPoEfQIegQ9gh5Bj6RH0iPpkfRIeiQ9kh5Jj6QHNl6g4wU+XiDkBUZeoOQFTl4g5QVWXqDlBV5eIOYFZl6g5gVuXiDnBXZeoOcFfl4g6AWGXqDoBY5eIOkFll6g6QWeXiDqBaZeoOpF0QPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOE84TzhPOb/bR7Wp/04/OalHtU469GUj36nYV71slqqPH/XeTalBNqqJaVOcEU+kBmNITMKVHYErPwJQegik9BVN6DKb0HEzpQZgSOTexcxM9N/FzE0E3MXQTRTdxdBNJN7F0E0038XQTUTcxdRNVN3F1E1k3sXUTXTfxdRNhNz0e0/B8TMMDMg1PyDQ8ItPwjEzDQzINT8k0PCbT8JxM40IP0UP0ED1ED9FD9BA9RA/RQ/QIegQ9gh5Bj6BH0CPoEfQIegQ9kh5Jj6RH0iPpkfRIeiQ9kh5Jj0GPQY9Bj0GPQY9Bj0GPQY9Bj0GPSY9Jj0mPSY9Jj0mPSY9Jj0mPSY+iR9Gj6FH0KHoUPYoe5SGpbr6TSxYeN+ep75WovLxBexLekxCfhPkk1CfhPgn5SdhPQn8S/pMQoIQBJRQo4UAJCUpYUEKDEh6UEKGECSVUKOFCCRlK2FBChxI+lBCihBEllCjhRAkpSlhRQosSXpQQo4QZJdQo4UYJOUrYUUKPEn6UEKSEISUUKeFICUlKWFJCkxKelBClhCklVCnhSglZSthSQpcSvpQQpoQxJZQp4UwJaUpYU0KbEt6UEKeEOSXUKeFOCXlK2FNCnxL+lBCohEElFCrhUAmJSlhUQqMSHpUQqYRJJVQq4VIJmUrYVEKnEj6VEKqEUSWUKuFUCalKWFVCqxJelRCrhFkl1CrhVgm5SthVQq8SfpUQrIRhJRQr4VgJyUpYVkKzEp6VEK2EaSVUK+FaCdlK2FZCtxK+lRCuhHEllCvhXAnpSlhXQrsS3pUQr1RwXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnBecF5wXnB+07tug86b33VWfPu5KV738i55zVslKo9dFz/behO9zspj18WPty5+vnXxA66Ln3BdNi11871uY9e75xW3alBNqqJaVJvKY1d0L+F7CeFLGF9C+RLOl5C+hPUltC/hfQnxS5hfQv0S7peQv4T9JfQv4X8JAUwYYEIBEw6YkMCEBSY0MOGBCRFMmGBCBRMumJDBhA0mdDDhgwkhTBhhQgkTTpiQwoQVJrQw4YUJMUyYYUINE26YkMOEHSb0MOGHCUFMGGJCEROOmJDEhCUmNDHhiQlRTJhiQhUTrpiQxYQtJnQx4YsJYUwYY0IZE86YkMaENSa0MeGNCXFMmGNCHRPumJDHhD0m9DHhjwmBTBhkQiETDpmQyLQZwW1GcJsR3GYEtxnBbUZwmxHcZgS3GcFtRnCbEdxmBLcZwW0433C+4XzD+YbzDecbzjecbzjfcL7hfMP5hvMN5xvON5xvON9wvuF8w/mG8w3nG843nG8433C+4XzD+YbzDecbzjecbzjfcL7hfMP5hvMN5xvON5xvON9wvuF8w/mG8w3nG843nG8433C+4XzD+YbzDecbzjecbzjfcL7hfMP5hvMN5xvON5xvON9wvuF8w/mG8w3nG843nG8433C+4XzD+YbzDecbzjecN5w3nDecN5w3nN89tXmrimpReex6c9XulTx2vdlqZ+Wx691Xu1eDalIV1aLy2LUZwTUjuGYE14zgmhFcM4JrRnDNCK4ZwTUjuGYE14zgmhFcM4JrRnDNCK4ZwTUjuGYE14zgmhFcM4JrRnDNCK4ZwTUjuGYE14zgmhFcM4JrRnDNCK4ZwTUjuGYE14zgmhFcM4JrRnDNCK4ZwTUjuGYE14zgmhFcM4JrRnDNCK6LHkUPRu3NqL0ZtTej9mbU3ozam1F7M2pvRu3NqL0ZtTej9mbU3ozam1F7M2pvRu3NqL0ZtTej9n48EuPxTIzHQzEeT8V4PBbj8VyMx4MxHk/GeDwa482zMc4ecXk8HePxeIzH8zEeD8h4PCHj8YiMxzMyHg/JeDwlg8dkXHhOxoUHZVx4UsaFR2VceFbGhYdlXHhaxgU3NS7IqXHBTo0LD8242E8NLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCCyy4wIILLLjAggssuMCCC8G54FxwLjgXnAvOBeeCc8G54FxwLjgXnAvOBeeCc8G54FxwLjgXnAvOBeeCc8G54FxwLjgXnAvOBeeCc8G54FxwLjgXnAvOBeeCc8G54FxwLjgXnAvOBeeCc8G54FxwLjgXnAvOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPOA84DzgPO3z4Fix6P52A9HoT1eBLW41FYj2dhPR6GBeePx2E9nof1eCDW44lYj0diPZ6J9Xgo1uOpWI/HYj2ei/V4MNbjyViPR2M9no31eDjW4+lYYds1wrZrBLZrBLZrhG3XCNuucfPhrh/TtzIf5XiU83g45e0fajxol24NDtxd7kfZlAfxLvUo41b+ejwf86fvv/vTDx//+eHbfx0Pwfzlxz/7gZfXX/78P//w7/gfsPzHT3//88e//PLTx+PhmMfv3f/dyus+/9fSN1t/8L9RefyX45/0uF4s/vDr8UzN/wU=",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "entrypoint",
       "verification_key": "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"
@@ -9833,12 +9905,12 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private",
         "abi_view"
       ],
-      "debug_symbols": "rZfbbuIwEIbfJddceDwzPvAqq6pKaVpFigJKYaVVxbvvmNg5INmioTf8hJAv4/HMb/u7em/eLp+vbf9x/Kr2f76rt6HtuvbztTse6nN77OXX70qFD6Bqj9ddBbcLrPZaLnS4QLkDuwpZ5Co/pmdfz0PThD8sYPKKUz00/bna95eu21V/6+5y+9PXqe5veq4Huat2VdO/iwrwo+2a8O26m59W+UfZ+fiw0XZ6HPzDAOMxAiz5CaCVfxQArGwkAPt5CBoejsFpTKNw2i+GAXaFoEIU6FyKgnBTFBpNGogm0NkoTAEBJkWh9WI+HK4INk/wqDgSPNIcBNo1whUQitKUerWYkHuEzyNwIkha51w6WgGgkEw0ZBLCMG1kAEwMjdsYHigx/LLA7xmYZxDY1KGk1aI87Q/CsNNQvM2HUSpPIprK07tseUKhPkFp1qlNlF7MrfE/gBD7CcLAOUjJthhTmTObfMdDoUgld5PzyHc22cEUIXbKiOQD3IbBkLap6wkZs4Mpmehsw2AX7YJerxC6UKZMmMJgmaGJEexwxSjYKBuVssEGKM/gko+mbpFiWxDg0WRYcKlZbFiIcvnUttQtHvXcLosSu5tX7Z62c+2f93NUzxs6wrOOHlL2rBsXZ4UVTC0r+4Zst2GhRmmyDnKwZcvD1qZksFOcrS80v2A+ZQirydMdL6zjZxA7QwxujgQXELsN8ryXsp36hT3BFi+1ss4n+/DmbqF8kcv60A7rTT/Idl5eCybsHkVtVBfVj6pVsGdRiCpHAhCH0BiVws5ZlKOa4CGiNqqL6sfnUQVjERVeKGrUoalFMWo4hrjxtHFTE9VGdWGFEPWjkooKUYVHEgfh+D6iqBzVhM2NqI3qovpROY6X43hZR408prD4XcNUDG391jUhmSHfl/6QciuX53+ndCcduU7D8dC8X4YmzMNtCsbTlRyaZIlDfLmGqfoP",
+      "debug_symbols": "rZfbbuIwFEX/Jc88+Nx84VdGVUVpWiFFgFIYaVTx73NM7CQg2aKhL2xCyIp9Ltv2d/Pevp0/X3f7j8NXs/7z3bz1u67bfb52h+3mtDvs9dfvxsQP4GZNl1UD1wtq1qgXGC9I78CqIVG56I/52ddT37bxDzOYvuK46dv9qVnvz123av5uuvP1T1/Hzf6qp02vd82qaffvqgr82HVt/HZZTU+b8qPiQ3rYohsfh8CPAmygBHAcRgCCPAoAMS4RQIKZIdyjCI+UZ+ExzKYB/gbBlVGQ93kUTItGgWTzRJABi6OwFQTYPArEWT78bTpcmRDISCIE4mkQ5OkG4SsIwzmlwcwSco8IZQSNBA3rFMu7qoJKMMmyzQgrvJABMDKQljECcGaEeYHfM6jMYHC5QxnNrDzdD4bhxqkEVx5GrTyZeSzP4IvlCZX6BIOCuU0MznJrww8gLGGEiDpFAVKzLaFc5iK23PFQKVL0PDqPfhdbnEwV4saIaDzAL5gMo8tdzyRUnEzNRCcbBjdrFzZ4g8BKmQpTHoZohiYG364mWLFRsSZHQyxwmSE1H83dosU2I8CjwXDgc7M4NKEYT3S1bgmEU7vMSuwur+iftnMMz/s5mecNneBZR48he9aNq1kRA2PL6r6h2G1UqVEerYM9LNnyiHM5GOKNFOuL7C+YTx0iZvR0LzPr+BnETRBLi0dCM4hbBnneS8WN/SKBYYmXOl3ns30Ee7dQvujlZrvrbzf9oNt5fS3YuHtUdUl90jAommjPqpBUjwSgDoGUlHXiOjKUpDZ6iKpL6pOG4Xky0VhUlReLmpRH8XdKGo8hfjhtXNUmdUl93E6ohkHZJIWkGFcQVRrex5xUktq4uVF1SX3SMKik+Uqar2DSxBOOi98lpqLfbd66NgYzxvu83+bY6uXp3zHfyUeuY3/Ytu/nvo15uKZgOF3poUmXOKKXS0zVfw==",
       "is_unconstrained": false,
       "name": "verify_private_authwit",
       "verification_key": "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"
@@ -9846,10 +9918,6 @@
     {
       "abi": {
         "error_types": {
-          "12913276134398371456": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
           "14990209321349310352": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
@@ -9861,10 +9929,6 @@
           "9530675838293881722": {
             "error_kind": "string",
             "string": "Writer did not write all data"
-          },
-          "992401946138144806": {
-            "error_kind": "string",
-            "string": "Attempted to read past end of BoundedVec"
           }
         },
         "parameters": [
@@ -9973,11 +10037,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "tZndbiI5EIXfhWsuXP6vvEo0GjEZMkJCJGKSlVZR3n3rpH2aJiNbLGRu4o9Af5Srq2wDb6uf2x+vv77vDo9Pv1d392+rH8fdfr/79X3/9LB52T0d7L9vK4c/2dfVXVjbqKu7bGNwbZQ2+jaGNsY2pjbmNpY21jY2X2y+2Hyx+ZK9rtiY7f+K0bfR/CKARLB3EISYC6EStEFxBCF4QiBEQiLQXGguNBeaK82V5kpzpbnSXGmuNFeaK82VZqVZaVaalWalWZu5OFyVAELwBLwmAzKhEOzdvQNoA3EEIXhCINi7e1wuiZAJhQBzAWgD7wgwK8DMAcH7QIiERMiEQqgEbYDanEAINAeaA80o0IC0oEInKASYESGK9ANQpRPgcsQc7cVRAPbiCGHUBskRLIwYAZ4QCJGQCJlQCDAjnqQNsiMIAWYElgMhEmCugEwohErQBmiQCYQAM2aKBpkgEhLBzAlJQINMUAlmTt4ADTKBEDwhECIhEWBGDtEgE1SCNkCDJCQKDZJQbGiQCQIBZmQDDTJBJhRCJegEFU00AcwV4AmBEAlY6RwgEwoBi50AtAHaKnuAEDwhELCEZgDMeAu01QSFUAnaAG01gRBgVkAgmLkgDLRVwXuhrSYwcwmAStAGaKsJhOAJgQBzBCRCJhQCzAmgDdBWEwgBV2Hu6K8JKgFXYRborwmEYPFUJBz9NUEkJEImFEIlmLkiLeivCYTgCZhpeX9fr7hJfn85brfYIxe7pu2lz5vj9vCyuju87vfr1T+b/evHi34/bw4f48vmaM/a224PP2004eNuvwW9r09Xu/6l4qNL7XLj6GeFOH8mkb4kYnH+UMRYZkE5v973rw+JMwilngKo+j9mgUpss0gpd2cR+5KUHaeRsg8nRZYzReorfMBe9KHwYZGKfHkMGhiDbZ/dGAYKOzwxm3Y+Kl1F7SvKnAhbyhf3o1w8jTLHkMqypj7FIIN76lXmXGpNnVyODcrSDk5CzzAqTFvbaKgxXnE/bdVmImx57Cdi4NBZof5UEfHyutbARGbnylU15eSk8H0FXtXtUc2sKtGyyOUnxaAupeBmTQo7JXQVOkimMAity6UmX27QyBicpK7CD9ZL7yMd3qfau6d+UJm2rs2pcEn6YYRRcc6OZNvWKYxwvn34YWU4PVWG6ztGq2Zkk/lcFsko1xWG9gujjO5JkPmexNBT+EEUOaU5F0njVVFIPm0g0o0iDFa9mObNuPTrIoy2c8kszyjqF3eknjtG9ZnmG5LCoirk8ii88IZYKWg/ijg6FxRupxJi6scxcIQSZd4DxPXjyH/XYWttnHOapYRur4VBjWqaDxi6rNE/HMNIwmkNtO9a+l0fB3Ua8unQF7t3ZmiIbLdwtnp9MgyqNLrApSe6xXntj3n40ZmP8/DJXxWFr/P6V3O/Rsvw6Dqv5FYm/XnkL8hFvjkX+eZc5NtzkdztuRg5LsvF0HBzLiz4Os8jy1XdfnEu0t91XJjPdHM+h3uScnu2y/rreNIv2JNG9Vm48qXo+qfY0UEjVB4T7BuA684qUeZTbFocQT8pcrj1rJJHu7NTdnsQ6e+JeVAXwed5I/HVX+mYp2K62neUWyt8mM+L6mJ0nPeFPZKXTfL5g14ZFGeOlYedHLV2PjSPDSXOB2kv1xhS8LMhxasMNcyGesVHf/tRK8/fw0j/M/PwtJbnT1eaJV934ls6Qr9DyhecL0q9fQ8YOS7rkKGhvwd8s4ebh93x7IfLd6iOu82P/bY9fHw9PCyeffn3mc/wh8/n49PD9ufrcQvT6ddP+3NfrbCr+m/rlX0DfG+n+LV1nD3CF/j3VXWtTr69I5b/AA==",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "offchain_receive"
     },
@@ -10075,10 +10139,6 @@
             "error_kind": "string",
             "string": "get_shared_secrets: response length does not match request length"
           },
-          "9183489621457545712": {
-            "error_kind": "string",
-            "string": "unrecognized delivery mode"
-          },
           "9530675838293881722": {
             "error_kind": "string",
             "string": "Writer did not write all data"
@@ -10120,11 +10180,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "sync_state"
     },
@@ -10518,5 +10578,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "5.0.0-rc.1"
+  "aztec_version": "5.0.0-rc.2"
 }