@aztec/standard-contracts 0.0.1-commit.a5db02d → 0.0.1-commit.b8a057fa

package/artifacts/PublicChecks.json

@@ -67,7 +67,7 @@
           "start": 4151
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/logging.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "103": {
@@ -85,7 +85,7 @@
           "start": 7724
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/macros/aztec/compute_note_hash_and_nullifier.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "104": {
@@ -123,7 +123,7 @@
           "start": 12880
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "109": {
@@ -153,7 +153,7 @@
           "start": 12254
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
       "source": "use crate::macros::internals_functions_generation::external_functions_registry::get_public_functions;\nuse crate::protocol::meta::utils::get_params_len_quote;\nuse crate::utils::cmap::CHashMap;\nuse super::functions::initialization_utils::EMIT_PUBLIC_INIT_NULLIFIER_FN_NAME;\nuse super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Minimum number of public functions that must share a parameter-type signature before we extract a shared\n/// unpack helper. See [compute_unpack_prelude] for the rationale behind the chosen value.\nglobal EXTRACTION_THRESHOLD: u32 = 4;\n\n/// Generates a `public_dispatch` function for an Aztec contract module `m`.\n///\n/// The generated function dispatches public calls based on selector to the appropriate contract function. If\n/// `generate_emit_public_init_nullifier` is true, it also handles dispatch to the macro-generated\n/// `__emit_public_init_nullifier` function.\n///\n/// Alongside `public_dispatch`, this also emits one `__aztec_nr_internals__unpack_arguments_<N>` helper per\n/// parameter-type signature shared by enough public functions; see [compute_unpack_prelude] for the extraction\n/// criterion.\npub comptime fn generate_public_dispatch(m: Module, generate_emit_public_init_nullifier: bool) -> Quoted {\n    let functions = get_public_functions(m);\n\n    let unit = get_type::<()>();\n\n    // Count how many public functions share each parameter-type signature, so we can decide which signatures are\n    // worth extracting into helpers.\n    let signature_counts = &mut CHashMap::<Quoted, u32>::new();\n    for function in functions {\n        let parameters = function.parameters();\n        if parameters.len() != 0 {\n            let key = signature_key(parameters);\n            let prior = signature_counts.get(key).unwrap_or(0);\n            signature_counts.insert(key, prior + 1);\n        }\n    }\n\n    let seen_selectors = &mut CHashMap::<Field, Quoted>::new();\n    let signature_to_helper_idx = &mut CHashMap::<Quoted, u32>::new();\n    // The helper function definitions, in the order they were created.\n    let unpack_helpers: &mut [Quoted] = &mut @[];\n\n    let mut ifs = functions.map(|function: FunctionDefinition| {\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let fn_name = function.name();\n        let selector: Field = compute_fn_selector(fn_name, parameters);\n\n        // Since function selectors are computed as the first 4 bytes of the hash of the function signature, it's\n        // possible to have collisions. With the following check, we ensure it doesn't happen within the same contract.\n        let existing_fn = seen_selectors.get(selector);\n        if existing_fn.is_some() {\n            let existing_fn = existing_fn.unwrap();\n            panic(\n                f\"Public function selector collision detected between functions '{fn_name}' and '{existing_fn}'\",\n            );\n        }\n        seen_selectors.insert(selector, fn_name);\n\n        let (unpack_prelude, call_args) = compute_unpack_prelude(\n            parameters,\n            signature_counts,\n            signature_to_helper_idx,\n            unpack_helpers,\n        );\n\n        // We call a function whose name is prefixed with `__aztec_nr_internals__`. This is necessary because the\n        // original function is intentionally made uncallable, preventing direct invocation within the contract.\n        // Instead, a new function with the same name, but prefixed by `__aztec_nr_internals__`, has been generated to\n        // be called here. For more details see the `process_functions` function.\n        let name = f\"__aztec_nr_internals__{fn_name}\".quoted_contents();\n        let call = quote { $name($call_args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                aztec::oracle::avm::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = aztec::protocol::traits::Serialize::serialize($call);\n                aztec::oracle::avm::avm_return(return_value.as_vector());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $unpack_prelude\n                $return_code\n            }\n        };\n        if_\n    });\n\n    // If we injected the auto-generated public function to emit the public initialization nullifier, then\n    // we'll also need to handle its dispatch.\n    if generate_emit_public_init_nullifier {\n        let name = EMIT_PUBLIC_INIT_NULLIFIER_FN_NAME;\n        let init_nullifier_selector: Field = compute_fn_selector(name, @[]);\n\n        ifs = ifs.push_back(\n            quote {\n                if selector == $init_nullifier_selector {\n                    $name();\n                    aztec::oracle::avm::avm_return([]);\n                }\n            },\n        );\n    }\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let helpers = (*unpack_helpers).join(quote {  });\n\n        let body = quote {\n            $helpers\n\n            // We mark this as public because our whole system depends on public functions having this attribute.\n            #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\n/// Canonical Quoted representation of a parameter list's types, used as the deduplication key for unpack helpers.\ncomptime fn signature_key(parameters: [(Quoted, Type)]) -> Quoted {\n    parameters\n        .map(|param: (Quoted, Type)| {\n            let param_type = param.1;\n            quote { $param_type }\n        })\n        .join(quote { , })\n}\n\n/// Builds the dispatch-arm prelude for a public function and the comma-separated arg list to pass through to the call.\n///\n/// If the function's signature reaches `EXTRACTION_THRESHOLD`, the prelude reuses (or creates) a shared\n/// `__aztec_nr_internals__unpack_arguments_<N>` helper. Otherwise the calldata read is inlined, matching the\n/// pre-extraction shape; this avoids paying the helper-call overhead on signatures that would not benefit from the\n/// shared body.\n///\n/// The real break-even depends on the size of the inlined boilerplate at each call site (which scales with the\n/// parameter types' `stream_deserialize` cost), not just the share count: a signature with one `Field` arg inlines\n/// to a few opcodes per site, while a signature like `(AztecAddress, U128, PartialUintNote)` inlines into many. For\n/// now we approximate that with a single share-count threshold, which is the simplest knob that keeps the macro\n/// readable. If we ever want to be more precise we can size each helper against its per-site savings.\ncomptime fn compute_unpack_prelude(\n    parameters: [(Quoted, Type)],\n    signature_counts: &mut CHashMap<Quoted, u32>,\n    signature_to_helper_idx: &mut CHashMap<Quoted, u32>,\n    unpack_helpers: &mut [Quoted],\n) -> (Quoted, Quoted) {\n    if parameters.len() == 0 {\n        (quote {}, quote {})\n    } else {\n        let sig_key = signature_key(parameters);\n        let count = signature_counts.get(sig_key).unwrap_or(0);\n        let shared = count >= EXTRACTION_THRESHOLD;\n\n        let mut arg_names: [Quoted] = @[];\n        for parameter_index in 0..parameters.len() {\n            let arg_name = f\"arg{parameter_index}\".quoted_contents();\n            arg_names = arg_names.push_back(arg_name);\n        }\n        let args = arg_names.join(quote { , });\n\n        let prelude = if shared {\n            let existing_idx = signature_to_helper_idx.get(sig_key);\n            let helper_idx = if existing_idx.is_some() {\n                existing_idx.unwrap()\n            } else {\n                let new_idx = (*unpack_helpers).len();\n                signature_to_helper_idx.insert(sig_key, new_idx);\n                let helper_def = build_unpack_helper(new_idx, parameters);\n                *unpack_helpers = (*unpack_helpers).push_back(helper_def);\n                new_idx\n            };\n            let helper_name = f\"__aztec_nr_internals__unpack_arguments_{helper_idx}\".quoted_contents();\n            if parameters.len() == 1 {\n                quote { let arg0 = $helper_name(); }\n            } else {\n                quote { let ($args) = $helper_name(); }\n            }\n        } else {\n            inline_unpack(parameters)\n        };\n\n        (prelude, args)\n    }\n}\n\n/// Inlined calldata read + per-parameter `stream_deserialize` for signatures that are not worth extracting.\ncomptime fn inline_unpack(parameters: [(Quoted, Type)]) -> Quoted {\n    let params_len_quote = get_params_len_quote(parameters);\n    let initial_read = quote {\n        let input_calldata: [Field; $params_len_quote] = aztec::oracle::avm::calldata_copy(1, $params_len_quote);\n        let mut reader = aztec::protocol::utils::reader::Reader::new(input_calldata);\n    };\n\n    let mut read_quotes: [Quoted] = @[];\n    for parameter_index in 0..parameters.len() {\n        let arg_name = f\"arg{parameter_index}\".quoted_contents();\n        let param_type = parameters[parameter_index].1;\n        read_quotes = read_quotes.push_back(\n            quote {\n                let $arg_name: $param_type = aztec::protocol::traits::Deserialize::stream_deserialize(&mut reader);\n            },\n        );\n    }\n    let reads = read_quotes.join(quote { });\n\n    quote {\n        $initial_read\n        $reads\n    }\n}\n\n/// Emits the `#[inline_never]` helper that reads calldata for one specific parameter-type signature.\n///\n/// Returns a single value when there is only one parameter, and a tuple when there are several. Marked\n/// `#[inline_never]` (and therefore `unconstrained`) so each entry point can call into the same compiled body.\ncomptime fn build_unpack_helper(idx: u32, parameters: [(Quoted, Type)]) -> Quoted {\n    let helper_name = f\"__aztec_nr_internals__unpack_arguments_{idx}\".quoted_contents();\n    let params_len_quote = get_params_len_quote(parameters);\n\n    // The initial calldata_copy offset is 1 to skip the Field selector. The expected calldata is the serialization\n    // of:\n    // - FunctionSelector: the selector of the function intended to dispatch\n    // - Parameters: the parameters of the function intended to dispatch\n    // That is, exactly what is expected for a call to the target function, but with a selector added at the\n    // beginning.\n    let initial_read = quote {\n        let input_calldata: [Field; $params_len_quote] = aztec::oracle::avm::calldata_copy(1, $params_len_quote);\n        let mut reader = aztec::protocol::utils::reader::Reader::new(input_calldata);\n    };\n\n    let mut read_quotes: [Quoted] = @[];\n    let mut arg_quotes: [Quoted] = @[];\n    let mut type_quotes: [Quoted] = @[];\n    for parameter_index in 0..parameters.len() {\n        let arg_name = f\"arg{parameter_index}\".quoted_contents();\n        let param_type = parameters[parameter_index].1;\n        read_quotes = read_quotes.push_back(\n            quote {\n                let $arg_name: $param_type = aztec::protocol::traits::Deserialize::stream_deserialize(&mut reader);\n            },\n        );\n        arg_quotes = arg_quotes.push_back(arg_name);\n        type_quotes = type_quotes.push_back(quote { $param_type });\n    }\n    let reads = read_quotes.join(quote { });\n    let return_args = arg_quotes.join(quote { , });\n\n    if parameters.len() == 1 {\n        let only_type = parameters[0].1;\n        quote {\n            #[inline_never]\n            #[contract_library_method]\n            unconstrained fn $helper_name() -> $only_type {\n                $initial_read\n                $reads\n                arg0\n            }\n        }\n    } else {\n        let return_types = type_quotes.join(quote { , });\n        quote {\n            #[inline_never]\n            #[contract_library_method]\n            unconstrained fn $helper_name() -> ($return_types) {\n                $initial_read\n                $reads\n                ($return_args)\n            }\n        }\n    }\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
     },
     "120": {
@@ -171,304 +171,50 @@
           "start": 4225
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/public.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/public.nr",
       "source": "use crate::macros::{\n    internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},\n    utils::{\n        fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self, is_fn_view,\n        module_has_initializer, module_has_storage,\n    },\n};\n\n/// Emits a per-contract helper that creates the `self` value from a `PublicContext` already in scope.\n///\n/// This is the shared helper used by both:\n/// - public external functions, via [`generate_public_self_creator`], which constructs a fresh `PublicContext` from\n///   `calldata_copy` and then delegates to this helper; and\n/// - public internal functions and `#[contract_library_method]` bodies, which already receive `context` as a\n///   parameter and call this helper directly to skip the `calldata_copy` step.\npub(crate) comptime fn generate_public_self_creator_from_context(m: Module) -> Quoted {\n    let (storage_type, storage_init) = if module_has_storage(m) {\n        (quote { Storage<aztec::context::PublicContext> }, quote { let storage = Storage::init(context); })\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelfPublic requires\n        // a storage struct in its constructor. Using an Option type would lead to worse developer experience and\n        // higher constraint counts so we use the unit type `()` instead.\n        (quote { () }, quote { let storage = (); })\n    };\n\n    quote {\n        #[contract_library_method]\n        unconstrained fn __aztec_nr_internals__create_public_self_from_context(context: aztec::context::PublicContext) -> aztec::contract_self::ContractSelfPublic<$storage_type, CallSelf<aztec::context::PublicContext>, CallSelfStatic<aztec::context::PublicContext>, CallInternal<aztec::context::PublicContext>> {\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<aztec::context::PublicContext> = CallSelf { address: self_address, context };\n            let call_self_static: CallSelfStatic<aztec::context::PublicContext> = CallSelfStatic { address: self_address, context };\n            let internal: CallInternal<aztec::context::PublicContext> = CallInternal { context };\n            aztec::contract_self::ContractSelfPublic::new(context, storage, call_self, call_self_static, internal)\n        }\n    }\n}\n\n/// Generates the per-contract helper that builds public `self`.\n///\n/// Each public external function calls this helper instead of inlining the construction, so the same preamble does not\n/// appear duplicated in every public function body. We let Noir's inliner decide whether to inline the helper at each\n/// call site rather than forcing it via macro expansion.\n///\n/// The helper is generic over the calldata length `N` because `PublicContext::new` takes a closure that reads `N`\n/// fields from calldata. Noir monomorphizes one copy per distinct `N`, so public functions with the same number of\n/// serialized args reuse the same compiled code.\npub(crate) comptime fn generate_public_self_creator(m: Module) -> Quoted {\n    let storage_type = if module_has_storage(m) {\n        quote { Storage<aztec::context::PublicContext> }\n    } else {\n        quote { () }\n    };\n\n    quote {\n        #[contract_library_method]\n        unconstrained fn __aztec_nr_internals__create_public_self<let N: u32>() -> aztec::contract_self::ContractSelfPublic<$storage_type, CallSelf<aztec::context::PublicContext>, CallSelfStatic<aztec::context::PublicContext>, CallInternal<aztec::context::PublicContext>> {\n            // Unlike in the private case, in public the `context` does not need to receive the hash of the original\n            // params.\n            let context = aztec::context::PublicContext::new(|| {\n                // We start from 1 because we skip the selector for the dispatch function.\n                let serialized_args : [Field; N] = aztec::oracle::avm::calldata_copy(1, N);\n                aztec::hash::hash_args(serialized_args)\n            });\n            __aztec_nr_internals__create_public_self_from_context(context)\n        }\n    }\n}\n\npub(crate) comptime fn generate_public_external(f: FunctionDefinition) -> Quoted {\n    let module_has_initializer = module_has_initializer(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n\n    let args_len_quote = if original_params.len() == 0 {\n        // If the function has no parameters, we set the args_len to 0.\n        quote { 0 }\n    } else {\n        // The following will give us <type_of_struct_member_1 as Serialize>::N + <type_of_struct_member_2 as\n        // Serialize>::N + ...\n        original_params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n            <$param_type as $crate::protocol::traits::Serialize>::N\n        }\n            })\n            .join(quote {+})\n    };\n\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = __aztec_nr_internals__create_public_self::<$args_len_quote>();\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.is_static_call(), $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (\n            quote {\n                aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_public(self.context);\n            },\n            quote {\n                aztec::macros::functions::initialization_utils::mark_as_initialized_from_public_initializer(self.context);\n            },\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 & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_public(self.context); }\n    } else {\n        quote {}\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, false)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $contract_self_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $authorize_once_check\n    };\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        $mark_as_initialized\n    };\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n    let body = f.body();\n    let return_type = f.return_type();\n\n    // New function parameters are the same as the original function's ones.\n    let params = original_params.map(|(param_name, param_type)| quote { $param_name: $param_type }).join(quote {, });\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    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n        $abi_relevant_attributes\n        unconstrained fn $fn_name($params) -> pub $return_type {\n            $to_prepend\n            $body\n            $to_append\n        }\n    }\n}\n"
     },
     "134": {
       "function_locations": [
-        {
-          "name": "protect_from_forgery",
-          "start": 4924
-        },
-        {
-          "name": "forgery_protected_eph_pk",
-          "start": 5936
-        },
         {
           "name": "get_existing_app_siloed_handshake_secrets",
-          "start": 6951
+          "start": 3756
         },
         {
           "name": "create_non_interactive_handshake",
-          "start": 7819
+          "start": 4624
         },
         {
           "name": "create_interactive_handshake",
-          "start": 8606
+          "start": 5411
         },
         {
           "name": "get_handshake_secrets",
-          "start": 9189
+          "start": 5990
         },
         {
           "name": "fetch_handshake_page",
-          "start": 10884
+          "start": 7311
         },
         {
           "name": "test::get_handshake_secrets_returns_secrets_from_single_page",
-          "start": 11734
+          "start": 8161
         },
         {
           "name": "test::get_handshake_secrets_fetches_multiple_pages",
-          "start": 13389
+          "start": 9808
         },
         {
-          "name": "test::get_handshake_secrets_returns_empty_when_recipient_keys_not_held",
-          "start": 15712
+          "name": "test::get_handshake_secrets_returns_empty_when_scope_keys_not_held",
+          "start": 12119
         },
         {
           "name": "test::mock_get_shared_secrets",
-          "start": 16538
-        }
-      ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/delivery/handshake.nr",
-      "source": "use crate::protocol::point::EmbeddedCurvePoint;\nuse crate::protocol::traits::{Deserialize, Serialize};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, multi_scalar_mul};\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,\n        address::AztecAddress,\n        constants::DOM_SEP__HANDSHAKE_FORGERY_PROTECTION,\n        hash::{poseidon2_hash_with_separator, sha256_to_field},\n        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\n/// The app-siloed handshake secrets the registry returns for a `(sender, recipient)` pair.\n#[derive(Deserialize, Eq, Serialize)]\npub struct AppSiloedHandshakeSecrets {\n    /// The app-siloed shared secret, used to derive the recipient's discovery tag. The recipient can reconstruct\n    /// it from the handshake's public ephemeral key via ECDH.\n    pub shared: Field,\n    /// The app-siloed sender-only secret, folded into the constrained-delivery sequence nullifier so only the\n    /// sender can advance a sequence. The recipient cannot reconstruct it: it derives from a random secret stored\n    /// only in the sender's handshake note and never transmitted.\n    pub sender_only: Field,\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_SECRETS_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"get_app_siloed_secrets((Field),(Field))\") };\npub global NON_INTERACTIVE_HANDSHAKE_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"non_interactive_handshake((Field),(Field))\") };\npub global INTERACTIVE_HANDSHAKE_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"interactive_handshake((Field),(Field))\") };\npub global GET_NON_INTERACTIVE_HANDSHAKES_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"get_non_interactive_handshakes((Field),u32)\") };\n\n/// Protects a handshake's shared secret from recipient forgery.\n///\n/// The handshake's ECDH shared secret is symmetric: `S = eph_sk * recipient_pub`, where `(eph_sk, eph_pk)` is\n/// the sender's ephemeral key pair, also equals `recipient_priv * eph_pk`. The recipient recomputing `S` this\n/// way is normal: it is how they derive the handshake's tags when scanning. The attack is minting a second\n/// handshake with the same secret: the ephemeral key is unconstrained, so a malicious recipient can register\n/// its own handshake crafted to land on `S` again, with a different sender-only secret, and emit logs under\n/// the honest handshake's constrained-delivery tag. That breaks the invariant that a constrained-delivery log\n/// sequence is tied to a single sender: by colliding on the tag it blocks the honest sender, who can no longer\n/// emit the next note in their sequence.\n///\n/// The protection multiplies `S` by the scalar `k = hash(eph_pk, recipient_point)`: a forgery must announce a\n/// different `eph_pk`, so the protected secrets diverge. The result is still a point and silos like `S`.\n///\n/// The recipient point must be part of `k`: were `k` independent of it, an attacker choosing the fake\n/// recipient point as a multiple of the honest protected secret could solve for the multiplier that makes the\n/// forged secret land exactly on it.\n///\n/// Concretely, on the sender's side:\n///   S  = eph_sk * recipient_point\n///   S' = protect_from_forgery(S, eph_pk, recipient_point) = k * S\n///\n/// See [`forgery_protected_eph_pk`] for how that arrives at the same `S'`.\npub fn protect_from_forgery(\n    secret: EmbeddedCurvePoint,\n    eph_pk: EmbeddedCurvePoint,\n    recipient_point: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    let scalar = poseidon2_hash_with_separator(\n        [eph_pk.x, eph_pk.y, recipient_point.x, recipient_point.y],\n        DOM_SEP__HANDSHAKE_FORGERY_PROTECTION,\n    );\n    multi_scalar_mul([secret], [EmbeddedCurveScalar::from_field(scalar)])\n}\n\n/// Applies the forgery protection to a discovered ephemeral key.\n///\n/// The recipient never holds the raw `S` (its side of the ECDH happens inside PXE), so it cannot call\n/// [`protect_from_forgery`] on the secret directly. The protection is a scalar multiplication and therefore\n/// commutes through ECDH: protecting the ephemeral key before the shared-secret derivation yields the same\n/// protected secret `S'` the sender stored:\n///\n///   protected_eph_pk = forgery_protected_eph_pk(eph_pk, recipient_point) = k * eph_pk\n///   recipient_priv * protected_eph_pk = recipient_priv * (k * eph_pk) = k * (recipient_priv * eph_pk) = k * S = S'\npub fn forgery_protected_eph_pk(eph_pk: EmbeddedCurvePoint, recipient_point: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n    // Passing `eph_pk` twice is deliberate: it is both the point being multiplied and an input to the scalar\n    // `k`, yielding `k * eph_pk` (see the algebra on [`protect_from_forgery`]).\n    protect_from_forgery(eph_pk, eph_pk, recipient_point)\n}\n\n/// Reads the existing app-siloed handshake secrets for `(sender, recipient)` from the registry.\n///\n/// Returns `None` when no handshake has been registered for the pair yet, in which case the caller decides how to\n/// source a tagging secret (see [`super::tag::derive_log_tag`]).\n///\n/// ## Batching\n///\n/// This reads committed state, so within a single transaction multiple sends cannot see each other's pending\n/// handshake. A brand-new recipient therefore needs one landed transaction to establish the handshake before further\n/// sends can be batched onto it.\npub(crate) unconstrained fn get_existing_app_siloed_handshake_secrets(\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> Option<AppSiloedHandshakeSecrets> {\n    let returns = call_utility_function(\n        registry,\n        GET_APP_SILOED_SECRETS_SELECTOR,\n        [sender.to_field(), recipient.to_field()],\n    );\n    Deserialize::deserialize(returns)\n}\n\n/// Establishes a non-interactive handshake for `(sender, recipient)` and returns its app-siloed secrets.\n///\n/// The registry inserts a fresh handshake note and returns the app-siloed secrets. The constrained return value is the\n/// source of truth for the secrets, so constrained delivery anchoring a freshly bootstrapped handshake needs no\n/// separate call to the registry's `validate_handshake`.\n///\n/// Any handshake already registered for the pair is overwritten.\npub(crate) fn create_non_interactive_handshake(\n    context: &mut PrivateContext,\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> AppSiloedHandshakeSecrets {\n    context\n        .call_private_function(registry, NON_INTERACTIVE_HANDSHAKE_SELECTOR, [sender.to_field(), recipient.to_field()])\n        .get_preimage()\n}\n\n/// Establishes an interactive handshake for `(sender, recipient)` and returns its app-siloed secrets.\n///\n/// As with [`create_non_interactive_handshake`], the constrained return value is the source of truth for the\n/// secrets, so constrained delivery anchoring a freshly bootstrapped handshake needs no separate call to the\n/// registry's `validate_handshake`.\n///\n/// Any handshake already registered for the pair is overwritten.\npub(crate) fn create_interactive_handshake(\n    context: &mut PrivateContext,\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> AppSiloedHandshakeSecrets {\n    context\n        .call_private_function(registry, INTERACTIVE_HANDSHAKE_SELECTOR, [sender.to_field(), recipient.to_field()])\n        .get_preimage()\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    recipient: AztecAddress,\n) -> EphemeralArray<ProvidedSecret> {\n    let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);\n\n    // Each ephemeral key gets the forgery protection applied (see [`forgery_protected_eph_pk`]) so the oracle's\n    // ECDH yields the protected secret the sender stored.\n    let protected_eph_pks: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(HANDSHAKE_EPH_PKS_SLOT);\n    let recipient_point = recipient.to_address_point().expect(f\"recipient address is not on the curve\").inner;\n\n    let mut page_offset: u32 = 0;\n    let mut has_more = true;\n    while has_more {\n        let page = fetch_handshake_page(recipient, page_offset);\n\n        for j in 0..page.items.len() {\n            protected_eph_pks.push(forgery_protected_eph_pk(page.items.get(j).eph_pk, recipient_point));\n        }\n\n        page_offset += page.items.len();\n        has_more = page_offset < page.total_count;\n    }\n\n    if protected_eph_pks.len() > 0 {\n        let secrets = get_shared_secrets(recipient, protected_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_non_interactive_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_NON_INTERACTIVE_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 recipient = 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, recipient);\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 recipient = 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, recipient);\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    #[test]\n    unconstrained fn get_handshake_secrets_returns_empty_when_recipient_keys_not_held() {\n        let env = TestEnvironment::new();\n        let recipient = AztecAddress::from_field(1);\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            let mut items = BoundedVec::new();\n            items.push(DiscoveredHandshake { eph_pk: point_from_x_coord(1).unwrap() });\n            let page = HandshakePage { items, total_count: 1 };\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page.serialize());\n\n            let empty: [Field; 0] = [];\n            mock_get_shared_secrets(empty);\n\n            let secrets = get_handshake_secrets(contract_address, recipient);\n            assert_eq(secrets.len(), 0);\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"
-    },
-    "14": {
-      "function_locations": [
-        {
-          "name": "EmbeddedCurvePoint::new",
-          "start": 510
-        },
-        {
-          "name": "EmbeddedCurvePoint::double",
-          "start": 705
-        },
-        {
-          "name": "EmbeddedCurvePoint::point_at_infinity",
-          "start": 877
-        },
-        {
-          "name": "EmbeddedCurvePoint::generator",
-          "start": 1018
-        },
-        {
-          "name": "EmbeddedCurvePoint::is_infinite",
-          "start": 1329
-        },
-        {
-          "name": "<impl Add for EmbeddedCurvePoint>::add",
-          "start": 1576
-        },
-        {
-          "name": "<impl Sub for EmbeddedCurvePoint>::sub",
-          "start": 1793
-        },
-        {
-          "name": "<impl Neg for EmbeddedCurvePoint>::neg",
-          "start": 2051
-        },
-        {
-          "name": "<impl Eq for EmbeddedCurvePoint>::eq",
-          "start": 2245
-        },
-        {
-          "name": "<impl Hash for EmbeddedCurvePoint>::hash",
-          "start": 2415
-        },
-        {
-          "name": "EmbeddedCurveScalar::new",
-          "start": 2969
-        },
-        {
-          "name": "EmbeddedCurveScalar::from_field",
-          "start": 3154
-        },
-        {
-          "name": "<impl Eq for EmbeddedCurveScalar>::eq",
-          "start": 3342
-        },
-        {
-          "name": "<impl Hash for EmbeddedCurveScalar>::hash",
-          "start": 3525
-        },
-        {
-          "name": "multi_scalar_mul",
-          "start": 4201
-        },
-        {
-          "name": "fixed_base_scalar_mul",
-          "start": 4416
-        },
-        {
-          "name": "multi_scalar_mul_array_return",
-          "start": 4699
-        },
-        {
-          "name": "embedded_curve_add",
-          "start": 5154
-        },
-        {
-          "name": "embedded_curve_add_array_return",
-          "start": 5439
-        },
-        {
-          "name": "tests::hash_point",
-          "start": 5888
-        },
-        {
-          "name": "tests::hash_scalar",
-          "start": 6064
-        },
-        {
-          "name": "tests::point_new_sets_coordinates",
-          "start": 6236
-        },
-        {
-          "name": "tests::point_at_infinity_is_origin",
-          "start": 6395
-        },
-        {
-          "name": "tests::generator_has_documented_coordinates",
-          "start": 6579
-        },
-        {
-          "name": "tests::is_infinite_only_true_for_origin",
-          "start": 6803
-        },
-        {
-          "name": "tests::points_with_same_coords_are_equal",
-          "start": 7126
-        },
-        {
-          "name": "tests::points_with_different_coords_are_unequal",
-          "start": 7318
-        },
-        {
-          "name": "tests::neg_negates_y_coordinate",
-          "start": 7580
-        },
-        {
-          "name": "tests::neg_is_involution",
-          "start": 7768
-        },
-        {
-          "name": "tests::add_with_point_at_infinity_is_identity",
-          "start": 7913
-        },
-        {
-          "name": "tests::add_of_two_infinities_is_infinity",
-          "start": 8147
-        },
-        {
-          "name": "tests::add_with_negation_is_point_at_infinity",
-          "start": 8318
-        },
-        {
-          "name": "tests::add_is_commutative",
-          "start": 8458
-        },
-        {
-          "name": "tests::add_is_associative",
-          "start": 8620
-        },
-        {
-          "name": "tests::sub_of_a_point_with_itself_is_infinity",
-          "start": 8841
-        },
-        {
-          "name": "tests::sub_with_point_at_infinity_is_identity",
-          "start": 8998
-        },
-        {
-          "name": "tests::sub_inverts_add",
-          "start": 9183
-        },
-        {
-          "name": "tests::double_equals_self_plus_self",
-          "start": 9394
-        },
-        {
-          "name": "tests::double_of_point_at_infinity_is_infinity",
-          "start": 9551
-        },
-        {
-          "name": "tests::embedded_curve_add_matches_add_operator",
-          "start": 9701
-        },
-        {
-          "name": "tests::point_hash_is_consistent_for_equal_points",
-          "start": 9905
-        },
-        {
-          "name": "tests::point_hash_differs_for_distinct_points",
-          "start": 10117
-        },
-        {
-          "name": "tests::scalar_new_sets_limbs",
-          "start": 10515
-        },
-        {
-          "name": "tests::scalars_with_same_limbs_are_equal",
-          "start": 10683
-        },
-        {
-          "name": "tests::scalars_with_different_limbs_are_unequal",
-          "start": 10877
-        },
-        {
-          "name": "tests::scalar_from_field_decomposes_zero",
-          "start": 11098
-        },
-        {
-          "name": "tests::scalar_from_field_decomposes_small_value",
-          "start": 11256
-        },
-        {
-          "name": "tests::scalar_from_field_decomposes_two_pow_128",
-          "start": 11455
-        },
-        {
-          "name": "tests::scalar_hash_is_consistent_for_equal_scalars",
-          "start": 11645
-        },
-        {
-          "name": "tests::scalar_hash_differs_for_distinct_scalars",
-          "start": 11865
-        },
-        {
-          "name": "tests::msm_with_scalar_one_returns_point",
-          "start": 12288
-        },
-        {
-          "name": "tests::msm_with_scalar_zero_returns_infinity",
-          "start": 12507
-        },
-        {
-          "name": "tests::msm_with_scalar_two_doubles_point",
-          "start": 12732
-        },
-        {
-          "name": "tests::msm_sums_terms",
           "start": 12937
-        },
-        {
-          "name": "tests::msm_with_opposite_terms_cancels",
-          "start": 13167
-        },
-        {
-          "name": "tests::msm_skips_point_at_infinity",
-          "start": 13393
-        },
-        {
-          "name": "tests::msm_skips_zero_scalar",
-          "start": 13665
-        },
-        {
-          "name": "tests::fixed_base_scalar_mul_with_one_returns_generator",
-          "start": 13955
-        },
-        {
-          "name": "tests::fixed_base_scalar_mul_with_zero_returns_infinity",
-          "start": 14164
-        },
-        {
-          "name": "tests::fixed_base_scalar_mul_matches_msm_on_generator",
-          "start": 14351
         }
       ],
-      "path": "std/embedded_curve_ops.nr",
-      "source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Create a new point using the provided (x, y) pair\n    pub fn new(x: Field, y: Field) -> Self {\n        EmbeddedCurvePoint { x, y }\n    }\n\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0 }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n        }\n    }\n\n    /// True if this point is the point at infinity\n    pub fn is_infinite(self) -> bool {\n        (self.x == 0) & (self.y == 0)\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.x == b.x) & (self.y == b.y)\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.x.hash(state);\n        self.y.hash(state);\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    /// Create a new scalar using the provided (lo, hi) pair\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    /// Create a scalar from the given bn254 field value\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n/// Computes a multi scalar multiplication over the embedded curve.\n/// For bn254, We have Grumpkin.\n///\n/// The embedded curve being used is decided by the\n/// underlying proof system.\n///\n/// IMPORTANT: Prefer `multi_scalar_mul()` over repeated `embedded_curve_add()`\n/// for adding multiple points. This is significantly more efficient.\n/// For adding exactly 2 points, use `embedded_curve_add()` directly.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// Elliptic curve addition\n/// IMPORTANT: this function is expected to perform a full addition in order to handle all corner cases:\n/// - points on the curve\n/// - point doubling\n/// - point at infinity\n/// As a result, you may not get optimal performance, depending on the assumptions of your inputs.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::default::Default;\n    use crate::embedded_curve_ops::{\n        embedded_curve_add, EmbeddedCurvePoint, EmbeddedCurveScalar, fixed_base_scalar_mul,\n        multi_scalar_mul,\n    };\n    use crate::field::bn254::TWO_POW_128;\n    use crate::hash::Hash;\n    use crate::hash::Hasher;\n    use crate::hash::poseidon2::Poseidon2Hasher;\n\n    fn hash_point(p: EmbeddedCurvePoint) -> Field {\n        let mut hasher: Poseidon2Hasher = Default::default();\n        p.hash(&mut hasher);\n        hasher.finish()\n    }\n\n    fn hash_scalar(s: EmbeddedCurveScalar) -> Field {\n        let mut hasher: Poseidon2Hasher = Default::default();\n        s.hash(&mut hasher);\n        hasher.finish()\n    }\n\n    #[test]\n    fn point_new_sets_coordinates() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        assert_eq(p.x, 3);\n        assert_eq(p.y, 5);\n    }\n\n    #[test]\n    fn point_at_infinity_is_origin() {\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(inf.x, 0);\n        assert_eq(inf.y, 0);\n    }\n\n    #[test]\n    fn generator_has_documented_coordinates() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(g.x, 1);\n        assert_eq(g.y, 17631683881184975370165255887551781615748388533673675138860);\n    }\n\n    #[test]\n    fn is_infinite_only_true_for_origin() {\n        assert(EmbeddedCurvePoint::point_at_infinity().is_infinite());\n        assert(!EmbeddedCurvePoint::generator().is_infinite());\n        assert(!EmbeddedCurvePoint::new(1, 0).is_infinite());\n        assert(!EmbeddedCurvePoint::new(0, 1).is_infinite());\n    }\n\n    #[test]\n    fn points_with_same_coords_are_equal() {\n        let p = EmbeddedCurvePoint::new(7, 11);\n        let q = EmbeddedCurvePoint::new(7, 11);\n        assert_eq(p, q);\n    }\n\n    #[test]\n    fn points_with_different_coords_are_unequal() {\n        let p = EmbeddedCurvePoint::new(7, 11);\n        assert(p != EmbeddedCurvePoint::new(7, 12));\n        assert(p != EmbeddedCurvePoint::new(8, 11));\n        assert(p != EmbeddedCurvePoint::new(8, 12));\n    }\n\n    #[test]\n    fn neg_negates_y_coordinate() {\n        let g = EmbeddedCurvePoint::generator();\n        let neg_g = -g;\n        assert_eq(neg_g.x, g.x);\n        assert_eq(neg_g.y, -g.y);\n    }\n\n    #[test]\n    fn neg_is_involution() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(--g, g);\n    }\n\n    #[test]\n    fn add_with_point_at_infinity_is_identity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(g + inf, g);\n        assert_eq(inf + g, g);\n    }\n\n    #[test]\n    fn add_of_two_infinities_is_infinity() {\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert((inf + inf).is_infinite());\n    }\n\n    #[test]\n    fn add_with_negation_is_point_at_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        assert((g + (-g)).is_infinite());\n    }\n\n    #[test]\n    fn add_is_commutative() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq(g + g2, g2 + g);\n    }\n\n    #[test]\n    fn add_is_associative() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        let g3 = g + g2;\n        assert_eq((g + g2) + g3, g + (g2 + g3));\n    }\n\n    #[test]\n    fn sub_of_a_point_with_itself_is_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        assert((g - g).is_infinite());\n    }\n\n    #[test]\n    fn sub_with_point_at_infinity_is_identity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(g - inf, g);\n    }\n\n    #[test]\n    fn sub_inverts_add() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq((g + g2) - g2, g);\n        assert_eq((g + g2) - g, g2);\n    }\n\n    #[test]\n    fn double_equals_self_plus_self() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(g.double(), g + g);\n    }\n\n    #[test]\n    fn double_of_point_at_infinity_is_infinity() {\n        assert(EmbeddedCurvePoint::point_at_infinity().double().is_infinite());\n    }\n\n    #[test]\n    fn embedded_curve_add_matches_add_operator() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq(embedded_curve_add(g, g2), g + g2);\n    }\n\n    #[test]\n    fn point_hash_is_consistent_for_equal_points() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        let q = EmbeddedCurvePoint::new(3, 5);\n        assert_eq(hash_point(p), hash_point(q));\n    }\n\n    #[test]\n    fn point_hash_differs_for_distinct_points() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(3, 7)));\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(4, 5)));\n        // Distinguishes (x, y) from (y, x) - order of writes matters.\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(5, 3)));\n    }\n\n    #[test]\n    fn scalar_new_sets_limbs() {\n        let s = EmbeddedCurveScalar::new(3, 5);\n        assert_eq(s.lo, 3);\n        assert_eq(s.hi, 5);\n    }\n\n    #[test]\n    fn scalars_with_same_limbs_are_equal() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        let t = EmbeddedCurveScalar::new(7, 11);\n        assert_eq(s, t);\n    }\n\n    #[test]\n    fn scalars_with_different_limbs_are_unequal() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        assert(s != EmbeddedCurveScalar::new(7, 12));\n        assert(s != EmbeddedCurveScalar::new(8, 11));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_zero() {\n        assert_eq(EmbeddedCurveScalar::from_field(0), EmbeddedCurveScalar::new(0, 0));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_small_value() {\n        let s = EmbeddedCurveScalar::from_field(0x1234567890);\n        assert_eq(s, EmbeddedCurveScalar::new(0x1234567890, 0));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_two_pow_128() {\n        let s = EmbeddedCurveScalar::from_field(TWO_POW_128);\n        assert_eq(s, EmbeddedCurveScalar::new(0, 1));\n    }\n\n    #[test]\n    fn scalar_hash_is_consistent_for_equal_scalars() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        let t = EmbeddedCurveScalar::new(7, 11);\n        assert_eq(hash_scalar(s), hash_scalar(t));\n    }\n\n    #[test]\n    fn scalar_hash_differs_for_distinct_scalars() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(7, 12)));\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(8, 11)));\n        // Distinguishes (lo, hi) from (hi, lo) - limb order matters.\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(11, 7)));\n    }\n\n    #[test]\n    fn msm_with_scalar_one_returns_point() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([g], [one]), g);\n    }\n\n    #[test]\n    fn msm_with_scalar_zero_returns_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert(multi_scalar_mul([g], [zero]).is_infinite());\n    }\n\n    #[test]\n    fn msm_with_scalar_two_doubles_point() {\n        let g = EmbeddedCurvePoint::generator();\n        let two = EmbeddedCurveScalar::new(2, 0);\n        assert_eq(multi_scalar_mul([g], [two]), g.double());\n    }\n\n    #[test]\n    fn msm_sums_terms() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([g, g], [one, one]), g.double());\n    }\n\n    #[test]\n    fn msm_with_opposite_terms_cancels() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert(multi_scalar_mul([g, -g], [one, one]).is_infinite());\n    }\n\n    #[test]\n    fn msm_skips_point_at_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([inf, g], [one, one]), g);\n    }\n\n    #[test]\n    fn msm_skips_zero_scalar() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert_eq(multi_scalar_mul([g, g], [zero, one]), g);\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_with_one_returns_generator() {\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(fixed_base_scalar_mul(one), EmbeddedCurvePoint::generator());\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_with_zero_returns_infinity() {\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert(fixed_base_scalar_mul(zero).is_infinite());\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_matches_msm_on_generator() {\n        let s = EmbeddedCurveScalar::new(2, 0);\n        assert_eq(\n            fixed_base_scalar_mul(s),\n            multi_scalar_mul([EmbeddedCurvePoint::generator()], [s]),\n        );\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/messages/delivery/handshake.nr",
+      "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\n/// The app-siloed handshake secrets the registry returns for a `(sender, recipient)` pair.\n#[derive(Deserialize, Eq, Serialize)]\npub struct AppSiloedHandshakeSecrets {\n    /// The app-siloed shared secret, used to derive the recipient's discovery tag. The recipient can reconstruct\n    /// it from the handshake's public ephemeral key via ECDH.\n    pub shared: Field,\n    /// The app-siloed sender-only secret, folded into the constrained-delivery sequence nullifier so only the\n    /// sender can advance a sequence. The recipient cannot reconstruct it: it derives from a random secret stored\n    /// only in the sender's handshake note and never transmitted.\n    pub sender_only: Field,\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_SECRETS_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"get_app_siloed_secrets((Field),(Field))\") };\npub global NON_INTERACTIVE_HANDSHAKE_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"non_interactive_handshake((Field),(Field))\") };\npub global INTERACTIVE_HANDSHAKE_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"interactive_handshake((Field),(Field))\") };\npub global GET_NON_INTERACTIVE_HANDSHAKES_SELECTOR: FunctionSelector =\n    comptime { FunctionSelector::from_signature(\"get_non_interactive_handshakes((Field),u32)\") };\n\n/// Reads the existing app-siloed handshake secrets for `(sender, recipient)` from the registry.\n///\n/// Returns `None` when no handshake has been registered for the pair yet, in which case the caller decides how to\n/// source a tagging secret (see [`super::tag::derive_log_tag`]).\n///\n/// ## Batching\n///\n/// This reads committed state, so within a single transaction multiple sends cannot see each other's pending\n/// handshake. A brand-new recipient therefore needs one landed transaction to establish the handshake before further\n/// sends can be batched onto it.\npub(crate) unconstrained fn get_existing_app_siloed_handshake_secrets(\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> Option<AppSiloedHandshakeSecrets> {\n    let returns = call_utility_function(\n        registry,\n        GET_APP_SILOED_SECRETS_SELECTOR,\n        [sender.to_field(), recipient.to_field()],\n    );\n    Deserialize::deserialize(returns)\n}\n\n/// Establishes a non-interactive handshake for `(sender, recipient)` and returns its app-siloed secrets.\n///\n/// The registry inserts a fresh handshake note and returns the app-siloed secrets. The constrained return value is the\n/// source of truth for the secrets, so constrained delivery anchoring a freshly bootstrapped handshake needs no\n/// separate call to the registry's `validate_handshake`.\n///\n/// Any handshake already registered for the pair is overwritten.\npub(crate) fn create_non_interactive_handshake(\n    context: &mut PrivateContext,\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> AppSiloedHandshakeSecrets {\n    context\n        .call_private_function(registry, NON_INTERACTIVE_HANDSHAKE_SELECTOR, [sender.to_field(), recipient.to_field()])\n        .get_preimage()\n}\n\n/// Establishes an interactive handshake for `(sender, recipient)` and returns its app-siloed secrets.\n///\n/// As with [`create_non_interactive_handshake`], the constrained return value is the source of truth for the\n/// secrets, so constrained delivery anchoring a freshly bootstrapped handshake needs no separate call to the\n/// registry's `validate_handshake`.\n///\n/// Any handshake already registered for the pair is overwritten.\npub(crate) fn create_interactive_handshake(\n    context: &mut PrivateContext,\n    registry: AztecAddress,\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> AppSiloedHandshakeSecrets {\n    context\n        .call_private_function(registry, INTERACTIVE_HANDSHAKE_SELECTOR, [sender.to_field(), recipient.to_field()])\n        .get_preimage()\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_non_interactive_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_NON_INTERACTIVE_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    #[test]\n    unconstrained fn get_handshake_secrets_returns_empty_when_scope_keys_not_held() {\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 mut items = BoundedVec::new();\n            items.push(DiscoveredHandshake { eph_pk: point_from_x_coord(1).unwrap() });\n            let page = HandshakePage { items, total_count: 1 };\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(page.serialize());\n\n            let empty: [Field; 0] = [];\n            mock_get_shared_secrets(empty);\n\n            let secrets = get_handshake_secrets(contract_address, scope);\n            assert_eq(secrets.len(), 0);\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"
     },
     "141": {
       "function_locations": [
@@ -497,7 +243,7 @@
           "start": 13875
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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::partial_notes;\nuse crate::protocol::address::AztecAddress;\n\npub(crate) mod nonce_discovery;\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            offchain::OffchainInboxSync, OffchainMessageWithTx, pending_tagged_log::PendingTaggedLog, ResolvedTx,\n            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/* resolved_tx */ ResolvedTx,\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: OffchainMessageWithTx| {\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.resolved_tx,\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::sync(\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_getPendingTaggedLogsV2\");\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            // Guards against the mocked oracle name going stale: if sync stops calling it, the crafted empty log\n            // above is never consumed and the test silently stops covering the empty-payload path.\n            assert_eq(mock.times_called(), 1);\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"
     },
     "142": {
@@ -555,7 +301,7 @@
           "start": 18937
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/discovery/nonce_discovery.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "143": {
@@ -565,7 +311,7 @@
           "start": 547
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/discovery/private_events.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "144": {
@@ -579,7 +325,7 @@
           "start": 3612
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "145": {
@@ -593,7 +339,7 @@
           "start": 2851
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHash, ComputeNoteNullifier, CustomMessageHandler, private_events::process_private_event_msg,\n        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::ResolvedTx,\n};\n\nuse crate::logging::{aztecnr_debug_log, aztecnr_warn_log_format};\nuse crate::partial_notes::process_partial_note_private_msg;\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    resolved_tx: ResolvedTx,\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            resolved_tx,\n            recipient,\n        );\n    } else {\n        aztecnr_warn_log_format!(\"Could not decrypt message ciphertext from tx {0}, ignoring\")([resolved_tx.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    resolved_tx: ResolvedTx,\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                resolved_tx.tx_hash,\n                resolved_tx.unique_note_hashes_in_tx,\n                resolved_tx.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                resolved_tx,\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                resolved_tx.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                resolved_tx,\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\")([resolved_tx.tx_hash]);\n    }\n}\n"
     },
     "146": {
@@ -655,7 +401,7 @@
           "start": 13280
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/encoding.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "147": {
@@ -741,7 +487,7 @@
           "start": 33413
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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`. Secret derivation may also fail when the PXE does not\n                // hold the recipient's keys (e.g. when syncing the scope of an address we don't control), in which\n                // case the message is undecryptable and equally skipped.\n                point_from_x_coord_and_sign(eph_pk_x, true)\n                    .and_then(|eph_pk| get_shared_secret(recipient, eph_pk, contract_address))\n                    .and_then(|s_app| {\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\n                        // necessary here as the header ciphertext length is fixed. But we do it anyway to not have to\n                        // have duplicate 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"
     },
     "15": {
@@ -845,7 +591,7 @@
           "start": 6966
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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` is too short to contain the reserved fields. This plaintext is meant to have\n/// originated 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, EventSelector},\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::{FromField, 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    #[derive(Serialize)]\n    struct EmptyEvent {}\n\n    impl EventInterface for EmptyEvent {\n        fn get_event_type_id() -> EventSelector {\n            EventSelector::from_field(90)\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_empty_event() {\n        let message_plaintext = encode_private_event_message(EmptyEvent {}, 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, EmptyEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event.len(), 0);\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_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([RANDOMNESS]);\n\n        let (_, randomness, serialized_event) = decode_private_event_message(0, content).unwrap();\n\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event.len(), 0);\n    }\n}\n"
     },
     "154": {
@@ -903,7 +649,7 @@
           "start": 9509
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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` is too short to contain the reserved fields. This plaintext is meant to have\n/// originated 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, ToField}};\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    #[derive(Packable)]\n    struct EmptyNote {}\n\n    impl NoteType for EmptyNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_empty_note() {\n        let encoded = encode_private_note_message(EmptyNote {}, 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, EmptyNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note.len(), 0);\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_fewer_than_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0, 0]);\n        assert(decode_private_note_message(0, content).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([OWNER.to_field(), STORAGE_SLOT, RANDOMNESS]);\n\n        let (_, owner, storage_slot, randomness, packed_note) = decode_private_note_message(0, content).unwrap();\n\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note.len(), 0);\n    }\n}\n"
     },
     "155": {
@@ -929,7 +675,7 @@
           "start": 7197
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/logs/partial_note.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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": {
@@ -1213,148 +959,140 @@
           "start": 7003
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
       "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\npub use crate::oracle::tx_resolution::ResolvedTx;\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    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\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    partial_notes::DeliveredPendingPartialNote,\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 OffchainMessageWithTx {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub resolved_tx: ResolvedTx,\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 in an\n/// `EphemeralArray` 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: EphemeralArray<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": 2699
+          "start": 2673
         },
         {
           "name": "sync_inbox",
-          "start": 4202
+          "start": 3451
         },
         {
           "name": "test::setup",
-          "start": 6051
+          "start": 5230
         },
         {
           "name": "test::make_msg",
-          "start": 6381
+          "start": 5560
         },
         {
           "name": "test::advance_by",
-          "start": 6664
+          "start": 5843
         },
         {
           "name": "test::empty_inbox_returns_empty_result",
-          "start": 6855
+          "start": 6034
         },
         {
           "name": "test::multiple_messages_mixed_expiration",
-          "start": 7243
-        },
-        {
-          "name": "test::accepts_messages_within_the_tolerated_future_skew",
-          "start": 9172
-        },
-        {
-          "name": "test::rejects_batch_with_implausible_future_anchor",
-          "start": 10197
+          "start": 6422
         },
         {
           "name": "test::redelivery_is_idempotent",
-          "start": 10895
+          "start": 8404
         },
         {
           "name": "test::redelivery_after_processing_keeps_processed_guard",
-          "start": 11760
+          "start": 9269
         }
       ],
-      "path": "/home/nventuro/pkg-1/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::OffchainMessageWithTx},\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::{MAX_ANCHOR_FUTURE_SKEW, 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 and finality-based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithTx>;\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 eventually removed from the inbox: an unprocessed message once its TTL (`anchor_block_timestamp +\n/// MAX_MSG_TTL`) elapses, and a processed message once the block its transaction was found in finalizes.\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    //\n    // The sender-supplied anchor timestamp is the one field we bound: a message claiming to originate implausibly far\n    // in our future (see MAX_ANCHOR_FUTURE_SKEW) cannot be genuine, and accepting it would let a malicious anchor evade\n    // the TTL-based inbox eviction. We reject such a batch by panicking instead of silently dropping the message, so\n    // the calling wallet can react to it (e.g. surface the error or distrust the sender).\n    let now = UtilityContext::new().timestamp();\n    messages.for_each(|msg| {\n        assert(\n            msg.anchor_block_timestamp <= now + MAX_ANCHOR_FUTURE_SKEW,\n            \"offchain message anchor timestamp is implausibly far in the future\",\n        );\n    });\n\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<OffchainMessageWithTx> {\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<OffchainMessageWithTx> = 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,\n        protocol::{address::AztecAddress, constants::MAX_TX_LIFETIME},\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OffchainMessage, receive, sync_inbox};\n    use super::reception::{MAX_ANCHOR_FUTURE_SKEW, 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    #[test]\n    unconstrained fn accepts_messages_within_the_tolerated_future_skew() {\n        let (env, scope) = setup();\n        let now = advance_by(env, 10);\n\n        // A present-dated anchor and a 24h-future one both fall within the tolerated skew. The latter models a genuine\n        // message whose sender anchored ahead of our lagging PXE, and must still be accepted.\n        let present = make_msg(scope, Option::some(random()), now);\n        let lagged = make_msg(scope, Option::some(random()), now + MAX_TX_LIFETIME);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([present, lagged]));\n\n            assert(OffchainReception::is_active(address, scope, present));\n            assert(OffchainReception::is_active(address, scope, lagged));\n            assert_eq(OffchainReception::load_all(address, scope).len(), 2);\n        });\n    }\n\n    #[test(should_fail_with = \"offchain message anchor timestamp is implausibly far in the future\")]\n    unconstrained fn rejects_batch_with_implausible_future_anchor() {\n        let (env, scope) = setup();\n        let now = advance_by(env, 10);\n\n        // Beyond `now + MAX_ANCHOR_FUTURE_SKEW`: our view would trail the tip by more than a tx lifetime, so this\n        // cannot be genuine. Reception panics so the wallet can react rather than accept it.\n        let too_future = make_msg(\n            scope,\n            Option::some(random()),\n            now + MAX_ANCHOR_FUTURE_SKEW + 7200,\n        );\n\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([too_future])); });\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"
+      "path": "/home/aztec-dev/aztec-packages-private/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::OffchainMessageWithTx},\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 and finality-based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithTx>;\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 eventually removed from the inbox: an unprocessed message once its TTL (`anchor_block_timestamp +\n/// MAX_MSG_TTL`) elapses, and a processed message once the block its transaction was found in finalizes.\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<OffchainMessageWithTx> {\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<OffchainMessageWithTx> = 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": 9679
+          "start": 8657
         },
         {
           "name": "OffchainReception::load_all",
-          "start": 10197
+          "start": 9175
         },
         {
           "name": "OffchainReception::read_message",
-          "start": 10546
+          "start": 9524
         },
         {
           "name": "OffchainReception::id_for",
-          "start": 11247
+          "start": 10225
         },
         {
           "name": "OffchainReception::is_active",
-          "start": 11566
+          "start": 10544
         },
         {
           "name": "OffchainReception::step",
-          "start": 12221
+          "start": 11199
         },
         {
           "name": "OffchainReception::is_processed",
-          "start": 13826
+          "start": 12804
         },
         {
           "name": "OffchainReception::mark_processed",
-          "start": 14394
+          "start": 13372
         },
         {
           "name": "OffchainReception::terminate",
-          "start": 14962
+          "start": 13940
         },
         {
           "name": "to_payload",
-          "start": 15336
+          "start": 14314
         },
         {
           "name": "test::setup",
-          "start": 15893
+          "start": 14871
         },
         {
           "name": "test::make_msg",
-          "start": 16223
+          "start": 15201
         },
         {
           "name": "test::resolved_tx_at_block",
-          "start": 16507
+          "start": 15485
         },
         {
           "name": "test::resolved_tx",
-          "start": 16898
+          "start": 15876
         },
         {
           "name": "test::expired_reception_is_terminated",
-          "start": 17015
+          "start": 15993
         },
         {
           "name": "test::unresolved_reception_stays_active",
-          "start": 17697
+          "start": 16675
         },
         {
           "name": "test::resolved_reception_is_ready_to_process",
-          "start": 18492
+          "start": 17470
         },
         {
           "name": "test::already_processed_reception_is_not_re_pushed",
-          "start": 19538
+          "start": 18516
         },
         {
           "name": "test::processed_reception_terminates_once_its_origin_block_finalizes",
-          "start": 20912
+          "start": 19890
         },
         {
           "name": "test::unfinalized_processed_reception_survives_past_the_ttl",
-          "start": 22137
+          "start": 21115
         },
         {
           "name": "test::expired_reception_is_still_processed_when_its_tx_resolves",
-          "start": 23527
+          "start": 22505
         }
       ],
-      "path": "/home/nventuro/pkg-1/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                            |  tx block finalized\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//!   until the block the originating transaction was found in finalizes.\n//! - **Terminated**: nothing else can be done with the message, either because its originating transaction never\n//!   appeared within the TTL, or because the block it was processed in has finalized. This is the terminal state of\n//!   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 originating transaction can no longer\n//!   appear and the message is no longer processable.\n//! - **Processed -> Terminated**: the block the originating transaction was found in has finalized, so the effects of\n//!   its processing are permanent and reorg-proof.\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//! The TTL only matters for unprocessed messages. Already-processed message receptions complete when the block that\n//! included the originating transaction finalizes, which is exactly when the processing becomes reorg-proof.\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//!\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 analyze the recorded facts:\n//!\n//! - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state. Once that fact's origin block has\n//!   finalized the processing is reorg-proof, so the [fact collection](crate::facts::FactCollection) can (and should)\n//!   be deleted; until then there is nothing to do.\n//! - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we check if the message\n//!   transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition. Otherwise, once the\n//!   TTL has elapsed the originating transaction can no longer appear and the collection can (and should) be deleted.\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::OffchainMessageWithTx,\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/// Maximum amount by which a received message's `anchor_block_timestamp` may exceed our current timestamp.\n///\n/// A message's anchor is the timestamp of the block the sender anchored its originating tx to, so for a genuine\n/// message it is at or before our own anchor timestamp. Our PXE may lag the chain tip though, which can make a\n/// legitimate anchor appear to be in our future, so we tolerate a forward skew of `MAX_TX_LIFETIME` (the longest a tx\n/// can wait to be mined after its anchor) plus a 2h margin. A larger skew would mean our view trails the tip by more\n/// than a tx lifetime -- so far behind that we could not even build a tx that wouldn't be immediately expired -- so\n/// such a message cannot be genuine and is rejected on reception. Bounding the anchor this way also keeps accepted\n/// values near the present, which prevents the `anchor_block_timestamp + MAX_MSG_TTL` eviction check from overflowing.\n/// (7200 == 2 hours)\npub(crate) global MAX_ANCHOR_FUTURE_SKEW: 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<OffchainMessageWithTx> {\n        let message = self.read_message();\n        let processed_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n        if processed_fact.is_none() & maybe_resolved_tx.is_some() {\n            // Received -> Processed: the originating tx is onchain.\n            let resolved = maybe_resolved_tx.unwrap();\n            self.mark_processed(resolved.block_number, resolved.block_hash);\n            Option::some(\n                OffchainMessageWithTx { message_ciphertext: message.ciphertext, resolved_tx: resolved },\n            )\n        } else if processed_fact.is_some() {\n            if processed_fact.unwrap().origin_block.unwrap().block_state.is_finalized() {\n                // Processed -> Terminated: once the marker's origin block finalizes, the processing is reorg-proof and\n                // the reception is complete. Until then we wait: a reorg dropping that block removes the retractable\n                // marker and PXE pushes us back to Received.\n                self.terminate();\n            }\n            Option::none()\n        } else {\n            // Received -> Terminated: the TTL caps how long we keep looking for the originating tx.\n            if now > message.anchor_block_timestamp + MAX_MSG_TTL {\n                self.terminate();\n            }\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`, found in `block_number`.\n    fn resolved_tx_at_block(tx_hash: Field, block_number: u32) -> ResolvedTx {\n        ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: BoundedVec::new(),\n            first_nullifier_in_tx: 0,\n            block_number,\n            block_hash: 0,\n        }\n    }\n\n    /// Builds a resolved-tx context found in a low block, which TXE (proven == finalized == latest) reports as\n    /// `Finalized`.\n    fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n        resolved_tx_at_block(tx_hash, 1)\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().resolved_tx.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        // A future origin block stays unfinalized, so the reception lingers in Processed across steps.\n        let future_block = env.last_block_number() + 100;\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_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Second step (still resolved, not finalized) recognizes it as processed and does not re-push it.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(\n                reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_none(),\n                \"already processed\",\n            );\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n        });\n    }\n\n    #[test]\n    unconstrained fn processed_reception_terminates_once_its_origin_block_finalizes() {\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            // Process the message against a finalized block.\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            // Next step, still well within the TTL: a finalized origin block makes the processing reorg-proof, so the\n            // reception terminates regardless of the TTL.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none());\n            assert(\n                !OffchainReception::is_active(address, scope, msg),\n                \"finalized processed reception should be terminated\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn unfinalized_processed_reception_survives_past_the_ttl() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n        // A future origin block never finalizes here, so the reception must not be terminated by the TTL.\n        let future_block = env.last_block_number() + 100;\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Past the TTL, but the origin block has not finalized: the reception stays active. The TTL no longer\n            // governs an already-processed reception.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), MAX_MSG_TTL + 1).is_none());\n            assert(\n                OffchainReception::is_active(address, scope, msg),\n                \"unfinalized processed reception should survive past the TTL\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_still_processed_when_its_tx_resolves() {\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            // Even past the TTL, a freshly resolved tx is still handed off: expiry only caps the search for the\n            // originating tx, it does not pre-empt processing once that tx is found.\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            assert(OffchainReception::is_active(address, scope, msg), \"just-processed reception should stay active\");\n        });\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages-private/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                            |  tx block finalized\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//!   until the block the originating transaction was found in finalizes.\n//! - **Terminated**: nothing else can be done with the message, either because its originating transaction never\n//!   appeared within the TTL, or because the block it was processed in has finalized. This is the terminal state of\n//!   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 originating transaction can no longer\n//!   appear and the message is no longer processable.\n//! - **Processed -> Terminated**: the block the originating transaction was found in has finalized, so the effects of\n//!   its processing are permanent and reorg-proof.\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//! The TTL only matters for unprocessed messages. Already-processed message receptions complete when the block that\n//! included the originating transaction finalizes, which is exactly when the processing becomes reorg-proof.\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//!\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 analyze the recorded facts:\n//!\n//! - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state. Once that fact's origin block has\n//!   finalized the processing is reorg-proof, so the [fact collection](crate::facts::FactCollection) can (and should)\n//!   be deleted; until then there is nothing to do.\n//! - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we check if the message\n//!   transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition. Otherwise, once the\n//!   TTL has elapsed the originating transaction can no longer appear and the collection can (and should) be deleted.\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::OffchainMessageWithTx,\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<OffchainMessageWithTx> {\n        let message = self.read_message();\n        let processed_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n        if processed_fact.is_none() & maybe_resolved_tx.is_some() {\n            // Received -> Processed: the originating tx is onchain.\n            let resolved = maybe_resolved_tx.unwrap();\n            self.mark_processed(resolved.block_number, resolved.block_hash);\n            Option::some(\n                OffchainMessageWithTx { message_ciphertext: message.ciphertext, resolved_tx: resolved },\n            )\n        } else if processed_fact.is_some() {\n            if processed_fact.unwrap().origin_block.unwrap().block_state.is_finalized() {\n                // Processed -> Terminated: once the marker's origin block finalizes, the processing is reorg-proof and\n                // the reception is complete. Until then we wait: a reorg dropping that block removes the retractable\n                // marker and PXE pushes us back to Received.\n                self.terminate();\n            }\n            Option::none()\n        } else {\n            // Received -> Terminated: the TTL caps how long we keep looking for the originating tx.\n            if now > message.anchor_block_timestamp + MAX_MSG_TTL {\n                self.terminate();\n            }\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`, found in `block_number`.\n    fn resolved_tx_at_block(tx_hash: Field, block_number: u32) -> ResolvedTx {\n        ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: BoundedVec::new(),\n            first_nullifier_in_tx: 0,\n            block_number,\n            block_hash: 0,\n        }\n    }\n\n    /// Builds a resolved-tx context found in a low block, which TXE (proven == finalized == latest) reports as\n    /// `Finalized`.\n    fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n        resolved_tx_at_block(tx_hash, 1)\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().resolved_tx.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        // A future origin block stays unfinalized, so the reception lingers in Processed across steps.\n        let future_block = env.last_block_number() + 100;\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_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Second step (still resolved, not finalized) recognizes it as processed and does not re-push it.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(\n                reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_none(),\n                \"already processed\",\n            );\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n        });\n    }\n\n    #[test]\n    unconstrained fn processed_reception_terminates_once_its_origin_block_finalizes() {\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            // Process the message against a finalized block.\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            // Next step, still well within the TTL: a finalized origin block makes the processing reorg-proof, so the\n            // reception terminates regardless of the TTL.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none());\n            assert(\n                !OffchainReception::is_active(address, scope, msg),\n                \"finalized processed reception should be terminated\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn unfinalized_processed_reception_survives_past_the_ttl() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n        // A future origin block never finalizes here, so the reception must not be terminated by the TTL.\n        let future_block = env.last_block_number() + 100;\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Past the TTL, but the origin block has not finalized: the reception stays active. The TTL no longer\n            // governs an already-processed reception.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), MAX_MSG_TTL + 1).is_none());\n            assert(\n                OffchainReception::is_active(address, scope, msg),\n                \"unfinalized processed reception should survive past the TTL\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_still_processed_when_its_tx_resolves() {\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            // Even past the TTL, a freshly resolved tx is still handed off: expiry only caps the search for the\n            // originating tx, it does not pre-empt processing once that tx is found.\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            assert(OffchainReception::is_active(address, scope, msg), \"just-processed reception should stay active\");\n        });\n    }\n}\n"
     },
     "17": {
       "function_locations": [
@@ -1561,7 +1299,7 @@
           "start": 3150
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/aes128_decrypt.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "186": {
@@ -1799,7 +1537,7 @@
           "start": 7247
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/avm.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/oracle/avm.nr",
       "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> bool {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> bool {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> bool {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> bool {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> bool {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> bool {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
     "189": {
@@ -1813,7 +1551,7 @@
           "start": 507
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/call_utility_function.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "191": {
@@ -1827,7 +1565,7 @@
           "start": 700
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/contract_sync.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "193": {
@@ -1841,7 +1579,7 @@
           "start": 786
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use crate::context::UtilityContext;\nuse crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress};\n\n/// Wire shape of [`get_utility_context_oracle`]'s response. [`UtilityContext`] is built from it rather than returned\n/// directly so its fields stay private to its module.\n#[derive(Eq)]\npub(crate) struct UtilityContextData {\n    pub(crate) block_header: BlockHeader,\n    pub(crate) contract_address: AztecAddress,\n    pub(crate) msg_sender: AztecAddress,\n}\n\n#[oracle(aztec_utl_getUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContextData {}\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    UtilityContext::from(get_utility_context_oracle())\n}\n"
     },
     "204": {
@@ -1877,18 +1615,10 @@
         {
           "name": "get_tx_effect_oracle",
           "start": 3000
-        },
-        {
-          "name": "get_tx_effects",
-          "start": 3193
-        },
-        {
-          "name": "get_tx_effects_oracle",
-          "start": 3378
         }
       ],
-      "path": "/home/nventuro/pkg-1/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, 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_getPendingTaggedLogsV2)]\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_getLogsByTagV2)]\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\n/// Fetches all effects of settled transactions by hash, preserving request order.\npub unconstrained fn get_tx_effects(tx_hashes: EphemeralArray<Field>) -> EphemeralArray<Option<TxEffect>> {\n    get_tx_effects_oracle(tx_hashes)\n}\n\n#[oracle(aztec_utl_getTxEffects)]\nunconstrained fn get_tx_effects_oracle(tx_hashes: EphemeralArray<Field>) -> EphemeralArray<Option<TxEffect>> {}\n"
+      "path": "/home/aztec-dev/aztec-packages-private/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, 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_getPendingTaggedLogsV2)]\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_getLogsByTagV2)]\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"
     },
     "210": {
       "function_locations": [
@@ -1901,7 +1631,7 @@
           "start": 568
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "213": {
@@ -1947,7 +1677,7 @@
           "start": 7189
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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.\n///\n/// Returns `none` when the PXE does not hold `address`'s keys and therefore cannot derive the secret.\npub unconstrained fn get_shared_secret(\n    address: AztecAddress,\n    eph_pk: EmbeddedCurvePoint,\n    contract_address: AztecAddress,\n) -> Option<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    if secrets.len() == 1 {\n        Option::some(secrets.get(0))\n    } else {\n        Option::none()\n    }\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).\n///\n/// Returns an empty array when the PXE does not hold `address`'s keys and therefore cannot derive any secrets. This\n/// happens when syncing the scope of an address the PXE does not control, and is an expected outcome rather than an\n/// error. Any other response length mismatch is a malformed oracle response.\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(\n        (response.len() == eph_pks.len()) | (response.len() == 0),\n        \"get_shared_secrets: response length does not match request length\",\n    );\n    response\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::oracle::shared_secret::{get_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]\n    unconstrained fn returns_empty_when_pxe_does_not_hold_keys() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let empty: [Field; 0] = [];\n            let _ = mock_get_shared_secrets(empty);\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 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.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn single_secret_returns_the_secret() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let secret = get_shared_secret(AztecAddress::from_field(1), pk, AztecAddress::from_field(2));\n\n            assert_eq(secret.unwrap(), 111);\n        });\n    }\n\n    #[test]\n    unconstrained fn single_secret_returns_none_when_pxe_does_not_hold_keys() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let empty: [Field; 0] = [];\n            let _ = mock_get_shared_secrets(empty);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let secret = get_shared_secret(AztecAddress::from_field(1), pk, AztecAddress::from_field(2));\n\n            assert(secret.is_none());\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"
     },
     "217": {
@@ -1965,7 +1695,7 @@
           "start": 991
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/oracle/tx_resolution.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "219": {
@@ -2079,7 +1809,7 @@
           "start": 22505
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/partial_notes/fsm.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/partial_notes/fsm.nr",
       "source": "//! The finite state machine to process a single partial note.\n//!\n//! A partial note arrives in two parts: a private part (delivered first, carrying the owner, randomness, completion-log\n//! tag, note type, and packed private content) and a public *completion log* (storage slot + packed public content).\n//! The note can only be discovered and stored once both are combined. The state chart below summarizes how a single\n//! partial note's process unfolds, including how reorgs cause it to rewind.\n//!\n//! ```text\n//!                   init() (partial note delivery message, including tx and block data)\n//!                         |\n//!                         v\n//!                     +-----------+    completion log found         +-----------+\n//!                ---- |           | ------------------------------> |           |\n//!  log not found |    |           |                                 |           |     discover note(s),\n//!                |--> |  PENDING  |                                 | COMPLETED | ~~> enqueue for storage, etc\n//!                     |           | <------------------------------ |           |\n//!                     |           |  completion log block re-orged  |           |\n//!                     +-----------+                                 +-----------+\n//!                         |                                               |\n//!                         |  delivery message block re-orged              |  completion log block finalized\n//!                         v                                               v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Pending**: the private part has been received but the completion log has not been found yet. While in this\n//!   state, message discovery keeps searching for that log on each sync.\n//! - **Completed**: the completion log was found, so the note was completed and enqueued for storage. Because the\n//!   block containing the completion log can be dropped by a reorg, this state is not terminal until the block\n//!   finalizes: a reorg dropping it rewinds the FSM back to `Pending` state.\n//! - **Terminated**: nothing else can be done with the partial note, either because its delivery block was re-orged\n//!   away (so the delivery itself was reverted) or because its completion block has finalized (so the discovered note\n//!   is permanent and reorg-proof). This is the terminal state of this FSM.\n//!\n//! ## Transitions (each evaluated by [`step`](PartialNoteFsm::step))\n//!\n//! - **Pending -> Completed** ([`complete_with_log`](PartialNoteFsm::complete_with_log)): the completion log is\n//!   found. Its public content is combined with the delivered private content, the resulting note(s) are discovered\n//!   and enqueued for storage.\n//! - **Completed -> Pending**: the completion log block is re-orged out. The completion log is searched for again.\n//! - **Pending -> Terminated**: the delivery block is re-orged out, retracting the `delivered` birth fact. The\n//!   delivery was reverted, so there is nothing left to do.\n//! - **Completed -> Terminated**: the completion log block finalizes, making the discovered note reorg-proof, so the\n//!   reception is complete and its collection is deleted.\n//!\n//! ## Implementation\n//!\n//! Each pending partial note is tracked as a [fact collection](crate::facts::FactCollection) of type\n//! `PARTIAL_NOTE_RECEPTION_TYPE_ID`, identified by a hash of its [`DeliveredPendingPartialNote`] content (so\n//! re-delivery of the same partial note is idempotent). The collection holds:\n//!\n//! - a retractable `PARTIAL_NOTE_DELIVERED` birth fact tied to a delivery block (so a reorg of that block auto-prunes\n//!   the pending note), whose payload is the serialized [`DeliveredPendingPartialNote`];\n//! - once the completion log is found, a retractable `PARTIAL_NOTE_COMPLETED` fact tied to the completion log block.\n//!\n//! Status folds from the canonical fact set:\n//!     - `delivered` only ⇒ Pending\n//!     - `delivered` + `completed` ⇒ Completed\n//!\n//! A reorg retracting either fact folds the reception back accordingly.\nuse crate::ephemeral::EphemeralArray;\nuse crate::facts::{\n    delete_fact_collection, Fact, FactCollection, get_fact_collections_by_type, OriginBlock, record_retractable_fact,\n    RetractableFactOrigin,\n};\nuse crate::logging::aztecnr_debug_log_format;\nuse crate::messages::{\n    discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n    processing::{enqueue_note_for_validation, log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN}},\n};\nuse crate::protocol::{address::AztecAddress, hash::{poseidon2_hash, sha256_to_field}, traits::{Deserialize, Serialize}};\nuse crate::utils::array;\nuse super::DeliveredPendingPartialNote;\n\n/// Fact-collection type id shared by every partial-note reception in the [fact store](crate::facts).\nglobal PARTIAL_NOTE_RECEPTION_TYPE_ID: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_RECEPTION_TYPE_ID\".as_bytes());\n\n/// Fact type id of the birth fact carrying the delivered private partial note.\nglobal PARTIAL_NOTE_DELIVERED: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_DELIVERED\".as_bytes());\n\n/// Fact type id marking a partial note as completed (its note has been discovered and enqueued).\nglobal PARTIAL_NOTE_COMPLETED: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_COMPLETED\".as_bytes());\n\n/// A single partial note's finite state machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n#[derive(Deserialize, Serialize)]\npub(crate) struct PartialNoteFsm {\n    collection: FactCollection,\n}\n\nimpl PartialNoteFsm {\n    /// Initializes an FSM for a freshly discovered partial note.\n    ///\n    /// The FSM existence is tied to `origin_block`: if `origin_block` is dropped by a reorg, the FSM is transparently\n    /// deleted.\n    pub(crate) unconstrained fn init(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        pending: DeliveredPendingPartialNote,\n        origin_block: OriginBlock,\n    ) {\n        record_retractable_fact(\n            contract_address,\n            scope,\n            PARTIAL_NOTE_RECEPTION_TYPE_ID,\n            Self::id_for(pending),\n            PARTIAL_NOTE_DELIVERED,\n            to_payload(pending),\n            origin_block,\n        );\n    }\n\n    /// Loads every active partial-note FSM for the given contract and scope.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<PartialNoteFsm> {\n        get_fact_collections_by_type(contract_address, scope, PARTIAL_NOTE_RECEPTION_TYPE_ID)\n            .map(|collection: FactCollection| PartialNoteFsm { collection })\n    }\n\n    /// The fact-collection id identifying a specific partial note.\n    fn id_for(pending: DeliveredPendingPartialNote) -> Field {\n        poseidon2_hash(pending.serialize())\n    }\n\n    /// Reads and decodes the delivered partial note this FSM processes.\n    pub(crate) unconstrained fn read_pending_partial_note(self) -> DeliveredPendingPartialNote {\n        let delivered = self.collection.facts.find(|f: Fact| f.fact_type_id == PARTIAL_NOTE_DELIVERED).unwrap();\n        let mut fields = [0; <DeliveredPendingPartialNote as Deserialize>::N];\n        for i in 0..fields.len() {\n            fields[i] = delivered.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Whether the partial note FSM is in `completed` state, i.e. its note was completed and stored.\n    unconstrained fn is_completed(self) -> bool {\n        self.collection.facts.any(|f: Fact| f.fact_type_id == PARTIAL_NOTE_COMPLETED)\n    }\n\n    /// Whether the partial note FSM is in `pending` state, i.e. it hasn't been completed yet.\n    pub(crate) unconstrained fn is_pending(self) -> bool {\n        !self.is_completed()\n    }\n\n    /// Origin block of the partial note completion log, if available.\n    unconstrained fn completion_log_origin(self) -> Option<RetractableFactOrigin> {\n        let maybe_completed = self.collection.facts.find(|f: Fact| f.fact_type_id == PARTIAL_NOTE_COMPLETED);\n        if maybe_completed.is_some() {\n            maybe_completed.unwrap().origin_block\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Transition the partial note FSM as `completed`, conditional to `origin_block`.\n    unconstrained fn mark_completed(self, origin_block: OriginBlock) {\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            PARTIAL_NOTE_COMPLETED,\n            empty_payload,\n            origin_block,\n        );\n    }\n\n    /// Terminates this partial note FSM.\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    /// Advances this partial-note FSM by one step.\n    ///\n    /// Partial notes can only be completed if completion logs have been found for them. Log discovery and\n    /// provisioning is responsibility of the caller.\n    ///\n    /// `compute_note_hash` and `compute_note_nullifier` are injected dependencies.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_completion_logs: Option<EphemeralArray<LogRetrievalResponse>>,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        if self.is_pending() {\n            self.step_pending(maybe_completion_logs, compute_note_hash, compute_note_nullifier);\n        } else {\n            self.step_completed();\n        }\n    }\n\n    /// Processes a partial note in pending state\n    ///\n    /// Completes the partial note if its completion log is given. If not, the partial note remains in pending state\n    /// and its completion log is searched for again on future syncs.\n    unconstrained fn step_pending(\n        self,\n        maybe_completion_logs: Option<EphemeralArray<LogRetrievalResponse>>,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        if maybe_completion_logs.is_some() {\n            let completion_logs = maybe_completion_logs.unwrap();\n            let num_logs = completion_logs.len();\n            if num_logs != 0 {\n                assert(num_logs == 1, f\"Expected at most 1 completion log per partial note, got {num_logs}\");\n                self.complete_with_log(completion_logs.get(0), compute_note_hash, compute_note_nullifier);\n            }\n        }\n    }\n\n    /// Advances partial note in `completed` state: terminates it once the completion log block finalizes, since the\n    /// discovered note is then permanent and there is nothing left to track.\n    unconstrained fn step_completed(self) {\n        if self.completion_log_origin().unwrap().block_state.is_finalized() {\n            self.terminate();\n        }\n    }\n\n    /// Completes a partial note.\n    ///\n    /// Combines the delivered private content with the log's public content, discovers the resulting note(s), enqueues\n    /// them for validation, and transitions the FSM to `completed` state conditional to the completion log's block.\n    ///\n    /// Because the completion fact is retractable, a reorg of the completion log's block rewinds the FSM back to\n    /// `pending` state (which signals that completion log search should restart).\n    unconstrained fn complete_with_log(\n        self,\n        log: LogRetrievalResponse,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        let pending = self.read_pending_partial_note();\n\n        // The first field in the completion log payload is the storage slot, followed by the public note content.\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 placed at the end of the packed representation, so we combine the private and public\n        // packed content to get the complete packed note.\n        let complete_packed_note = array::append(pending.packed_private_note_content, public_note_content);\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            self.collection.contract_address,\n            pending.owner,\n            storage_slot,\n            pending.randomness,\n            pending.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 being\n        // 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.note_completion_log_tag,\n        ]);\n\n        discovered_notes.for_each(|discovered_note| {\n            enqueue_note_for_validation(\n                self.collection.contract_address,\n                pending.owner,\n                storage_slot,\n                pending.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        self.mark_completed(OriginBlock { block_number: log.block_number, block_hash: log.block_hash });\n    }\n}\n\n/// Serializes a [`DeliveredPendingPartialNote`] into a fact payload.\nunconstrained fn to_payload(pending: DeliveredPendingPartialNote) -> EphemeralArray<Field> {\n    let fields = pending.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::ephemeral::EphemeralArray;\n    use crate::facts::OriginBlock;\n    use crate::messages::logs::note::MAX_NOTE_PACKED_LEN;\n    use crate::messages::processing::log_retrieval_response::LogRetrievalResponse;\n    use crate::partial_notes::DeliveredPendingPartialNote;\n    use crate::protocol::address::AztecAddress;\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::PartialNoteFsm;\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    /// A delivered partial note with simple dummy content.\n    unconstrained fn make_pending(owner: AztecAddress) -> DeliveredPendingPartialNote {\n        DeliveredPendingPartialNote {\n            owner,\n            randomness: 0x11,\n            note_completion_log_tag: 0x22,\n            note_type_id: 0x33,\n            packed_private_note_content: BoundedVec::new(),\n        }\n    }\n\n    /// A low block, which TXE (proven == finalized == latest) reports as finalized.\n    fn finalized_block() -> OriginBlock {\n        OriginBlock { block_number: 1, block_hash: 0 }\n    }\n\n    #[test]\n    unconstrained fn init_creates_a_partial_note_fsm_in_pending_state() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_pending(), \"freshly delivered reception should be pending\");\n            assert(all.get(0).completion_log_origin().is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn read_pending_round_trips_the_delivered_content() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            let pending = PartialNoteFsm::load_all(address, scope).get(0).read_pending_partial_note();\n            assert_eq(pending.owner, scope);\n            assert_eq(pending.randomness, 0x11);\n            assert_eq(pending.note_completion_log_tag, 0x22);\n            assert_eq(pending.note_type_id, 0x33);\n        });\n    }\n\n    #[test]\n    unconstrained fn mark_completed_moves_to_completed() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(finalized_block());\n\n            let reloaded = PartialNoteFsm::load_all(address, scope).get(0);\n            assert(reloaded.is_completed(), \"should be completed after mark_completed\");\n            assert(reloaded.completion_log_origin().unwrap().block_state.is_finalized());\n        });\n    }\n\n    #[test]\n    unconstrained fn terminate_deletes_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            PartialNoteFsm::load_all(address, scope).get(0).terminate();\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn re_init_is_idempotent() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_leaves_a_pending_reception_untouched_when_it_has_no_completion_log() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // Neither an empty fetched-logs set (`Some(empty)`, the pass-1 \"searched, found nothing\" case) nor no\n            // fetch at all (`None`, the pass-2 case) can complete a pending reception, so it stays pending.\n            let no_logs: EphemeralArray<LogRetrievalResponse> = EphemeralArray::empty();\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::some(no_logs),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_pending(), \"reception without a completion log should stay pending\");\n        });\n    }\n\n    #[test]\n    unconstrained fn step_terminates_a_completed_reception_once_its_block_is_finalized() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(finalized_block());\n\n            // Completed with a finalized completion block: the discovered note is reorg-proof, so step terminates the\n            // FSM by deleting its collection.\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_keeps_a_completed_reception_while_its_block_is_unfinalized() {\n        let (env, scope) = setup();\n        // A future block never finalizes here, so the completed reception must survive the step.\n        let unfinalized_block = OriginBlock { block_number: env.last_block_number() + 100, block_hash: 0 };\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(unfinalized_block);\n\n            // Completed but not yet finalized: step must not terminate it, since a reorg could still fold it back.\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed(), \"unfinalized completed reception should survive step\");\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"
     },
     "220": {
@@ -2093,7 +1823,7 @@
           "start": 2404
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/partial_notes/mod.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/partial_notes/mod.nr",
       "source": "mod fsm;\n\nuse crate::{\n    facts::OriginBlock,\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::partial_note::{decode_partial_note_private_message, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN},\n        processing::{get_pending_partial_notes_completion_logs, ResolvedTx},\n    },\n};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\nuse fsm::PartialNoteFsm;\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    resolved_tx: ResolvedTx,\n    recipient: AztecAddress,\n) {\n    let decoded = decode_partial_note_private_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content) = decoded.unwrap();\n\n        PartialNoteFsm::init(\n            contract_address,\n            recipient,\n            DeliveredPendingPartialNote {\n                owner,\n                randomness,\n                note_completion_log_tag,\n                note_type_id,\n                packed_private_note_content,\n            },\n            OriginBlock { block_number: resolved_tx.block_number, block_hash: resolved_tx.block_hash },\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode partial note private message from tx {0}, ignoring\",\n        )(\n            [resolved_tx.tx_hash],\n        );\n    }\n}\n\n/// Drives every active partial-note FSM forward.\npub(crate) unconstrained fn sync(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    scope: AztecAddress,\n) {\n    // `load_all` is a relatively expensive oracle round-trip, so we call it once and reuse the result.\n    let active_partial_note_fsms = PartialNoteFsm::load_all(contract_address, scope);\n\n    // Fetching completion logs is the dominant cost of partial note contract sync (a node round-trip each) and only\n    // pending notes need them, so we batch that fetch for the pending subset and then drive the FSMs in two passes:\n    //  1. Step each pending FSM with its freshly-fetched completion logs, giving found logs a chance to complete notes.\n    //  2. Step every active FSM with no logs, which is where completed-and-finalized FSMs terminate.\n    // Keeping both the completion and termination logic inside `PartialNoteFsm::step` is what lets the orchestrator\n    // stay this small, the price is the somewhat less elegant two-pass shape that the batched fetch forces on us.\n    let pending_partial_note_fsms = active_partial_note_fsms.filter(|fsm: PartialNoteFsm| fsm.is_pending());\n    let pending_partial_notes = pending_partial_note_fsms.map(|fsm: PartialNoteFsm| fsm.read_pending_partial_note());\n\n    aztecnr_debug_log_format!(\"{} pending partial notes\")([pending_partial_notes.len() as Field]);\n\n    let completion_logs = get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n    assert_eq(completion_logs.len(), pending_partial_notes.len());\n\n    pending_partial_note_fsms.for_each(|i, fsm: PartialNoteFsm| {\n        fsm.step(Option::some(completion_logs.get(i)), compute_note_hash, compute_note_nullifier);\n    });\n\n    active_partial_note_fsms.for_each(|_i, fsm: PartialNoteFsm| {\n        fsm.step(Option::none(), compute_note_hash, compute_note_nullifier);\n    });\n}\n"
     },
     "273": {
@@ -2163,7 +1893,7 @@
           "start": 7995
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/unconstrained_array/mod.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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, 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"
     },
     "276": {
@@ -2185,7 +1915,7 @@
           "start": 1387
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "279": {
@@ -2215,7 +1945,7 @@
           "start": 1941
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "280": {
@@ -2257,7 +1987,7 @@
           "start": 3409
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "282": {
@@ -2271,7 +2001,7 @@
           "start": 987
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
       "source": "struct ComparatorEnum {\n    pub EQ: u8,\n    pub NEQ: u8,\n    pub LT: u8,\n    pub LTE: u8,\n    pub GT: u8,\n    pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum = ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n    // Values are computed ahead of time because circuits evaluate all branches\n    let is_equal = lhs == rhs;\n    let is_lt = lhs.lt(rhs);\n\n    if (operation == Comparator.EQ) {\n        is_equal\n    } else if (operation == Comparator.NEQ) {\n        !is_equal\n    } else if (operation == Comparator.LT) {\n        is_lt\n    } else if (operation == Comparator.LTE) {\n        is_lt | is_equal\n    } else if (operation == Comparator.GT) {\n        !is_lt & !is_equal\n    } else if (operation == Comparator.GTE) {\n        !is_lt\n    } else {\n        panic(f\"Invalid operation\")\n    }\n}\n\nmod test {\n    use super::Comparator;\n    use super::compare;\n\n    #[test]\n    unconstrained fn test_compare() {\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GTE, rhs), \"Expected lhs to be greater than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GTE, rhs), \"Expected lhs to be greater than or equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LTE, rhs), \"Expected lhs to not be less than or equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.GTE, rhs), \"Expected lhs to not be greater than or equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.GTE, rhs), \"Expected lhs to not be greater than or equal to rhs\");\n    }\n}\n"
     },
     "283": {
@@ -2297,7 +2027,7 @@
           "start": 2454
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_as_fields.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "284": {
@@ -2347,7 +2077,7 @@
           "start": 6544
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_as_bytes.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "287": {
@@ -2397,7 +2127,7 @@
           "start": 6628
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/utils/point.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "297": {
@@ -2439,99 +2169,9 @@
           "start": 4549
         }
       ],
-      "path": "/home/nventuro/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon2.nr",
+      "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon2.nr",
       "source": "use std::default::Default;\nuse std::hash::Hasher;\n\nglobal RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { 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        self.state[0] += self.cache[0];\n        self.state[1] += self.cache[1];\n        self.state[2] += self.cache[2];\n        self.state = crate::poseidon2_permutation(self.state);\n    }\n\n    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    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>(input: [Field; N], in_len: u32) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut state = [0; 4];\n        state[RATE] = iv;\n\n        if std::runtime::is_unconstrained() {\n            for i in 0..(in_len / RATE) {\n                state[0] += input[i * RATE];\n                state[1] += input[i * RATE + 1];\n                state[2] += input[i * RATE + 2];\n                state = crate::poseidon2_permutation(state);\n            }\n\n            // handle remaining elements after last full RATE-sized chunk\n            let num_extra_fields = in_len % RATE;\n            if num_extra_fields != 0 {\n                let remainder_start = in_len - num_extra_fields;\n                state[0] += input[remainder_start];\n                if num_extra_fields > 1 {\n                    state[1] += input[remainder_start + 1];\n                }\n            }\n        } else {\n            let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n            states[0] = state;\n\n            // process all full RATE-sized chunks, storing state after each permutation\n            for chunk_idx in 0..(N / RATE) {\n                for i in 0..RATE {\n                    state[i] += input[chunk_idx * RATE + i];\n                }\n                state = crate::poseidon2_permutation(state);\n                states[chunk_idx + 1] = state;\n            }\n\n            // get state at the last full block before in_len\n            let first_partially_filled_chunk = in_len / RATE;\n            state = states[first_partially_filled_chunk];\n\n            // handle remaining elements after last full RATE-sized chunk\n            let remainder_start = (in_len / RATE) * RATE;\n            for j in 0..RATE {\n                let idx = remainder_start + j;\n                if idx < in_len {\n                    state[j] += input[idx];\n                }\n            }\n        }\n\n        // always run final permutation unless we just completed a full chunk\n        // still need to permute once if in_len is 0\n        if (in_len == 0) | (in_len % RATE != 0) {\n            state = crate::poseidon2_permutation(state);\n        };\n\n        state[0]\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: @[] }\n    }\n}\n"
     },
-    "355": {
-      "function_locations": [
-        {
-          "name": "<impl Empty for AztecAddress>::empty",
-          "start": 853
-        },
-        {
-          "name": "<impl ToField for AztecAddress>::to_field",
-          "start": 953
-        },
-        {
-          "name": "<impl FromField for AztecAddress>::from_field",
-          "start": 1065
-        },
-        {
-          "name": "AztecAddress::zero",
-          "start": 1160
-        },
-        {
-          "name": "AztecAddress::is_valid",
-          "start": 1490
-        },
-        {
-          "name": "AztecAddress::to_address_point",
-          "start": 1865
-        },
-        {
-          "name": "AztecAddress::is_positive",
-          "start": 2511
-        },
-        {
-          "name": "AztecAddress::get_y",
-          "start": 3367
-        },
-        {
-          "name": "AztecAddress::compute",
-          "start": 3753
-        },
-        {
-          "name": "AztecAddress::compute_from_class_id",
-          "start": 7944
-        },
-        {
-          "name": "AztecAddress::is_zero",
-          "start": 8216
-        },
-        {
-          "name": "AztecAddress::assert_is_zero",
-          "start": 8281
-        },
-        {
-          "name": "check_max_field_value",
-          "start": 8365
-        },
-        {
-          "name": "check_is_positive",
-          "start": 8476
-        },
-        {
-          "name": "check_embedded_curve_point_add",
-          "start": 8997
-        },
-        {
-          "name": "compute_address_from_partial_and_pub_keys",
-          "start": 9262
-        },
-        {
-          "name": "compute_preaddress_from_partial_and_pub_keys",
-          "start": 11366
-        },
-        {
-          "name": "from_field_to_field",
-          "start": 11715
-        },
-        {
-          "name": "serde",
-          "start": 11852
-        },
-        {
-          "name": "to_address_point_valid",
-          "start": 12258
-        },
-        {
-          "name": "to_address_point_invalid",
-          "start": 12908
-        }
-      ],
-      "path": "/home/nventuro/pkg-1/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]\nfn 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"
-    },
     "386": {
       "function_locations": [
         {
@@ -2651,7 +2291,7 @@
           "start": 16359
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "388": {
@@ -2725,7 +2365,7 @@
           "start": 2802
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "407": {
@@ -2755,7 +2395,7 @@
           "start": 2544
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "42": {
@@ -2971,7 +2611,7 @@
           "start": 912
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/types/src/traits/to_field.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "43": {
@@ -3078,29 +2718,33 @@
           "name": "sqrt_negative_one_test",
           "start": 10564
         },
+        {
+          "name": "sqrt_negative_one_squares_back_test",
+          "start": 11017
+        },
         {
           "name": "validate_sqrt_hint_valid_test",
-          "start": 10770
+          "start": 11414
         },
         {
           "name": "validate_sqrt_hint_invalid_test",
-          "start": 11201
+          "start": 11845
         },
         {
           "name": "validate_not_sqrt_hint_valid_test",
-          "start": 11333
+          "start": 11977
         },
         {
           "name": "validate_not_sqrt_hint_zero_test",
-          "start": 11613
+          "start": 12257
         },
         {
           "name": "validate_not_sqrt_hint_wrong_hint_test",
-          "start": 11830
+          "start": 12474
         }
       ],
-      "path": "/home/nventuro/pkg-1/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    std::static_assert(N < 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"
+      "path": "/home/aztec-dev/aztec-packages-private/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    std::static_assert(N < 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).unwrap();\n    // -1 has two square roots, `r` and `-r` (= p - r), and `sqrt()` may legitimately return either one.\n    // Accept both rather than pinning the test to one particular root.\n    let known_root = 0x30644e72e131a029048b6e193fd841045cea24f6fd736bec231204708f703636;\n    assert((result == known_root) | (result == 0 - known_root));\n}\n\n#[test]\nunconstrained fn sqrt_negative_one_squares_back_test() {\n    let x = 0 - 1;\n    let root = sqrt(x).unwrap();\n    // Whichever root `sqrt` returns is a genuine square root of -1...\n    assert_eq(root * root, x);\n    // ...and so is its negation (the other root), which must be distinct.\n    let other_root = 0 - root;\n    assert_eq(other_root * other_root, x);\n    assert(root != other_root);\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"
     },
     "440": {
       "function_locations": [
@@ -3149,7 +2793,7 @@
           "start": 1426
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "441": {
@@ -3175,7 +2819,7 @@
           "start": 12477
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "443": {
@@ -3489,7 +3133,7 @@
           "start": 21246
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     },
     "444": {
@@ -3535,7 +3179,7 @@
           "start": 1263
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-protocol-circuits/crates/serde/src/writer.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/noir-protocol-circuits/crates/serde/src/writer.nr",
       "source": "pub struct Writer<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Writer<N> {\n    pub fn new() -> Self {\n        Self { data: [0; N], offset: 0 }\n    }\n\n    pub fn write(&mut self, value: Field) {\n        self.data[self.offset] = value;\n        self.offset += 1;\n    }\n\n    pub fn write_u32(&mut self, value: u32) {\n        self.write(value as Field);\n    }\n\n    pub fn write_u64(&mut self, value: u64) {\n        self.write(value as Field);\n    }\n\n    pub fn write_bool(&mut self, value: bool) {\n        self.write(value as Field);\n    }\n\n    pub fn write_array<let K: u32>(&mut self, value: [Field; K]) {\n        for i in 0..K {\n            self.data[i + self.offset] = value[i];\n        }\n        self.offset += K;\n    }\n\n    pub fn write_struct<T, let K: u32>(&mut self, value: T, serialize: fn(T) -> [Field; K]) {\n        self.write_array(serialize(value));\n    }\n\n    pub fn write_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        value: [T; C],\n        serialize: fn(T) -> [Field; K],\n    ) {\n        for i in 0..C {\n            self.write_struct(value[i], serialize);\n        }\n    }\n\n    pub fn advance_offset(&mut self, offset: u32) {\n        self.offset += offset;\n    }\n\n    pub fn finish(self) -> [Field; N] {\n        assert_eq(self.offset, self.data.len(), \"Writer did not write all data\");\n        self.data\n    }\n}\n"
     },
     "51": {
@@ -3549,7 +3193,7 @@
           "start": 1364
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/noir-contracts/contracts/standard/public_checks_contract/src/main.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/noir-contracts/contracts/standard/public_checks_contract/src/main.nr",
       "source": "mod test;\n\nuse aztec::macros::aztec;\n\n/// The purpose of this contract is to perform a check in public without revealing what contract enqueued the public\n/// call. This can be achieved by enqueueing an `incognito` public call.\n///\n/// Note that this contract should not be grouped with protocol contracts as it is not part of the protocol. We keep\n/// it here for now as it allows us to use hardcoded address.\n#[aztec]\npub contract PublicChecks {\n    use aztec::{macros::functions::{external, view}, utils::comparison::compare};\n\n    // docs:start:check_timestamp\n    /// Asserts that the current timestamp satisfies the `operation` with respect\n    /// to the `value.\n    /// NOTE: signature is hardcoded in `aztec-nr/aztec/src/public_checks.nr`; keep in sync.\n    #[external(\"public\")]\n    #[view]\n    fn check_timestamp(operation: u8, value: u64) {\n        let lhs_field = self.context.timestamp() as Field;\n        let rhs_field = value as Field;\n        assert(compare(lhs_field, operation, rhs_field), \"Timestamp mismatch.\");\n    }\n    // docs:end:check_timestamp\n\n    /// Asserts that the current block number satisfies the `operation` with respect\n    /// to the `value.\n    /// NOTE: signature is hardcoded in `aztec-nr/aztec/src/public_checks.nr`; keep in sync.\n    #[external(\"public\")]\n    #[view]\n    fn check_block_number(operation: u8, value: u32) {\n        assert(\n            compare(\n                self.context.block_number() as Field,\n                operation,\n                value as Field,\n            ),\n            \"Block number mismatch.\",\n        );\n    }\n}\n"
     },
     "6": {
@@ -3966,107 +3610,107 @@
         },
         {
           "name": "PublicContext::consume_l1_to_l2_message",
-          "start": 11961
+          "start": 11896
         },
         {
           "name": "PublicContext::message_portal",
-          "start": 14085
+          "start": 14020
         },
         {
           "name": "PublicContext::call_public_function",
-          "start": 14975
+          "start": 14910
         },
         {
           "name": "PublicContext::static_call_public_function",
-          "start": 16607
+          "start": 16542
         },
         {
           "name": "PublicContext::push_note_hash",
-          "start": 18391
+          "start": 18326
         },
         {
           "name": "PublicContext::push_nullifier_unsafe",
-          "start": 19837
+          "start": 19772
         },
         {
           "name": "PublicContext::this_address",
-          "start": 20427
+          "start": 20362
         },
         {
           "name": "PublicContext::maybe_msg_sender",
-          "start": 21522
+          "start": 21457
         },
         {
           "name": "PublicContext::selector",
-          "start": 22294
+          "start": 22229
         },
         {
           "name": "PublicContext::get_args_hash",
-          "start": 23033
+          "start": 22968
         },
         {
           "name": "PublicContext::transaction_fee",
-          "start": 24425
+          "start": 24360
         },
         {
           "name": "PublicContext::chain_id",
-          "start": 25014
+          "start": 24949
         },
         {
           "name": "PublicContext::version",
-          "start": 25684
+          "start": 25619
         },
         {
           "name": "PublicContext::block_number",
-          "start": 26624
+          "start": 26559
         },
         {
           "name": "PublicContext::timestamp",
-          "start": 27736
+          "start": 27671
         },
         {
           "name": "PublicContext::min_fee_per_l2_gas",
-          "start": 29017
+          "start": 28952
         },
         {
           "name": "PublicContext::min_fee_per_da_gas",
-          "start": 29544
+          "start": 29479
         },
         {
           "name": "PublicContext::l2_gas_left",
-          "start": 29942
+          "start": 29877
         },
         {
           "name": "PublicContext::da_gas_left",
-          "start": 30558
+          "start": 30493
         },
         {
           "name": "PublicContext::is_static_call",
-          "start": 31023
+          "start": 30958
         },
         {
           "name": "PublicContext::raw_storage_read",
-          "start": 31865
+          "start": 31800
         },
         {
           "name": "PublicContext::storage_read",
-          "start": 32723
+          "start": 32658
         },
         {
           "name": "PublicContext::raw_storage_write",
-          "start": 33391
+          "start": 33326
         },
         {
           "name": "PublicContext::storage_write",
-          "start": 34125
+          "start": 34060
         },
         {
           "name": "<impl Empty for PublicContext>::empty",
-          "start": 34250
+          "start": 34185
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "source": "use crate::{\n    context::gas::GasOpts,\n    hash::{\n        compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n        compute_siloed_nullifier,\n    },\n    oracle::avm,\n};\nuse crate::protocol::{\n    abis::function_selector::FunctionSelector,\n    address::{AztecAddress, EthAddress},\n    constants::{MAX_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS},\n    traits::{Empty, FromField, Packable, Serialize, ToField},\n    utils::writer::Writer,\n};\n\n/// # PublicContext\n///\n/// The **main interface** between an #[external(\"public\")] function and the Aztec blockchain.\n///\n/// An instance of the PublicContext is initialized automatically at the outset of every public function, within the\n/// #[external(\"public\")] macro, so you'll never need to consciously instantiate this yourself.\n///\n/// The instance is always named `context`, and it will always be available within the body of every\n/// #[external(\"public\")] function in your smart contract.\n///\n/// Typical usage for a smart contract developer will be to call getter methods of the PublicContext.\n///\n/// _Pushing_ data and requests to the context is mostly handled within aztec-nr's own functions, so typically a smart\n/// contract developer won't need to call any setter methods directly.\n///\n/// ## Responsibilities\n/// - Exposes contextual data to a public function:\n/// - Data relating to how this public function was called:\n/// - msg_sender, this_address\n/// - Data relating to the current blockchain state:\n/// - timestamp, block_number, chain_id, version\n/// - Gas and fee information\n/// - Provides state access:\n/// - Read/write public storage (key-value mapping)\n/// - Check existence of notes and nullifiers (Some patterns use notes & nullifiers to store public (not private)\n/// information)\n///   - Enables consumption of L1->L2 messages.\n/// - Enables calls to other public smart contract functions:\n/// - Writes data to the blockchain:\n/// - Updates to public state variables\n/// - New public logs (for events)\n///   - New L2->L1 messages\n/// - New notes & nullifiers (E.g. pushing public info to notes/nullifiers, or for completing \"partial notes\")\n///\n/// ## Key Differences from Private Execution\n///\n/// Unlike private functions -- which are executed on the user's device and which can only reference historic state --\n/// public functions are executed by a block proposer and are executed \"live\" on the _current_ tip of the chain. This\n/// means public functions can:\n/// - Read and write _current_ public state\n/// - Immediately see the effects of earlier transactions in the same block\n///\n/// Also, public functions are executed within a zkVM (the \"AVM\"), so that they can _revert_ whilst still ensuring\n/// payment to the proposer and prover. (Private functions cannot revert: they either succeed, or they cannot be\n/// included).\n///\n/// ## Optimising Public Functions\n///\n/// Using the AVM to execute public functions means they compile down to \"AVM bytecode\" instead of the ACIR that\n/// private functions (standalone circuits) compile to. Therefore the approach to optimising a public function is\n/// fundamentally different from optimising a public function.\n///\npub struct PublicContext {\n    args_hash: Option<Field>,\n    compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n    fn eq(self, other: Self) -> bool {\n        (self.args_hash == other.args_hash)\n        // Can't compare the function compute_args_hash\n    }\n}\n\nimpl PublicContext {\n    /// Creates a new PublicContext instance.\n    ///\n    /// Low-level function: This is called automatically by the #[external(\"public\")] macro, so you shouldn't need to\n    /// be called directly by smart contract developers.\n    ///\n    /// # Arguments\n    /// * `compute_args_hash` - Function to compute the args_hash\n    ///\n    /// # Returns\n    /// * A new PublicContext instance\n    ///\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    /// Emits a _public_ log that will be visible onchain to everyone.\n    ///\n    /// # Arguments\n    /// * `tag` - A tag placed at `fields[0]` of the emitted log. Nodes index logs by this value, allowing\n    /// clients to efficiently query for matching logs without scanning all of them.\n    /// * `log` - The data to log, must implement Serialize trait.\n    ///\n    /// ## Safety\n    ///\n    /// The `tag` should be domain-separated (e.g. via [`crate::protocol::hash::compute_log_tag`]) to prevent\n    /// collisions between logs from different sources. Without domain separation, two unrelated log types that\n    /// happen to share a raw tag value become indistinguishable. Prefer `self.emit(event)` for events, which\n    /// handles tagging automatically.\n    pub fn emit_public_log_unsafe<T>(_self: Self, tag: Field, log: T)\n    where\n        T: Serialize,\n    {\n        // We use a Writer to serialize the log directly after the tag, avoiding an extra O(n) copy that would\n        // result from serializing first and then prepending the tag.\n        let mut writer: Writer<1 + <T as Serialize>::N> = Writer::new();\n        writer.write(tag);\n        Serialize::stream_serialize(log, &mut writer);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_public_log(writer.finish().as_vector()) };\n    }\n\n    /// Checks if a given note hash exists in the note hash tree at a particular leaf_index.\n    ///\n    /// # Arguments\n    /// * `note_hash` - The note hash to check for existence\n    /// * `leaf_index` - The index where the note hash should be located\n    ///\n    /// # Returns\n    /// * `bool` - True if the note hash exists at the specified index\n    ///\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::note_hash_exists(note_hash, leaf_index)\n        }\n    }\n\n    /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message tree at a particular leaf index.\n    ///\n    /// Common use cases include token bridging, cross-chain governance, and triggering L2 actions based on L1 events.\n    ///\n    /// This function should be called before attempting to consume an L1-to-L2 message.\n    ///\n    /// # Arguments\n    /// * `msg_hash` - Hash of the L1-to-L2 message to check\n    /// * `msg_leaf_index` - The index where the message should be located\n    ///\n    /// # Returns\n    /// * `bool` - True if the message exists at the specified index\n    ///\n    /// # Advanced\n    /// * Uses the AVM l1_to_l2_msg_exists opcode for tree lookup\n    /// * Messages are copied from L1 Inbox to L2 by block proposers\n    ///\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n        unsafe {\n            avm::l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64)\n        }\n    }\n\n    /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.\n    ///\n    /// Note that unsiloed nullifiers are not the actual values stored in the nullifier tree: they are first siloed via\n    /// [`crate::hash::compute_siloed_nullifier`] with the emitting contract's address.\n    ///\n    /// ## Use Cases\n    ///\n    /// Nullifiers are typically used as a _privacy-preserving_ record of a one-time action, but they can also be used\n    /// to efficiently record _public_ one-time actions as well. This is cheaper than using public storage, and has the\n    /// added benefit of the nullifier being emittable from a private function.\n    ///\n    /// An example is to check whether a contract has been published: we emit a nullifier that is deterministic and\n    /// which has a _public_ preimage.\n    ///\n    /// ## Public vs Private\n    ///\n    /// In general, one should not attempt to prove nullifier non-existence in private, as that will not consider the\n    /// possibility of the nullifier having been emitted in any transaction between the anchor block and the inclusion\n    /// block. Private functions instead prove existence via\n    /// [`crate::context::PrivateContext::assert_nullifier_exists`]\n    /// and 'prove' non-existence by _emitting_ the nullifer, which would cause the transaction to fail if the\n    /// nullifier existed.\n    ///\n    /// This is not the case in public functions, which **do** have access to the tip of the blockchain and so can\n    /// reliably prove whether a nullifier exists or not.\n    ///\n    /// ## Safety\n    ///\n    /// While it is safe to rely on this function's return value to determine if a nullifier exists or not, it is often\n    /// **not** safe to infer additional information from that. In particular, it is **unsafe** to infer that the\n    /// existence of a nullifier emitted from a private function implies that all other side-effects of said private\n    /// execution have been completed, more concretely that any enqueued public calls have been executed.\n    ///\n    /// For example, if a function in contract `A` privately emits nullifier `X` and then enqueues public function `Y`,\n    /// then it is **unsafe** for a contract `B` to infer that `Y` has alredy executed simply because `X` exists.\n    ///\n    /// This is because **all** private transaction effects are committed _before_ enqueued public functions are run\n    /// (in\n    /// order to not reveal detailed timing information about the transaction), so it is possible to observe a\n    /// nullifier that was emitted alongside the enqueuing of a public call **before** said call has been completed.\n    ///\n    /// ## Cost\n    ///\n    /// This emits the `CHECKNULLIFIEREXISTS` opcode, which conceptually performs a merkle inclusion proof on the\n    /// nullifier tree (both when the nullifier exists and when it doesn't).\n    pub fn nullifier_exists_unsafe(_self: Self, unsiloed_nullifier: Field, contract_address: AztecAddress) -> bool {\n        let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::nullifier_exists(siloed_nullifier)\n        }\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2) -- effectively marking it as \"read\".\n    ///\n    /// Use this function if you only want the message to ever be \"referred to\" once. Once consumed using this method,\n    /// the message cannot be consumed again, because a nullifier is emitted. If your use case wants for the message to\n    /// be read unlimited times, then you can always read any historic message from the L1-to-L2 messages tree, using\n    /// the `l1_to_l2_msg_exists` method. Messages never technically get deleted from that tree.\n    ///\n    /// The message will first be inserted into an Aztec \"Inbox\" smart contract on L1. It will not be available for\n    /// consumption immediately. Messages get copied-over from the L1 Inbox to L2 by the next Proposer in batches. So\n    /// you will need to wait until the messages are copied before you can consume them.\n    ///\n    /// # Arguments\n    /// * `content` - The message content that was sent from L1\n    /// * `secret` - Secret fields used for message privacy (if needed)\n    /// * `sender` - Ethereum address that sent the message\n    /// * `leaf_index` - Index of the message in the L1-to-L2 message tree\n    ///\n    /// # Advanced\n    /// * Validates message existence in the L1-to-L2 message tree\n    /// * Prevents double-consumption by emitting a nullifier\n    /// * Message hash is computed from all parameters + chain context\n    /// * Will revert if message doesn't exist or was already consumed\n    ///\n    pub fn consume_l1_to_l2_message<let N: u32>(\n        self: Self,\n        content: Field,\n        secret: [Field; N],\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(!self.nullifier_exists_unsafe(nullifier, self.this_address()), \"L1-to-L2 message is already nullified\");\n        assert(self.l1_to_l2_msg_exists(message_hash, leaf_index), \"Tried to consume nonexistent L1-to-L2 message\");\n\n        self.push_nullifier_unsafe(nullifier);\n    }\n\n    /// Sends an \"L2 -> L1 message\" from this function (Aztec, L2) to a smart contract on Ethereum (L1). L1 contracts\n    /// which are designed to send/receive messages to/from Aztec are called \"Portal Contracts\".\n    ///\n    /// Common use cases include withdrawals, cross-chain asset transfers, and triggering L1 actions based on L2 state\n    /// changes.\n    ///\n    /// The message will be inserted into an Aztec \"Outbox\" contract on L1, when this transaction's block is proposed\n    /// to L1. Sending the message will not result in any immediate state changes in the target portal contract. The\n    /// message will need to be manually consumed from the Outbox through a separate Ethereum transaction: a user will\n    /// need to call a function of the portal contract -- a function specifically designed to make a call to the Outbox\n    /// to consume the message. The message will only be available for consumption once the _epoch_ proof has been\n    /// submitted. Given that there are multiple Aztec blocks within an epoch, it might take some time for this epoch\n    /// proof to be submitted -- especially if the block was near the start of an epoch.\n    ///\n    /// # Arguments\n    /// * `recipient` - Ethereum address that will receive the message\n    /// * `content` - Message content (32 bytes as a Field element)\n    ///\n    pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::send_l2_to_l1_msg(recipient, content) };\n    }\n\n    /// Calls a public function on another contract.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `contract_address` - Address of the contract to call\n    /// * `function_selector` - Function to call on the target contract\n    /// * `args` - Arguments to pass to the function\n    /// * `gas_opts` - An optional allocation of gas to the called function.\n    ///\n    /// # Returns\n    /// * `[Field]` - Return data from the called function\n    ///\n    pub unconstrained fn call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Makes a read-only call to a public function on another contract.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function cannot modify state or emit events. Any nested\n    /// calls are constrained to also be staticcalls.\n    ///\n    /// Useful for querying data from other contracts safely.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `contract_address` - Address of the contract to call\n    /// * `function_selector` - Function to call on the target contract\n    /// * `args` - Array of arguments to pass to the called function\n    /// * `gas_opts` - An optional allocation of gas to the called function.\n    ///\n    /// # Returns\n    /// * `[Field]` - Return data from the called function\n    ///\n    pub unconstrained fn static_call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Adds a new note hash to the Aztec blockchain's global Note Hash Tree.\n    ///\n    /// Notes are ordinarily constructed and emitted by _private_ functions, to ensure that both the content of the\n    /// note, and the contract that emitted the note, stay private.\n    ///\n    /// There are however some useful patterns whereby a note needs to contain _public_ data. The ability to push a new\n    /// note_hash from a _public_ function means that notes can be injected with public data immediately -- as soon as\n    /// the public value is known. The slower alternative would be to submit a follow-up transaction so that a private\n    /// function can inject the data. Both are possible on Aztec.\n    ///\n    /// Search \"Partial Note\" for a very common pattern which enables a note to be \"partially\" populated with some data\n    /// in a _private_ function, and then later \"completed\" with some data in a public function.\n    ///\n    /// # Arguments\n    /// * `note_hash` - The hash of the note to add to the tree\n    ///\n    /// # Advanced\n    /// * The note hash will be siloed with the contract address by the protocol\n    ///\n    pub fn push_note_hash(_self: Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_note_hash(note_hash) };\n    }\n\n    /// Creates a new [nullifier](crate::nullifier).\n    ///\n    /// While nullifiers are primarily intended as a _privacy-preserving_ record of a one-time action, they can also\n    /// be used to efficiently record _public_ one-time actions. This function allows creating nullifiers from public\n    /// contract functions, which behave just like those created from private functions.\n    ///\n    /// ## Safety\n    ///\n    /// This is a low-level function that must be used with great care to avoid subtle corruption of contract state.\n    ///\n    /// In particular, callers must ensure all nullifiers created by a contract are properly domain-separated, so that\n    /// unrelated components don't interfere with one another (e.g. a transaction nullifier accidentally marking a\n    /// variable as initialized). Note nullifiers should only be created via\n    /// [`crate::context::PrivateContext::push_nullifier_for_note_hash`].\n    ///\n    /// ## Advanced\n    ///\n    /// The raw `nullifier` is not what is inserted into the Aztec state tree: it will be first siloed by contract\n    /// address via [`crate::protocol::hash::compute_siloed_nullifier`] in order to prevent accidental or malicious\n    /// interference of nullifiers from different contracts.\n    pub fn push_nullifier_unsafe(_self: Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_nullifier(nullifier) };\n    }\n\n    /// Returns the address of the current contract being executed.\n    ///\n    /// This is equivalent to `address(this)` in Solidity (hence the name). Use this to identify the current contract's\n    /// address, commonly needed for access control or when interacting with other contracts.\n    ///\n    /// # Returns\n    /// * `AztecAddress` - The contract address of the current function being executed.\n    ///\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::address()\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name).\n    ///\n    /// Important Note: If the calling function is a _private_ function, then it had the option of hiding its address\n    /// when enqueuing this public function call. In such cases, this method will return `Option<AztecAddress>::none`.\n    /// If the calling function is a _public_ function, it will always return an `Option<AztecAddress>::some` (i.e. a\n    /// non-null value).\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract\n    /// or a user's account contract).\n    ///\n    /// # Advanced\n    /// * Value is provided by the AVM sender opcode\n    /// * In nested calls, this is the immediate caller, not the original transaction sender\n    ///\n    pub fn maybe_msg_sender(_self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = unsafe { avm::sender() };\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the function selector of the currently-executing function.\n    ///\n    /// This is similar to `msg.sig` in Solidity, returning the first 4 bytes of the function signature.\n    ///\n    /// # Returns\n    /// * `FunctionSelector` - The 4-byte function identifier\n    ///\n    /// # Advanced\n    /// * Extracted from the first element of calldata\n    /// * Used internally for function dispatch in the AVM\n    ///\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { avm::calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    ///\n    /// Very low-level function: The #[external(\"public\")] macro uses this internally. Smart contract developers\n    /// typically won't need to access this directly as arguments are automatically made available.\n    ///\n    /// # Returns\n    /// * `Field` - Hash of the function arguments\n    ///\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n\n    /// Returns the \"transaction fee\" for the current transaction. This is the final tx fee that will be deducted from\n    /// the fee_payer's \"fee-juice\" balance (in the protocol's Base Rollup circuit).\n    ///\n    /// # Returns\n    /// * `Field` - The actual, final cost of the transaction, taking into account: the actual gas used during the\n    /// setup and app-logic phases, and the fixed amount of gas that's been allocated by the user for the teardown\n    /// phase. I.e. effectiveL2FeePerGas * l2GasUsed + effectiveDAFeePerGas * daGasUsed\n    ///\n    /// This will return `0` during the \"setup\" and \"app-logic\" phases of tx execution (because the final tx fee is not\n    /// known at that time). This will only return a nonzero value during the \"teardown\" phase of execution, where the\n    /// final tx fee can actually be computed.\n    ///\n    /// Regardless of _when_ this function is called during the teardown phase, it will always return the same final tx\n    /// fee value. The teardown phase does not consume a variable amount of gas: it always consumes a pre-allocated\n    /// amount of gas, as specified by the user when they generate their tx.\n    ///\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::transaction_fee()\n        }\n    }\n\n    /// Returns the chain ID of the current network.\n    ///\n    /// This is similar to `block.chainid` in Solidity. Returns the unique identifier for the blockchain network this\n    /// transaction is executing on.\n    ///\n    /// Helps prevent cross-chain replay attacks. Useful if implementing multi-chain contract logic.\n    ///\n    /// # Returns\n    /// * `Field` - The chain ID as a field element\n    ///\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::chain_id()\n        }\n    }\n\n    /// Returns the Aztec protocol version that this transaction is executing under. Different versions may have\n    /// different rules, opcodes, or cryptographic primitives.\n    ///\n    /// This is similar to how Ethereum has different EVM versions.\n    ///\n    /// Useful for forward/backward compatibility checks\n    ///\n    /// Not to be confused with contract versions; this is the protocol version.\n    ///\n    /// # Returns\n    /// * `Field` - The protocol version as a field element\n    ///\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::version()\n        }\n    }\n    /// Returns the current block number.\n    ///\n    /// This is similar to `block.number` in Solidity.\n    ///\n    /// Note: the current block number is only available within a public function (as opposed to a private function).\n    ///\n    /// Note: the time intervals between blocks should not be relied upon as being consistent:\n    /// - Timestamps of blocks fall within a range, rather than at exact regular intervals.\n    /// - Slots can be missed.\n    /// - Protocol upgrades can completely change the intervals between blocks (and indeed the current roadmap plans to\n    /// reduce the time between blocks, eventually). Use `context.timestamp()` for more-reliable time-based logic.\n    ///\n    /// # Returns\n    /// * `u32` - The current block number\n    ///\n    pub fn block_number(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::block_number()\n        }\n    }\n\n    /// Returns the timestamp of the current block.\n    ///\n    /// This is similar to `block.timestamp` in Solidity.\n    ///\n    /// All functions of all transactions in a block share the exact same timestamp (even though technically each\n    /// transaction is executed one-after-the-other).\n    ///\n    /// Important note: Timestamps of Aztec blocks are not at reliably-fixed intervals. The proposer of the block has\n    /// some flexibility to choose a timestamp which is in a valid _range_: Obviously the timestamp of this block must\n    /// be strictly greater than that of the previous block, and must must be less than the timestamp of whichever\n    /// ethereum block the aztec block is proposed to. Furthermore, if the timestamp is not deemed close enough to the\n    /// actual current time, the committee of validators will not attest to the block.\n    ///\n    /// # Returns\n    /// * `u64` - Unix timestamp in seconds\n    ///\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::timestamp()\n        }\n    }\n\n    /// Returns the fee per unit of L2 gas for this transaction (aka the \"L2 gas price\"), as chosen by the user.\n    ///\n    /// L2 gas covers the cost of executing public functions and handling side-effects within the AVM.\n    ///\n    /// # Returns\n    /// * `u128` - Fee per unit of L2 gas\n    ///\n    /// Wallet developers should be mindful that the choice of gas price (which is publicly visible) can leak\n    /// information about the user, e.g.:\n    /// - which wallet software the user is using;\n    /// - the amount of time which has elapsed from the time the user's wallet chose a gas price (at the going rate),\n    /// to the time of tx submission. This can give clues about the proving time, and hence the nature of the tx.\n    /// - the urgency of the transaction (which is kind of unavoidable, if the tx is indeed urgent).\n    /// - the wealth of the user.\n    /// - the exact user (if the gas price is explicitly chosen by the user to be some unique number like 0.123456789,\n    /// or their favorite number). Wallet devs might wish to consider fuzzing the choice of gas price.\n    ///\n    pub fn min_fee_per_l2_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_l2_gas()\n        }\n    }\n\n    /// Returns the fee per unit of DA (Data Availability) gas (aka the \"DA gas price\").\n    ///\n    /// DA gas covers the cost of making transaction data available on L1.\n    ///\n    /// See the warning in `min_fee_per_l2_gas` for how gas prices can be leaky.\n    ///\n    /// # Returns\n    /// * `u128` - Fee per unit of DA gas\n    ///\n    pub fn min_fee_per_da_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_da_gas()\n        }\n    }\n\n    /// Returns the remaining L2 gas available for this transaction.\n    ///\n    /// Different AVM opcodes consume different amounts of gas.\n    ///\n    /// # Returns\n    /// * `u32` - Remaining L2 gas units\n    ///\n    pub fn l2_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::l2_gas_left()\n        }\n    }\n\n    /// Returns the remaining DA (Data Availability) gas available for this transaction.\n    ///\n    /// DA gas is consumed when emitting data that needs to be made available on L1, such as public logs or state\n    /// updates. All of the side-effects from the private part of the tx also consume DA gas before execution of any\n    /// public functions even begins.\n    ///\n    /// # Returns\n    /// * `u32` - Remaining DA gas units\n    ///\n    pub fn da_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::da_gas_left()\n        }\n    }\n\n    /// Checks if the current execution is within a staticcall context, where no state changes or logs are allowed to\n    /// be emitted (by this function or any nested function calls).\n    ///\n    /// # Returns\n    /// * `bool` - True if in staticcall context, false otherwise\n    ///\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::is_static_call()\n        }\n    }\n\n    /// Reads raw field values from public storage. Reads N consecutive storage slots starting from the given slot.\n    ///\n    /// Very low-level function. Users should typically use the public state variable abstractions to perform reads:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The starting storage slot to read from\n    ///\n    /// # Returns\n    /// * `[Field; N]` - Array of N field values from consecutive storage slots\n    ///\n    /// # Generic Parameters\n    /// * `N` - the number of consecutive slots to return, starting from the `storage_slot`.\n    ///\n    pub fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { avm::storage_read(storage_slot + i as Field, self.this_address().to_field()) };\n        }\n        out\n    }\n\n    /// Reads a typed value from public storage.\n    ///\n    /// Low-level function. Users should typically use the public state variable abstractions to perform reads:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The storage slot to read from\n    ///\n    /// # Returns\n    /// * `T` - The deserialized value from storage\n    ///\n    /// # Generic Parameters\n    /// * `T` - The type that the caller expects to read from the `storage_slot`.\n    ///\n    pub 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    /// Writes raw field values to public storage. Writes to N consecutive storage slots starting from the given slot.\n    ///\n    /// Very low-level function. Users should typically use the public state variable abstractions to perform writes:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// Public storage writes take effect immediately.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The starting storage slot to write to\n    /// * `values` - Array of N Fields to write to storage\n    ///\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { avm::storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    /// Writes a typed value to public storage.\n    ///\n    /// Low-level function. Users should typically use the public state variable abstractions to perform writes:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The storage slot to write to\n    /// * `value` - The typed value to write to storage\n    ///\n    /// # Generic Parameters\n    /// * `T` - The type to write to storage.\n    ///\n    pub fn storage_write<T>(self, storage_slot: Field, value: T)\n    where\n        T: Packable,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
+      "source": "use crate::{\n    context::gas::GasOpts,\n    hash::{\n        compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n        compute_siloed_nullifier,\n    },\n    oracle::avm,\n};\nuse crate::protocol::{\n    abis::function_selector::FunctionSelector,\n    address::{AztecAddress, EthAddress},\n    constants::{MAX_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS},\n    traits::{Empty, FromField, Packable, Serialize, ToField},\n    utils::writer::Writer,\n};\n\n/// # PublicContext\n///\n/// The **main interface** between an #[external(\"public\")] function and the Aztec blockchain.\n///\n/// An instance of the PublicContext is initialized automatically at the outset of every public function, within the\n/// #[external(\"public\")] macro, so you'll never need to consciously instantiate this yourself.\n///\n/// The instance is always named `context`, and it will always be available within the body of every\n/// #[external(\"public\")] function in your smart contract.\n///\n/// Typical usage for a smart contract developer will be to call getter methods of the PublicContext.\n///\n/// _Pushing_ data and requests to the context is mostly handled within aztec-nr's own functions, so typically a smart\n/// contract developer won't need to call any setter methods directly.\n///\n/// ## Responsibilities\n/// - Exposes contextual data to a public function:\n/// - Data relating to how this public function was called:\n/// - msg_sender, this_address\n/// - Data relating to the current blockchain state:\n/// - timestamp, block_number, chain_id, version\n/// - Gas and fee information\n/// - Provides state access:\n/// - Read/write public storage (key-value mapping)\n/// - Check existence of notes and nullifiers (Some patterns use notes & nullifiers to store public (not private)\n/// information)\n///   - Enables consumption of L1->L2 messages.\n/// - Enables calls to other public smart contract functions:\n/// - Writes data to the blockchain:\n/// - Updates to public state variables\n/// - New public logs (for events)\n///   - New L2->L1 messages\n/// - New notes & nullifiers (E.g. pushing public info to notes/nullifiers, or for completing \"partial notes\")\n///\n/// ## Key Differences from Private Execution\n///\n/// Unlike private functions -- which are executed on the user's device and which can only reference historic state --\n/// public functions are executed by a block proposer and are executed \"live\" on the _current_ tip of the chain. This\n/// means public functions can:\n/// - Read and write _current_ public state\n/// - Immediately see the effects of earlier transactions in the same block\n///\n/// Also, public functions are executed within a zkVM (the \"AVM\"), so that they can _revert_ whilst still ensuring\n/// payment to the proposer and prover. (Private functions cannot revert: they either succeed, or they cannot be\n/// included).\n///\n/// ## Optimising Public Functions\n///\n/// Using the AVM to execute public functions means they compile down to \"AVM bytecode\" instead of the ACIR that\n/// private functions (standalone circuits) compile to. Therefore the approach to optimising a public function is\n/// fundamentally different from optimising a public function.\n///\npub struct PublicContext {\n    args_hash: Option<Field>,\n    compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n    fn eq(self, other: Self) -> bool {\n        (self.args_hash == other.args_hash)\n        // Can't compare the function compute_args_hash\n    }\n}\n\nimpl PublicContext {\n    /// Creates a new PublicContext instance.\n    ///\n    /// Low-level function: This is called automatically by the #[external(\"public\")] macro, so you shouldn't need to\n    /// be called directly by smart contract developers.\n    ///\n    /// # Arguments\n    /// * `compute_args_hash` - Function to compute the args_hash\n    ///\n    /// # Returns\n    /// * A new PublicContext instance\n    ///\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    /// Emits a _public_ log that will be visible onchain to everyone.\n    ///\n    /// # Arguments\n    /// * `tag` - A tag placed at `fields[0]` of the emitted log. Nodes index logs by this value, allowing\n    /// clients to efficiently query for matching logs without scanning all of them.\n    /// * `log` - The data to log, must implement Serialize trait.\n    ///\n    /// ## Safety\n    ///\n    /// The `tag` should be domain-separated (e.g. via [`crate::protocol::hash::compute_log_tag`]) to prevent\n    /// collisions between logs from different sources. Without domain separation, two unrelated log types that\n    /// happen to share a raw tag value become indistinguishable. Prefer `self.emit(event)` for events, which\n    /// handles tagging automatically.\n    pub fn emit_public_log_unsafe<T>(_self: Self, tag: Field, log: T)\n    where\n        T: Serialize,\n    {\n        // We use a Writer to serialize the log directly after the tag, avoiding an extra O(n) copy that would\n        // result from serializing first and then prepending the tag.\n        let mut writer: Writer<1 + <T as Serialize>::N> = Writer::new();\n        writer.write(tag);\n        Serialize::stream_serialize(log, &mut writer);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_public_log(writer.finish().as_vector()) };\n    }\n\n    /// Checks if a given note hash exists in the note hash tree at a particular leaf_index.\n    ///\n    /// # Arguments\n    /// * `note_hash` - The note hash to check for existence\n    /// * `leaf_index` - The index where the note hash should be located\n    ///\n    /// # Returns\n    /// * `bool` - True if the note hash exists at the specified index\n    ///\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::note_hash_exists(note_hash, leaf_index)\n        }\n    }\n\n    /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message tree at a particular leaf index.\n    ///\n    /// Common use cases include token bridging, cross-chain governance, and triggering L2 actions based on L1 events.\n    ///\n    /// This function should be called before attempting to consume an L1-to-L2 message.\n    ///\n    /// # Arguments\n    /// * `msg_hash` - Hash of the L1-to-L2 message to check\n    /// * `msg_leaf_index` - The index where the message should be located\n    ///\n    /// # Returns\n    /// * `bool` - True if the message exists at the specified index\n    ///\n    /// # Advanced\n    /// * Uses the AVM l1_to_l2_msg_exists opcode for tree lookup\n    /// * Messages are copied from L1 Inbox to L2 by block proposers\n    ///\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n        unsafe {\n            avm::l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64)\n        }\n    }\n\n    /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.\n    ///\n    /// Note that unsiloed nullifiers are not the actual values stored in the nullifier tree: they are first siloed via\n    /// [`crate::hash::compute_siloed_nullifier`] with the emitting contract's address.\n    ///\n    /// ## Use Cases\n    ///\n    /// Nullifiers are typically used as a _privacy-preserving_ record of a one-time action, but they can also be used\n    /// to efficiently record _public_ one-time actions as well. This is cheaper than using public storage, and has the\n    /// added benefit of the nullifier being emittable from a private function.\n    ///\n    /// An example is to check whether a contract has been published: we emit a nullifier that is deterministic and\n    /// which has a _public_ preimage.\n    ///\n    /// ## Public vs Private\n    ///\n    /// In general, one should not attempt to prove nullifier non-existence in private, as that will not consider the\n    /// possibility of the nullifier having been emitted in any transaction between the anchor block and the inclusion\n    /// block. Private functions instead prove existence via\n    /// [`crate::context::PrivateContext::assert_nullifier_exists`]\n    /// and 'prove' non-existence by _emitting_ the nullifer, which would cause the transaction to fail if the\n    /// nullifier existed.\n    ///\n    /// This is not the case in public functions, which **do** have access to the tip of the blockchain and so can\n    /// reliably prove whether a nullifier exists or not.\n    ///\n    /// ## Safety\n    ///\n    /// While it is safe to rely on this function's return value to determine if a nullifier exists or not, it is often\n    /// **not** safe to infer additional information from that. In particular, it is **unsafe** to infer that the\n    /// existence of a nullifier emitted from a private function implies that all other side-effects of said private\n    /// execution have been completed, more concretely that any enqueued public calls have been executed.\n    ///\n    /// For example, if a function in contract `A` privately emits nullifier `X` and then enqueues public function `Y`,\n    /// then it is **unsafe** for a contract `B` to infer that `Y` has alredy executed simply because `X` exists.\n    ///\n    /// This is because **all** private transaction effects are committed _before_ enqueued public functions are run\n    /// (in\n    /// order to not reveal detailed timing information about the transaction), so it is possible to observe a\n    /// nullifier that was emitted alongside the enqueuing of a public call **before** said call has been completed.\n    ///\n    /// ## Cost\n    ///\n    /// This emits the `CHECKNULLIFIEREXISTS` opcode, which conceptually performs a merkle inclusion proof on the\n    /// nullifier tree (both when the nullifier exists and when it doesn't).\n    pub fn nullifier_exists_unsafe(_self: Self, unsiloed_nullifier: Field, contract_address: AztecAddress) -> bool {\n        let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::nullifier_exists(siloed_nullifier)\n        }\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2) -- effectively marking it as \"read\".\n    ///\n    /// Use this function if you only want the message to ever be \"referred to\" once. Once consumed using this method,\n    /// the message cannot be consumed again, because a nullifier is emitted. If your use case wants for the message to\n    /// be read unlimited times, then you can always read any historic message from the L1-to-L2 messages tree, using\n    /// the `l1_to_l2_msg_exists` method. Messages never technically get deleted from that tree.\n    ///\n    /// The message will first be inserted into an Aztec \"Inbox\" smart contract on L1. It will not be available for\n    /// consumption immediately. Messages get copied-over from the L1 Inbox to L2 by the next Proposer in batches. So\n    /// you will need to wait until the messages are copied before you can consume them.\n    ///\n    /// # Arguments\n    /// * `content` - The message content that was sent from L1\n    /// * `secret` - Secret value used for message privacy (if needed)\n    /// * `sender` - Ethereum address that sent the message\n    /// * `leaf_index` - Index of the message in the L1-to-L2 message tree\n    ///\n    /// # Advanced\n    /// * Validates message existence in the L1-to-L2 message tree\n    /// * Prevents double-consumption by emitting a nullifier\n    /// * Message hash is computed from all parameters + chain context\n    /// * Will revert if message doesn't exist or was already consumed\n    ///\n    pub fn consume_l1_to_l2_message(self: Self, content: Field, secret: Field, sender: EthAddress, leaf_index: Field) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(!self.nullifier_exists_unsafe(nullifier, self.this_address()), \"L1-to-L2 message is already nullified\");\n        assert(self.l1_to_l2_msg_exists(message_hash, leaf_index), \"Tried to consume nonexistent L1-to-L2 message\");\n\n        self.push_nullifier_unsafe(nullifier);\n    }\n\n    /// Sends an \"L2 -> L1 message\" from this function (Aztec, L2) to a smart contract on Ethereum (L1). L1 contracts\n    /// which are designed to send/receive messages to/from Aztec are called \"Portal Contracts\".\n    ///\n    /// Common use cases include withdrawals, cross-chain asset transfers, and triggering L1 actions based on L2 state\n    /// changes.\n    ///\n    /// The message will be inserted into an Aztec \"Outbox\" contract on L1, when this transaction's block is proposed\n    /// to L1. Sending the message will not result in any immediate state changes in the target portal contract. The\n    /// message will need to be manually consumed from the Outbox through a separate Ethereum transaction: a user will\n    /// need to call a function of the portal contract -- a function specifically designed to make a call to the Outbox\n    /// to consume the message. The message will only be available for consumption once the _epoch_ proof has been\n    /// submitted. Given that there are multiple Aztec blocks within an epoch, it might take some time for this epoch\n    /// proof to be submitted -- especially if the block was near the start of an epoch.\n    ///\n    /// # Arguments\n    /// * `recipient` - Ethereum address that will receive the message\n    /// * `content` - Message content (32 bytes as a Field element)\n    ///\n    pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::send_l2_to_l1_msg(recipient, content) };\n    }\n\n    /// Calls a public function on another contract.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `contract_address` - Address of the contract to call\n    /// * `function_selector` - Function to call on the target contract\n    /// * `args` - Arguments to pass to the function\n    /// * `gas_opts` - An optional allocation of gas to the called function.\n    ///\n    /// # Returns\n    /// * `[Field]` - Return data from the called function\n    ///\n    pub unconstrained fn call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Makes a read-only call to a public function on another contract.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function cannot modify state or emit events. Any nested\n    /// calls are constrained to also be staticcalls.\n    ///\n    /// Useful for querying data from other contracts safely.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `contract_address` - Address of the contract to call\n    /// * `function_selector` - Function to call on the target contract\n    /// * `args` - Array of arguments to pass to the called function\n    /// * `gas_opts` - An optional allocation of gas to the called function.\n    ///\n    /// # Returns\n    /// * `[Field]` - Return data from the called function\n    ///\n    pub unconstrained fn static_call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Adds a new note hash to the Aztec blockchain's global Note Hash Tree.\n    ///\n    /// Notes are ordinarily constructed and emitted by _private_ functions, to ensure that both the content of the\n    /// note, and the contract that emitted the note, stay private.\n    ///\n    /// There are however some useful patterns whereby a note needs to contain _public_ data. The ability to push a new\n    /// note_hash from a _public_ function means that notes can be injected with public data immediately -- as soon as\n    /// the public value is known. The slower alternative would be to submit a follow-up transaction so that a private\n    /// function can inject the data. Both are possible on Aztec.\n    ///\n    /// Search \"Partial Note\" for a very common pattern which enables a note to be \"partially\" populated with some data\n    /// in a _private_ function, and then later \"completed\" with some data in a public function.\n    ///\n    /// # Arguments\n    /// * `note_hash` - The hash of the note to add to the tree\n    ///\n    /// # Advanced\n    /// * The note hash will be siloed with the contract address by the protocol\n    ///\n    pub fn push_note_hash(_self: Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_note_hash(note_hash) };\n    }\n\n    /// Creates a new [nullifier](crate::nullifier).\n    ///\n    /// While nullifiers are primarily intended as a _privacy-preserving_ record of a one-time action, they can also\n    /// be used to efficiently record _public_ one-time actions. This function allows creating nullifiers from public\n    /// contract functions, which behave just like those created from private functions.\n    ///\n    /// ## Safety\n    ///\n    /// This is a low-level function that must be used with great care to avoid subtle corruption of contract state.\n    ///\n    /// In particular, callers must ensure all nullifiers created by a contract are properly domain-separated, so that\n    /// unrelated components don't interfere with one another (e.g. a transaction nullifier accidentally marking a\n    /// variable as initialized). Note nullifiers should only be created via\n    /// [`crate::context::PrivateContext::push_nullifier_for_note_hash`].\n    ///\n    /// ## Advanced\n    ///\n    /// The raw `nullifier` is not what is inserted into the Aztec state tree: it will be first siloed by contract\n    /// address via [`crate::protocol::hash::compute_siloed_nullifier`] in order to prevent accidental or malicious\n    /// interference of nullifiers from different contracts.\n    pub fn push_nullifier_unsafe(_self: Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_nullifier(nullifier) };\n    }\n\n    /// Returns the address of the current contract being executed.\n    ///\n    /// This is equivalent to `address(this)` in Solidity (hence the name). Use this to identify the current contract's\n    /// address, commonly needed for access control or when interacting with other contracts.\n    ///\n    /// # Returns\n    /// * `AztecAddress` - The contract address of the current function being executed.\n    ///\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::address()\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name).\n    ///\n    /// Important Note: If the calling function is a _private_ function, then it had the option of hiding its address\n    /// when enqueuing this public function call. In such cases, this method will return `Option<AztecAddress>::none`.\n    /// If the calling function is a _public_ function, it will always return an `Option<AztecAddress>::some` (i.e. a\n    /// non-null value).\n    ///\n    /// # Returns\n    /// * `Option<AztecAddress>` - The address of the smart contract that called this function (be it an app contract\n    /// or a user's account contract).\n    ///\n    /// # Advanced\n    /// * Value is provided by the AVM sender opcode\n    /// * In nested calls, this is the immediate caller, not the original transaction sender\n    ///\n    pub fn maybe_msg_sender(_self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = unsafe { avm::sender() };\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the function selector of the currently-executing function.\n    ///\n    /// This is similar to `msg.sig` in Solidity, returning the first 4 bytes of the function signature.\n    ///\n    /// # Returns\n    /// * `FunctionSelector` - The 4-byte function identifier\n    ///\n    /// # Advanced\n    /// * Extracted from the first element of calldata\n    /// * Used internally for function dispatch in the AVM\n    ///\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { avm::calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    ///\n    /// Very low-level function: The #[external(\"public\")] macro uses this internally. Smart contract developers\n    /// typically won't need to access this directly as arguments are automatically made available.\n    ///\n    /// # Returns\n    /// * `Field` - Hash of the function arguments\n    ///\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n\n    /// Returns the \"transaction fee\" for the current transaction. This is the final tx fee that will be deducted from\n    /// the fee_payer's \"fee-juice\" balance (in the protocol's Base Rollup circuit).\n    ///\n    /// # Returns\n    /// * `Field` - The actual, final cost of the transaction, taking into account: the actual gas used during the\n    /// setup and app-logic phases, and the fixed amount of gas that's been allocated by the user for the teardown\n    /// phase. I.e. effectiveL2FeePerGas * l2GasUsed + effectiveDAFeePerGas * daGasUsed\n    ///\n    /// This will return `0` during the \"setup\" and \"app-logic\" phases of tx execution (because the final tx fee is not\n    /// known at that time). This will only return a nonzero value during the \"teardown\" phase of execution, where the\n    /// final tx fee can actually be computed.\n    ///\n    /// Regardless of _when_ this function is called during the teardown phase, it will always return the same final tx\n    /// fee value. The teardown phase does not consume a variable amount of gas: it always consumes a pre-allocated\n    /// amount of gas, as specified by the user when they generate their tx.\n    ///\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::transaction_fee()\n        }\n    }\n\n    /// Returns the chain ID of the current network.\n    ///\n    /// This is similar to `block.chainid` in Solidity. Returns the unique identifier for the blockchain network this\n    /// transaction is executing on.\n    ///\n    /// Helps prevent cross-chain replay attacks. Useful if implementing multi-chain contract logic.\n    ///\n    /// # Returns\n    /// * `Field` - The chain ID as a field element\n    ///\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::chain_id()\n        }\n    }\n\n    /// Returns the Aztec protocol version that this transaction is executing under. Different versions may have\n    /// different rules, opcodes, or cryptographic primitives.\n    ///\n    /// This is similar to how Ethereum has different EVM versions.\n    ///\n    /// Useful for forward/backward compatibility checks\n    ///\n    /// Not to be confused with contract versions; this is the protocol version.\n    ///\n    /// # Returns\n    /// * `Field` - The protocol version as a field element\n    ///\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::version()\n        }\n    }\n    /// Returns the current block number.\n    ///\n    /// This is similar to `block.number` in Solidity.\n    ///\n    /// Note: the current block number is only available within a public function (as opposed to a private function).\n    ///\n    /// Note: the time intervals between blocks should not be relied upon as being consistent:\n    /// - Timestamps of blocks fall within a range, rather than at exact regular intervals.\n    /// - Slots can be missed.\n    /// - Protocol upgrades can completely change the intervals between blocks (and indeed the current roadmap plans to\n    /// reduce the time between blocks, eventually). Use `context.timestamp()` for more-reliable time-based logic.\n    ///\n    /// # Returns\n    /// * `u32` - The current block number\n    ///\n    pub fn block_number(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::block_number()\n        }\n    }\n\n    /// Returns the timestamp of the current block.\n    ///\n    /// This is similar to `block.timestamp` in Solidity.\n    ///\n    /// All functions of all transactions in a block share the exact same timestamp (even though technically each\n    /// transaction is executed one-after-the-other).\n    ///\n    /// Important note: Timestamps of Aztec blocks are not at reliably-fixed intervals. The proposer of the block has\n    /// some flexibility to choose a timestamp which is in a valid _range_: Obviously the timestamp of this block must\n    /// be strictly greater than that of the previous block, and must must be less than the timestamp of whichever\n    /// ethereum block the aztec block is proposed to. Furthermore, if the timestamp is not deemed close enough to the\n    /// actual current time, the committee of validators will not attest to the block.\n    ///\n    /// # Returns\n    /// * `u64` - Unix timestamp in seconds\n    ///\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::timestamp()\n        }\n    }\n\n    /// Returns the fee per unit of L2 gas for this transaction (aka the \"L2 gas price\"), as chosen by the user.\n    ///\n    /// L2 gas covers the cost of executing public functions and handling side-effects within the AVM.\n    ///\n    /// # Returns\n    /// * `u128` - Fee per unit of L2 gas\n    ///\n    /// Wallet developers should be mindful that the choice of gas price (which is publicly visible) can leak\n    /// information about the user, e.g.:\n    /// - which wallet software the user is using;\n    /// - the amount of time which has elapsed from the time the user's wallet chose a gas price (at the going rate),\n    /// to the time of tx submission. This can give clues about the proving time, and hence the nature of the tx.\n    /// - the urgency of the transaction (which is kind of unavoidable, if the tx is indeed urgent).\n    /// - the wealth of the user.\n    /// - the exact user (if the gas price is explicitly chosen by the user to be some unique number like 0.123456789,\n    /// or their favorite number). Wallet devs might wish to consider fuzzing the choice of gas price.\n    ///\n    pub fn min_fee_per_l2_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_l2_gas()\n        }\n    }\n\n    /// Returns the fee per unit of DA (Data Availability) gas (aka the \"DA gas price\").\n    ///\n    /// DA gas covers the cost of making transaction data available on L1.\n    ///\n    /// See the warning in `min_fee_per_l2_gas` for how gas prices can be leaky.\n    ///\n    /// # Returns\n    /// * `u128` - Fee per unit of DA gas\n    ///\n    pub fn min_fee_per_da_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_da_gas()\n        }\n    }\n\n    /// Returns the remaining L2 gas available for this transaction.\n    ///\n    /// Different AVM opcodes consume different amounts of gas.\n    ///\n    /// # Returns\n    /// * `u32` - Remaining L2 gas units\n    ///\n    pub fn l2_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::l2_gas_left()\n        }\n    }\n\n    /// Returns the remaining DA (Data Availability) gas available for this transaction.\n    ///\n    /// DA gas is consumed when emitting data that needs to be made available on L1, such as public logs or state\n    /// updates. All of the side-effects from the private part of the tx also consume DA gas before execution of any\n    /// public functions even begins.\n    ///\n    /// # Returns\n    /// * `u32` - Remaining DA gas units\n    ///\n    pub fn da_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::da_gas_left()\n        }\n    }\n\n    /// Checks if the current execution is within a staticcall context, where no state changes or logs are allowed to\n    /// be emitted (by this function or any nested function calls).\n    ///\n    /// # Returns\n    /// * `bool` - True if in staticcall context, false otherwise\n    ///\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::is_static_call()\n        }\n    }\n\n    /// Reads raw field values from public storage. Reads N consecutive storage slots starting from the given slot.\n    ///\n    /// Very low-level function. Users should typically use the public state variable abstractions to perform reads:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The starting storage slot to read from\n    ///\n    /// # Returns\n    /// * `[Field; N]` - Array of N field values from consecutive storage slots\n    ///\n    /// # Generic Parameters\n    /// * `N` - the number of consecutive slots to return, starting from the `storage_slot`.\n    ///\n    pub fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { avm::storage_read(storage_slot + i as Field, self.this_address().to_field()) };\n        }\n        out\n    }\n\n    /// Reads a typed value from public storage.\n    ///\n    /// Low-level function. Users should typically use the public state variable abstractions to perform reads:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The storage slot to read from\n    ///\n    /// # Returns\n    /// * `T` - The deserialized value from storage\n    ///\n    /// # Generic Parameters\n    /// * `T` - The type that the caller expects to read from the `storage_slot`.\n    ///\n    pub 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    /// Writes raw field values to public storage. Writes to N consecutive storage slots starting from the given slot.\n    ///\n    /// Very low-level function. Users should typically use the public state variable abstractions to perform writes:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// Public storage writes take effect immediately.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The starting storage slot to write to\n    /// * `values` - Array of N Fields to write to storage\n    ///\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { avm::storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    /// Writes a typed value to public storage.\n    ///\n    /// Low-level function. Users should typically use the public state variable abstractions to perform writes:\n    /// PublicMutable & PublicImmutable.\n    ///\n    /// # Arguments\n    /// * `storage_slot` - The storage slot to write to\n    /// * `value` - The typed value to write to storage\n    ///\n    /// # Generic Parameters\n    /// * `T` - The type to write to storage.\n    ///\n    pub fn storage_write<T>(self, storage_slot: Field, value: T)\n    where\n        T: Packable,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n"
     },
     "72": {
       "function_locations": [
@@ -4119,7 +3763,7 @@
           "start": 2891
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
       "source": "use crate::oracle::{execution::{get_utility_context, UtilityContextData}, 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 From<UtilityContextData> for UtilityContext {\n    fn from(data: UtilityContextData) -> Self {\n        Self { block_header: data.block_header, contract_address: data.contract_address, msg_sender: data.msg_sender }\n    }\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"
     },
     "74": {
@@ -4145,7 +3789,7 @@
           "start": 6480
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/contract_self/contract_self_public.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/contract_self/contract_self_public.nr",
       "source": "//! The `self` contract value for public execution contexts.\n\nuse crate::{\n    context::{calls::{PublicCall, PublicStaticCall}, PublicContext},\n    event::{event_emission::emit_event_in_public, event_interface::EventInterface},\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Core interface for interacting with aztec-nr contract features in public execution contexts.\n///\n/// This struct is automatically injected into every [`external`](crate::macros::functions::external) and\n/// [`internal`](crate::macros::functions::internal) contract function marked with `\"public\"` by the Aztec macro\n/// system and is accessible through the `self` variable.\n///\n/// ## Type Parameters\n///\n/// - `Storage`: The contract's storage struct (defined with [`storage`](crate::macros::storage::storage), or `()` if\n/// the contract has no storage\n/// - `CallSelf`: Macro-generated type for calling contract's own non-view functions\n/// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions\n/// - `CallInternal`: Macro-generated type for calling internal functions\npub struct ContractSelfPublic<Storage, CallSelf, CallSelfStatic, CallInternal> {\n    /// The address of this contract\n    pub address: AztecAddress,\n\n    /// The contract's storage instance, representing the struct to which the\n    /// [`storage`](crate::macros::storage::storage) macro was applied in your contract. If the contract has no\n    /// storage, the type of this will be `()`.\n    ///\n    /// This storage instance is specialized for the current execution context (public) and\n    /// provides access to the contract's state variables.\n    ///\n    /// ## Developer Note\n    ///\n    /// If you've arrived here while trying to access your contract's storage while the `Storage` generic type is set\n    /// to unit type `()`, it means you haven't yet defined a Storage struct using the\n    /// [`storage`](crate::macros::storage::storage) macro in your contract. For guidance on setting this up, please\n    /// refer to our docs: https://docs.aztec.network/developers/docs/guides/smart_contracts/storage\n    pub storage: Storage,\n\n    /// The public execution context.\n    pub context: PublicContext,\n\n    /// Provides type-safe methods for calling this contract's own non-view functions.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self.some_public_function(args)\n    /// ```\n    pub call_self: CallSelf,\n\n    /// Provides type-safe methods for calling this contract's own view functions.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.call_self_static.some_view_function(args)\n    /// ```\n    pub call_self_static: CallSelfStatic,\n\n    /// Provides type-safe methods for calling internal functions.\n    ///\n    /// Example API:\n    /// ```noir\n    /// self.internal.some_internal_function(args)\n    /// ```\n    pub internal: CallInternal,\n}\n\nimpl<Storage, CallSelf, CallSelfStatic, CallInternal> ContractSelfPublic<Storage, CallSelf, CallSelfStatic, CallInternal> {\n    /// Creates a new `ContractSelfPublic` instance for a public function.\n    ///\n    /// This constructor is called automatically by the macro system and should not be called directly.\n    pub fn new(\n        context: PublicContext,\n        storage: Storage,\n        call_self: CallSelf,\n        call_self_static: CallSelfStatic,\n        internal: CallInternal,\n    ) -> Self {\n        Self { context, storage, address: context.this_address(), call_self, call_self_static, internal }\n    }\n\n    /// The address of the contract address that made this function call.\n    ///\n    /// This is similar to Solidity's `msg.sender` value.\n    ///\n    /// ## Incognito Calls\n    ///\n    /// Contracts can call public functions from private ones hiding their identity (see\n    ///\n    /// [`ContractSelfPrivate::enqueue_incognito`](crate::contract_self::ContractSelfPrivate::enqueue_incognito)).\n    /// This function reverts when executed in such a context.\n    ///\n    /// If you need to handle these cases, use [`PublicContext::maybe_msg_sender`].\n    pub fn msg_sender(self: Self) -> AztecAddress {\n        self.context.maybe_msg_sender().unwrap()\n    }\n\n    /// Emits an event publicly.\n    ///\n    /// Public events are emitted as plaintext and are therefore visible to everyone. This is is the same as Solidity\n    /// events on EVM chains.\n    ///\n    /// Unlike private events, they don't require delivery of an event message.\n    ///\n    /// # Example\n    /// ```noir\n    /// #[event]\n    /// struct Update { value: Field }\n    ///\n    /// #[external(\"public\")]\n    /// fn publish_update(value: Field) {\n    ///     self.emit(Update { value });\n    /// }\n    /// ```\n    ///\n    /// # Cost\n    ///\n    /// Public event emission is achieved by emitting public transaction logs. A total of `N+1` fields are emitted,\n    /// where `N` is the serialization length of the event.\n    pub unconstrained fn emit<Event>(&mut self, event: Event)\n    where\n        Event: EventInterface + Serialize,\n    {\n        emit_event_in_public(self.context, event);\n    }\n\n    /// Makes a public contract call.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.call(Token::at(address).transfer_in_public(recipient, amount));\n    /// ```\n    ///\n    pub unconstrained fn call<let M: u32, let N: u32, T>(self, call: PublicCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.call(self.context)\n    }\n\n    /// Makes a public read-only contract call.\n    ///\n    /// This is similar to Solidity's `staticcall`. The called function cannot modify state or emit events. Any nested\n    /// calls are constrained to also be static calls.\n    ///\n    /// Will revert if the called function reverts or runs out of gas.\n    ///\n    /// # Arguments\n    /// * `call` - The object representing the read-only public function to invoke.\n    ///\n    /// # Returns\n    /// * `T` - Whatever data the called function has returned.\n    ///\n    /// # Example\n    /// ```noir\n    /// self.view(Token::at(address).balance_of_public(recipient));\n    /// ```\n    ///\n    pub unconstrained fn view<let M: u32, let N: u32, T>(self, call: PublicStaticCall<M, N, T>) -> T\n    where\n        T: Deserialize,\n    {\n        call.view(self.context)\n    }\n}\n"
     },
     "77": {
@@ -4195,7 +3839,7 @@
           "start": 3259
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/ephemeral/mod.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/ephemeral/mod.nr",
       "source": "use crate::oracle::ephemeral_oracles;\nuse crate::protocol::traits::{Deserialize, Serialize};\nuse crate::protocol::utils::{reader::Reader, writer::Writer};\nuse crate::unconstrained_array::{ArrayOracles, UnconstrainedArray};\n\n/// A dynamically sized array that exists only during a single contract call frame.\n///\n/// Ephemeral arrays are backed by in-memory storage on the PXE side rather than a persistent database. Each contract\n/// call frame gets its own isolated slot space of ephemeral arrays. Child simulations cannot see the parent's\n/// ephemeral arrays, and vice versa.\n///\n/// Each logical array operation (push, pop, get, etc.) is a single oracle call, making ephemeral arrays significantly\n/// cheaper than capsule arrays.\n///\n/// ## Use Cases\n///\n/// Ephemeral arrays are designed for passing data between PXE (TypeScript) and contracts (Noir) during simulation,\n/// for example, note validation requests or event validation responses. This data type is appropriate for data that\n/// is not supposed to be persisted.\n///\n/// For data that needs to persist across simulations, contract calls, etc, use\n/// [`CapsuleArray`](crate::capsules::CapsuleArray) instead.\n///\n/// For data that must be shared across all frames of the same contract (private and utility) within one top-level PXE\n/// call (transaction simulation or utility call) but not persisted, use\n/// [`TransientArray`](crate::transient::TransientArray).\npub type EphemeralArray<T> = UnconstrainedArray<T, EphemeralOracles>;\n\npub struct EphemeralOracles {}\n\nimpl ArrayOracles for EphemeralOracles {\n    unconstrained fn len_oracle(slot: Field) -> u32 {\n        ephemeral_oracles::len_oracle(slot)\n    }\n\n    unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32 {\n        ephemeral_oracles::push_oracle(slot, values)\n    }\n\n    unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N] {\n        ephemeral_oracles::pop_oracle(slot)\n    }\n\n    unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N] {\n        ephemeral_oracles::get_oracle(slot, index)\n    }\n\n    unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]) {\n        ephemeral_oracles::set_oracle(slot, index, values)\n    }\n\n    unconstrained fn remove_oracle(slot: Field, index: u32) {\n        ephemeral_oracles::remove_oracle(slot, index)\n    }\n\n    unconstrained fn clear_oracle(slot: Field) {\n        ephemeral_oracles::clear_oracle(slot)\n    }\n}\n\n/// Serializes an `EphemeralArray` as its slot, allowing oracle function signatures to use ephemeral array types\n/// instead of opaque `Field` slots.\nimpl<T> Serialize for UnconstrainedArray<T, EphemeralOracles> {\n    let N: u32 = 1;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.slot]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.slot);\n    }\n}\n\n/// Deserializes a single Field into an `EphemeralArray` handle, treating the field value as the slot identifier.\nimpl<T> Deserialize for UnconstrainedArray<T, EphemeralOracles> {\n    let N: u32 = 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { slot: fields[0] }\n    }\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { slot: reader.read() }\n    }\n}\n\n#[crate::unconstrained_array::test_suite::unconstrained_array_tests(quote { crate::ephemeral::EphemeralOracles })]\nmod test {}\n"
     },
     "79": {
@@ -4217,7 +3861,7 @@
           "start": 2814
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/event/event_interface.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/event/event_interface.nr",
       "source": "use crate::{event::EventSelector, messages::logs::event::MAX_EVENT_SERIALIZED_LEN};\nuse crate::protocol::{\n    constants::DOM_SEP__EVENT_COMMITMENT,\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_bounded_vec},\n    traits::{Serialize, ToField},\n};\n\npub trait EventInterface {\n    fn get_event_type_id() -> EventSelector;\n}\n\n/// A private event's commitment is a value stored on-chain which is used to verify that the event was indeed emitted.\n///\n/// It requires a `randomness` value that must be produced alongside the event in order to perform said validation.\n/// This random value prevents attacks in which someone guesses plausible events (e.g. 'Alice transfers to Bob an\n/// amount of 10'), since they will not be able to test for existence of their guessed events without brute-forcing the\n/// entire `Field` space by guessing `randomness` values.\npub fn compute_private_event_commitment<Event>(event: Event, randomness: Field) -> Field\nwhere\n    Event: EventInterface + Serialize,\n{\n    poseidon2_hash_with_separator(\n        [randomness, Event::get_event_type_id().to_field()].concat(event.serialize()),\n        DOM_SEP__EVENT_COMMITMENT,\n    )\n}\n\n/// Unconstrained variant of [`compute_private_event_commitment`] which takes the event in serialized form.\n///\n/// This function is unconstrained as the mechanism it uses to compute the commitment would be very inefficient in a\n/// constrained environment (due to the hashing of a dynamically sized array). This is not an issue as it is typically\n/// invoked when processing event messages, which is an unconstrained operation.\npub unconstrained fn compute_private_serialized_event_commitment(\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    randomness: Field,\n    event_type_id: Field,\n) -> Field {\n    let mut commitment_preimage =\n        BoundedVec::<_, 2 + MAX_EVENT_SERIALIZED_LEN>::from_array([randomness, event_type_id]);\n    commitment_preimage.extend_from_bounded_vec(serialized_event);\n\n    poseidon2_hash_with_separator_bounded_vec(commitment_preimage, DOM_SEP__EVENT_COMMITMENT)\n}\n\nmod test {\n    use crate::event::event_interface::{\n        compute_private_event_commitment, compute_private_serialized_event_commitment, EventInterface,\n    };\n    use crate::messages::logs::event::MAX_EVENT_SERIALIZED_LEN;\n    use crate::protocol::traits::{Serialize, ToField};\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 max_size_serialized_event_commitment() {\n        let serialized_event = BoundedVec::from_array([0; MAX_EVENT_SERIALIZED_LEN]);\n        let _ = compute_private_serialized_event_commitment(serialized_event, 0, 0);\n    }\n\n    #[test]\n    unconstrained fn event_commitment_equivalence() {\n        let event = MockEvent::new(VALUE).build_event();\n\n        assert_eq(\n            compute_private_event_commitment(event, RANDOMNESS),\n            compute_private_serialized_event_commitment(\n                BoundedVec::from_array(event.serialize()),\n                RANDOMNESS,\n                MockEvent::get_event_type_id().to_field(),\n            ),\n        );\n    }\n}\n"
     },
     "81": {
@@ -4247,7 +3891,7 @@
           "start": 985
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/event/event_selector.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/event/event_selector.nr",
       "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": {
@@ -4329,7 +3973,7 @@
           "start": 12385
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/facts/mod.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/facts/mod.nr",
       "source": "//! Per-contract 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\nmod origin_state;\npub use origin_state::OriginBlockState;\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 retractable fact's origin block.\n#[derive(Deserialize, Eq, Serialize)]\npub struct RetractableFactOrigin {\n    pub block_number: u32,\n    pub block_hash: Field,\n    pub block_state: OriginBlockState,\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<RetractableFactOrigin>,\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_finalized_at_latest_block() {\n        let (env, scope) = setup();\n        let origin_block_number = env.last_block_number();\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: origin_block_number, 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 = fact.origin_block.unwrap();\n            assert_eq(origin.block_number, origin_block_number);\n            assert_eq(origin.block_hash, 0xabc);\n            // TXE finalizes every mined block, so an origin at the latest block is Finalized.\n            assert(origin.block_state.is_finalized());\n        });\n    }\n\n    #[test]\n    unconstrained fn retractable_fact_above_proven_tip_is_pending() {\n        let (env, scope) = setup();\n        let future_block_number = env.last_block_number() + 100;\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: future_block_number, block_hash: 0xabc },\n            );\n\n            let origin = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID)\n                .unwrap()\n                .facts\n                .get(0)\n                .origin_block\n                .unwrap();\n            assert(origin.block_state.is_pending());\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": {
@@ -4391,7 +4035,7 @@
           "start": 3216
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/facts/origin_state.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/noir-projects/aztec-nr/aztec/src/facts/origin_state.nr",
       "source": "use crate::protocol::{traits::{Deserialize, Serialize}, utils::reader::Reader};\n\n/// Chain state of a retractable fact's origin block, mirroring the L2 chain tips.\n#[derive(Serialize)]\npub struct OriginBlockState {\n    // Noir has no enums, so this wraps a `u8` discriminant. The discriminant values must stay in sync with the\n    // TypeScript `OriginBlockState` enum in `yarn-project/pxe/src/storage/fact_store/origin_state.ts`, which PXE\n    // serializes into the `Fact` oracle response that `from_u8` below deserializes.\n    inner: u8,\n}\n\nimpl OriginBlockState {\n    pub fn pending() -> Self {\n        Self { inner: 1 }\n    }\n\n    pub fn proven() -> Self {\n        Self { inner: 2 }\n    }\n\n    pub fn finalized() -> Self {\n        Self { inner: 3 }\n    }\n\n    /// Whether the origin block is still above the proven tip.\n    pub fn is_pending(self) -> bool {\n        self == Self::pending()\n    }\n\n    /// Whether the origin block is proven but not yet finalized.\n    pub fn is_proven(self) -> bool {\n        self == Self::proven()\n    }\n\n    /// Whether the origin block is finalized, and thus facts related to it can no longer be retracted.\n    pub fn is_finalized(self) -> bool {\n        self == Self::finalized()\n    }\n\n    fn from_u8(inner: u8) -> Self {\n        let state = Self { inner };\n        assert(state.is_valid(), \"unrecognized origin state\");\n        state\n    }\n\n    fn is_valid(self) -> bool {\n        self.is_pending() | self.is_proven() | self.is_finalized()\n    }\n}\n\nimpl Eq for OriginBlockState {\n    fn eq(self, other: Self) -> bool {\n        self.inner == other.inner\n    }\n}\n\nimpl Deserialize for OriginBlockState {\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\nmod test {\n    use crate::protocol::traits::{Deserialize, Serialize};\n    use super::OriginBlockState;\n\n    #[test]\n    fn query_functions_identify_each_state() {\n        assert(OriginBlockState::pending().is_pending());\n        assert(!OriginBlockState::pending().is_proven());\n        assert(!OriginBlockState::pending().is_finalized());\n\n        assert(OriginBlockState::proven().is_proven());\n        assert(!OriginBlockState::proven().is_pending());\n        assert(!OriginBlockState::proven().is_finalized());\n\n        assert(OriginBlockState::finalized().is_finalized());\n        assert(!OriginBlockState::finalized().is_pending());\n        assert(!OriginBlockState::finalized().is_proven());\n    }\n\n    #[test]\n    fn origin_state_roundtrips_through_serialization() {\n        let pending = OriginBlockState::pending();\n        let proven = OriginBlockState::proven();\n        let finalized = OriginBlockState::finalized();\n        assert(OriginBlockState::deserialize(pending.serialize()) == pending);\n        assert(OriginBlockState::deserialize(proven.serialize()) == proven);\n        assert(OriginBlockState::deserialize(finalized.serialize()) == finalized);\n    }\n\n    #[test(should_fail_with = \"unrecognized origin state\")]\n    fn deserializing_invalid_state_fails() {\n        let _ = OriginBlockState::deserialize([99]);\n    }\n}\n"
     },
     "96": {
@@ -4429,7 +4073,7 @@
           "start": 5055
         }
       ],
-      "path": "/home/nventuro/pkg-1/noir-projects/aztec-nr/aztec/src/keys/ecdh_shared_secret.nr",
+      "path": "/home/aztec-dev/aztec-packages-private/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"
     }
   },
@@ -4478,7 +4122,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rZfdbqMwEIXfhetceMbjv7zKqqrSlFaREIlostKqyrvvmPoQqGRUsXsTDgf47LFnhvDZvLYvt/fnU/92/mj2vz6bl+HUdaf35+58PFxP517dz8bkHyI9uJ0eXbNPemQ9J85CDbIqrIGIRYhV4bPITlDhshOzUIeNCq8OZ7DPTr45ehX55kRfgk2+pE8x50s6Oos0e2uySEV4vWRJRRSIVESCk4pjjUDAITgEh+EwHAvHwhE4AicH+CViER6OhxPghFBEJIgShU0GwkGUIQSTF1OAQhaiAIUZogDFEkQBihgIABGFIApBFOIB9BgiABgwRAQwYghsgWALJBWgMxaiAB0xRAE6JogM1IxyOce+BByBk3NsFOPkRxGKGCc/Cjjj5LMYs2UUqYgEJxXHGwtRHvdEEL4IhsNwMFWPqfpxYqIi5Plozgebb9acD+MW+Pt916D0nq9D2+bKm9WiVujlMLT9tdn3t67bNb8P3W286eNy6Mfj9TDoVS2Itn/VowLfTl2b1X33eNrUH3XG+fK0IwoTQAt+gaA6QoznghBiqSK4jqCYEIO2AVNF2DqCjWNbGKrtI5SwZMgKI0QQ0iyO6H8aB3MgELTuq3H4OkKbjCsIK949opAFIfyHlYj/uhJreeXTlFeB6ytBKwxLRAlrQSSmFgitZCeZiInoSy1tiyWmKRbx1VhWECRTJKQNeEI4WgaylpzaR1Akqm2qroarQzxjGt6ZLWuxCMS5WiBrBGemWnckWwg2yUTgVF3MtJJaE0HfrxOAI/+YoO9cEDhWCbySmcElNIvgZwtB39oNrzULoqlZ0Cy53RKx0jetMWgW1sy79zeErO2HeySFdcK1UFbXU6YdCWbTjjgzdRxrtxECMtMlv4kwr69thDBVR+CNhIDMDCltIkSLKKKvz8GuvQgN5sCznBL78yAsXkBh40J6D4KP9RJfbTPh0WZCXLSZJz07HE/D4tPpnlnD6fDSteX07dYfZ1evfy64gk+vy3A+tq+3oc2kx/eX/nX8RU525OUpf4WNp7TTD6qnex79Lw==",
+      "debug_symbols": "rZfRbuIwEEX/Jc88eMbjsc2vrKqK0rRCQoAorLSq+Pcdp76BVHJUZfeF3Fwnxx57PCaf3Wv/cn1/3h3ejh/d+tdn93Le7fe79+f9cbu57I4Hcz87V36I7BJWdg3dOtuV7Z64CDPIm/AOIlUh3oQWUZxoIhQnFWEOOxNqDhewFqc8nNREeTjTl2BXmuwt5tJkvbNIt/auiFyFWpMnE0kgchUZTq6OdwIBh+AQHIbDcDwcD0fgCJwS4JdIVSgchRPhxFhFIogahc8OIkDULgSDF1eBQh6iAoUZogLFE0QFijgIABGFIApBFKIAKrqIAEZ0kQBM6AJLIFgCyRUYnIeowEAMUYGBCaIALaNCybEvAUfglBwbxDD4QcQqhsEPAs4w+CKGbBlEriLDydVR5yHq60oEoVUwHIaDoSqGqsPAxEQs47Gcj748bDkfhyXQ223VYes9X859X3bew160HXranPvDpVsfrvv9qvu92V+Hhz5Om8NwvWzO1moboj+82tWAb7t9X9RtdX/btV8NLmh9OxDFEWAbfoKgNkKcckUIsTQR3EZQyojByoBrInwbwc6ytzJMRx4hccqQGUYcCfkhjqQ/jYM5Egi275txaBthRSZUhBcN9yhkQoj/YSbSv87EXF5pHvMqcnsmaIbhyQXBXJCLoRUIzWQnuYSB2KGWl8WS8hiLaDOWGQQJAUFWgEdEoGkgc8mpGpAZpqM0ZyO0IcoYhga3ZC4mgYTQCmSOENy41wPJEoLPMhI4Nyczz6TWSLDzdQRw4h8T7MwFgVOTwDOZGUNGsYj6MBH0rdzwXLEgGosFPSR3mCJm6qZ3zgPhHqv3N4TMrUe4J4UPwq1QZudTxhWJbtGKBDdWHO+XESIyM2RdRHjcX8sIcdwdkRcSIjIz5ryIkDyiSNoeg587CB3GwA85Jf7nQXgcQHHhRKqCoKm9xWfLTLyXmZgmZebJ7jbb3Xny6XQrrPNu87Lv6+3b9bB9aL38OaEFn16n83Hbv17PfSHdv7/sr+MvssOPVJ7KV9hwSyv7oHq6ld7/Ag==",
       "is_unconstrained": true,
       "name": "check_block_number"
     },
@@ -4526,7 +4170,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rZfRbuIwEEX/Jc88eMbjsc2vVFVFaVohIUAUVlpV/PuOU98QKjli2X0hNzfxsceZmZCv7q1/PX+8bHbv+89u+fTVvR432+3m42W7X69Om/3O3K/OlR8iO4SFHUO3zHZkOycuwgzyJryDSFWIN6FFFCeaCMVJRZjDzoSawwWsxSk3JzVRbs70LdiVSzaKuVyy2VmkW3pXRK5C7ZInE0kgchUZTq6OdwIBh+AQHIbDcDwcD0fgCJwS4LdIVSgchRPhxFhFIogahc8OIkDUKQSLF1eBQh6iAoUZogLFE0QFijgIABGFIApBFKIAKqaIAEZMkQBMmAKPQPAIJFdgcB6iAgMxRAUGJogCtIwKJce+BRyBU3JsEMPiBxGrGBY/CDjD4osYsmUQuYoMJ1dHnYeow5UIQqtgOAwHS1UsVYeFiYlY1mM5H3252XI+Do9AL5dFh9J7OR37vlTepBatQg+rY787dcvdebtddL9W2/Nw0+dhtRuOp9XRrlpB9Ls3OxrwfbPti7osrqNde2hwQevoQBRHgBX8DYLaCHHKFSHE0kRwG0EpIwZrA66J8G0Eu8C+Mkz7ayjxliEzjJhAyJM4kt4bB3MkEKzum3FoG2FNJlSEFw3XKOSGEP/DTqR/3Ym5vNI85lXk9k7QDMMTUcZeEIlrBUIz2UkuYSH2UsuPxZLyGItoM5YZRIqxElK+riHQbRjzqelRZaYlNfcitCGaEUeclvr9O3ENY1qlP8KYGZ89nkUOD41XzE/OxeY+5pmcyoJe5a6JzYnvJtjLFgROTQLPpGQMGV0iKk3K60ef4bkuQTR2CZpkdbhFzDRM7xy6hHfTtv0DMZOU5MNYoKaFW6HM7qeMTyS6h55IcGOr8f4xQsTrJ2R9iKCMjdDwGCE6rCHyg4SIzIyTJvM3hOQRRdL2GvzcG9CNXWqSU+LvD8LjzRMf3EhVEDS1S3y2y4x/Rpynmy7zbGer9eZ488l0KajjZvW67evp+3m3nlw9/T7gCj65Dsf9un87H/tCun532V/GJwqyIJXn8vVVTjXYaXy+lNn/AA==",
+      "debug_symbols": "rZfRbts8DIXfxde9ECmKlPoqQ1GkrTsECNIiS37gR5F3H+XqOE4BGV22m/j42PpESpQUfwwv49Pp5+N2//r2a7j/8TE8Hba73fbn4+7teXPcvu3d/RhC/SHyS7rzaxrui1/Z74mrcIOiixggchMSXWgV1TEXqTq5Cnc4uFB3uIK1OvXlrC7qy4U+BYf6yFsx10feO4sM9zFUUZpQfxTJRRaI0kSBU5oTg0DAITgEh+EwnAgnwhE4Aqcm+ClyEwpH4RgcsyYyQbQsYgkQCaJ1IQheQgMKRYgGFGaIBpRIEA0oEiAARBaCLARZiAKo6MIANHSRAczoAlMgmAIpDZhChGjARAzRgIkJogK9olKtsU8BR+DUGpvEFPwkrIkp+EnAmYKvYqqWSZQmCpzSHA0RojVXIghtguEwHISqCFWnwMSF1Xi85i3Wl73mbZoCPZ/vBiy9x+NhHOvKW6xFX6Hvm8O4Pw73+9Nudzf8t9mdppd+vW/20/W4OfhTXxDj/sWvDnzd7saqzneX1qHfNIWkrXUishngC/4KQX2EBOWGEGLpIriPoFyQg28DoYuIfQQHr97GcG08Q+yaISsMmwllkUfW7+bBbASCr/tuHtpH+CaTGiKKpksWckWwfzAS+W9HYq2utMx1ZdwfCVphRApJMBYULPUSoZXqpJARiB9q5bZccplzEe3msoLIZo2QyyWGRNdprJamKRCuc+yORepDtCAPWy7174/EJY3lKv2Sxkr7EjEXJd3Ufh4DCsG641hWaqqgovxgnQGc+dsEP2xB4Nwl8EpJWirYJUxpsby+7DO8tksQzbsELao6XSNWNswYQgQiLLftL4iVoqSYCBXlWriXyup4yjwjFm6akRTmrSbG2wiG4ycVvYmgjIHQdBvBAmIwvpFgqExbbDJ/QsgRWWTtxxDXTsCAGHhRUxK/n0TEyWM3DqQqCJr7S3x1l5n/jIRIV7vMg99tnreHq0+mc0Udtpun3dhuX0/758XT4//veIJPrvfD2/P4cjqMlXT57vK/jD/IDz1SeahfX/VWk9/aw7n2/hs=",
       "is_unconstrained": true,
       "name": "check_timestamp"
     },
@@ -4541,10 +4185,6 @@
             "error_kind": "string",
             "string": "Index out of bounds"
           },
-          "4215903597095405243": {
-            "error_kind": "string",
-            "string": "offchain message anchor timestamp is implausibly far in the future"
-          },
           "9530675838293881722": {
             "error_kind": "string",
             "string": "Writer did not write all data"
@@ -4656,11 +4296,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": "offchain_receive"
     },
@@ -4713,7 +4353,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "tVlbbls5DN2Lv/OhB6lHtjIoijR1CwOGE7jJAIMiex/yiofXDqCLxDP9KY/o6vAhUqKd37vv+2+vP78eTj+efu3u//q9+3Y+HI+Hn1+PT48PL4enk2h/74L+Eynu7uPdLnIwybv7JLIEk7autq5ksg/ZbN1s3bPJtsgUksk6JAkPqSSTfUi2Ndu62LrK/qqyDtnE36ayDNlt3WUdw90uhwggnkcJKccAoBohyUmDUU3S6MRMzqphBc0AaSBNgWq6ABZNVmZuBkoCKAY0TQMQQDfQoGnY3nW7uEEhAIxsUxjZpEgmdUsWkDJANZATADTqsJJxHbLykkqqI7XUyKStu637WHMYqeaYTI5Uc4ombZ1lnVlBMaCHm4sCNrCUlZIsdSXe8FJYamapLN1VM4BGKZnmJhoKCkRDukvLaoA6QNFzHoABugHN2gDQpAyg2yWjJbMBGoVdiEyO1Be2TBe23JeSACzTpUKjDmfdtZytgg5NN00NGQCaCE2EJiWAaiBDk6EhaKgY0CQPwADdgLbRADBRYbSCsIGwgVCbagAjbCEAEICZaIiiIYqGKBqiaDkCmIlGICSYIBAyTDAIC0wUEFaYqCBsMNFA2GGig7CbiY6z6DiLHhOAmegpApiJngMAA4CQCACEDBMMwgITBYQVJioIG0wsTUoKuoFumhj0TjVUgWJ0VICS6/SeG0jvt4H0gjPkOnYdO3NxluIses0Zcl1zXXNP4XwM3Zk7rEW9hokXJCwcFGmOWR+iqF6xPiVRvRpI7XJWpI3GypKCxMvKkjQHAyX9tCjSJhmIoyPXFdcV11XXVddpbIYYqLuuQ5dDcESO4EvWTjFUgbRXDMFaztGRM5MzkzNrxwzEzsxurThzcWseW/bYsseWPbbcnLm7tQ5mCtkRmCkmR2CmFB2BmXJwRI5gjciZya2xMrcFVaDiuqUiBmJHHUgr0ZDrtBIXxEvlLGipnIFcl1yX2BFYODuLdtRA5DpynXvP7j0vnnZFmt0S3t7udhjNvr6c93udzC5mNZngnh/O+9PL7v70ejze7f5+OL4u/+nX88NpkS8PZ/lUOmh/+i5SCH8cjntFb3fr7jDfSrEW202xVyeQfv0ohVQNHBCYbqFocjcaRZfra0qR5xQyUSajSHJKK0UrH/Wik04hwwsObeoFb3gRdeIcXsh15BRS4VcUZSsQBkOpFwThJh9ymPqwQUFEFVVB3KYU/Q+GceXDFUX+cGWWAAqZ0Hl6oDHNOTgwSlOui4sGSdeRxI3apFCSN1miOQfNOeLaZbHHMOfYqozAKeNU5NFfo6nvSLbqszZQdJq22VYoSd5aUOSa56G0jaMlr69MZT3aStcU/X/IRgr/ORtbBVa6F1hN82ykDY4sLY+rSzCFaSgbVSpjGxyJ2iG3BdO6B0NlfrQbHK2iaWVwdwaO14FsV2j2t6A2atNs1DlJ6QikXnb9J3KxxnHZr+/i2CLoBQQ68d/G4HdGyHHGsPm2c1/f9jx/mLeKM7DPB/K9YZpL3rrIC9pMpto+fQsy/cEH6cqJNn8Utw5ExmTkU2Zdmp1I3ihM8T6FNZLcZ9WdN67PkuBG4XBTdV9FwnxLdeq3DFDIiH0bRV0paruhwjkQHiP5BWw+9NHW7Bn8url43T8xp3geKKz7U0sfnuKTzxepTQlo486Un46Qhio/pK1puK4IqltPss+dAi/eD76m2HrVQ8h+VVwOSu8o+lZF8FqYmSnNQgmboyfSWcMt5yFfMVFTF19FPkNQ0eLcyy0Elw1+E0EN8KCm2wgqarJePOOfIGj+bayVuQdc/1xf1owLv96WxPXFKO1dY3+R5cPj4Xz1x5k3pTofHr4d97b88Xp6vPj05Z9nfII/7jyfnx7331/Pe2Va/8Ijv0n8laVdM9cv+sOZLiUc+UHpy5ta/xc=",
+      "debug_symbols": "tVnbbhs5DP0XP+dBF1KX/MqiKNLULQwYTuAmCyyK/PuSIx6OHUCDxLt9KY/ozuFFpMSZ/N593397/fn1cPrx9Gt3/9fv3bfz4Xg8/Px6fHp8eDk8nUT7exf0n0hxdx/vdpGDSd7dJ5ElmLR1tXUlk33IZutm655NtkWmkEzWIUl4SCWZ7EOyrdnWxdZVnq8q65BN/G0qy5Dd1l3WMdztcogA4nmUkHIMAKoRkpw0GNUkjU7M5KwaVtAMkAbSFKimC2DRZGXmZqAkgGJA0zQAAXQDDZqGx7s+Lm5QCAAj2xRGNimSSX0kC0gZoBrICQAadVjJuA5ZeUkl1ZFaamTS1t3Wfaw5jFRzTCZHqjlFk7bOss6soBjQzc1FARtYykpJlroSb3gpLDWzVJY+VTOARimZ5iYaCgpEQ/qUltUAdYCi+zwAA3QDmrUBoEkZQB+XjJbMBmgUdiEyOVJf2DJd2HJfSgKwTJcKjTqc9allbxV0aLppasgA0ERoIjQpAVQDGZoMDUFDxYAmeQAG6Aa0jQaAiQqjFYQNhA2E2lQDGGELAYAAzERDFA1RNETREEXLEcBMNAIhwQSBkGGCQVhgooCwwkQFYYOJBsIOEx2E3Ux07EXHXvSYAMxETxHATPQcABgAhEQAIGSYYBAWmCggrDBRQdhgYmlSUtANdNPEoGeqoQoUo6MClFyn59xAer4NpAecIdex69iZi7MUZ9FjzpDrmuuaewrnY+jO3GEt6jFMvCBh4aBIc8x6EUX1ivUqierVQGqXsyJtNFaWFCReVpakORgo6a9FkTbJQBwdua64rriuuq66TmMzxEDddR26HIIjcgRfsnaKoQqkvWII1nKOjpyZnJmcWTtmIHZmdmvFmYtb89iyx5Y9tuyx5ebM3a11MFPIjsBMMTkCM6XoCMyUgyNyBGtEzkxujZW5LagCFdctFTEQO+pAWomGXKeVuCBeKmdBS+UM5LrkusSOwMLZWbSjBiLXkevce3bvefG0K9LslvD2drfDaPb15bzf62R2MavJBPf8cN6fXnb3p9fj8W7398PxdflPv54fTot8eTjLr9JB+9N3kUL443DcK3q7W58O80cp1mJPU+zVCaRfP0ohVQMHBKZbKJqcjUbR5fiaUuQ5hUyUySiS7NJK0cpHveikU8jwgkObesEbXkSdOIcXchw5hVT4FUXZCoTBUOoFQbjJhxymPmxQEFFFVRC3KUX/g2Fc+XBFkT9cmSWAQiZ0nm5oTHMODozSlOPiokHSdSRxozYplORNlmjOQXOOuHZZ7DHMObYqI5CeRGNXAtW1Pus7kq36rE7RadpmW6EkuWtBkWueh9I2tpa8vjKVdWsrXVP0/yEbKfznbGwVWOleYDXNs5E2OORdV4eikQ4dzqahbFSpjG1wJGqH3BZM6x4MlfnWbnC0iqaVwd0ZOF4HslmhtYBCcMvTbNQ5SekIpF52/SdyscZx2a/v4tgi6B6FTvy3MfiZEXKcMWze7dzXuz3PL+at4gzs88Flab7PJW8d5AVtJlNtn94Fmf7ghXTlRJtfilsbImMy8imzLs12JG8Upryy8BpJqTSr7rxxfJYENwqHm6r7KhLmW6pT3zJAISP2bRR1pajthgrnQLiM5AvYfOijrdkz+Oh5cbt/Yk7xPFBYn08tfXiKTz5fpDYloI0zUz4dIQ1VPqStabiuCKpbV7LPnQIv7g++pti61UPIflRcDkrvKPpWRfBamJkpzUIJm6Mn0lnDLfshr5ioqYtXkc8QVByZ3MstBJcNfhNBDfCgptsIKmqyXlzjnyBo/jbWytwDrn+uL2vGgV9vS+J6Y5T2rrG/yPLh8XC++uPMm1KdDw/fjntb/ng9PV78+vLPM37BH3eez0+P+++v570yrX/hkW8Sf2Vp18z1i34406WEIx+Uvryp9X8B",
       "is_unconstrained": true,
       "name": "public_dispatch"
     },
@@ -4751,11 +4391,6 @@
             ],
             "length": 66
           },
-          "12706857619424059571": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 37
-          },
           "12820178569648940736": {
             "error_kind": "fmtstring",
             "item_types": [
@@ -4858,11 +4493,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"
     }
@@ -5085,5 +4720,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "0.0.1-commit.a5db02d"
+  "aztec_version": "0.0.1-commit.b8a057fa"
 }