@aztec/standard-contracts 0.0.1-commit.993d240 → 0.0.1-commit.b9865e97

package/artifacts/PublicChecks.json

@@ -35,7 +35,7 @@
           "start": 12880
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "105": {
@@ -65,7 +65,7 @@
           "start": 12234
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "116": {
@@ -83,32 +83,32 @@
           "start": 4225
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/public.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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 { aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_public(self.context); },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_from_public_initializer(self.context); },\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"
     },
-    "127": {
+    "128": {
       "function_locations": [
         {
           "name": "do_sync_state",
-          "start": 7093
+          "start": 7341
         },
         {
           "name": "test::do_sync_state_does_not_panic_on_empty_logs",
-          "start": 9803
+          "start": 10249
         },
         {
           "name": "test::dummy_compute_note_hash",
-          "start": 11290
+          "start": 11736
         },
         {
           "name": "test::dummy_compute_note_nullifier",
-          "start": 11651
+          "start": 12097
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
-      "source": "use crate::logging::{aztecnr_debug_log, aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::address::AztecAddress;\n\npub(crate) mod nonce_discovery;\npub(crate) mod partial_notes;\npub(crate) mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    messages::{\n        discovery::process_message::process_message_ciphertext,\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{\n            MessageContext, offchain::OffchainInboxSync, OffchainMessageWithContext,\n            pending_tagged_log::PendingTaggedLog, validate_and_store_enqueued_notes_and_events,\n        },\n    },\n    oracle::message_processing,\n    utils::array,\n};\n\npub struct NoteHashAndNullifier {\n    /// The result of [`crate::note::note_interface::NoteHash::compute_note_hash`].\n    pub note_hash: Field,\n    /// The result of [`crate::note::note_interface::NoteHash::compute_nullifier_unconstrained`].\n    ///\n    /// This value is unconstrained, as all of message discovery is unconstrained. It is `None` if the nullifier\n    /// cannot be computed (e.g. because the nullifier hiding key is not available).\n    pub inner_nullifier: Option<Field>,\n}\n\n/// A contract's way of computing note hashes.\n///\n/// Each contract in the network is free to compute their note's hash as they see fit - the hash function itself is not\n/// enshrined or standardized. Some aztec-nr functions however do need to know the details of this computation (e.g.\n/// when finding new notes), which is what this type represents.\n///\n/// This function takes a note's packed content, storage slot, note type ID, address of the emitting contract and\n/// randomness, and attempts to compute its inner note hash (not siloed by address nor uniqued by nonce).\n///\n/// ## Transient Notes\n///\n/// This function is meant to always be used on **settled** notes, i.e. those that have been inserted into the trees\n/// and for which the nonce is known. It is never invoked in the context of a transient note, as those are not involved\n/// in message processing.\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract by inspecting all note types in use and the storage layout. This injected function is a\n/// `#[contract_library_method]` called `_compute_note_hash`, and it looks something like this:\n///\n/// ```noir\n/// |packed_note, owner, storage_slot, note_type_id, _contract_address, randomness| {\n///     if note_type_id == MyNoteType::get_id() {\n///         if packed_note.len() != MY_NOTE_TYPE_SERIALIZATION_LENGTH {\n///             Option::none()\n///         } else {\n///             let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///             Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n///         }\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\npub type ComputeNoteHash = unconstrained fn(/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /*\n owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /*\nrandomness */ Field) -> Option<Field>;\n\n/// A contract's way of computing note nullifiers.\n///\n/// Like [`ComputeNoteHash`], each contract is free to derive nullifiers as they see fit. This function takes the\n/// unique note hash (used as the note hash for nullification for settled notes), plus the note's packed content and\n/// metadata, and attempts to compute the inner nullifier (not siloed by address).\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract called `_compute_note_nullifier`. It dispatches on `note_type_id` similarly to\n/// [`ComputeNoteHash`], then calls the note's\n/// [`compute_nullifier_unconstrained`](crate::note::note_interface::NoteHash::compute_nullifier_unconstrained) method.\npub type ComputeNoteNullifier = unconstrained fn(/* unique_note_hash */Field, /* packed_note */ BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/* randomness */ Field) -> Option<Field>;\n\n/// Deprecated: use [`ComputeNoteHash`] and [`ComputeNoteNullifier`] instead.\npub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/*randomness */ Field, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// A handler for custom messages.\n///\n/// Contracts that emit custom messages (i.e. any with a message type that is not in [`crate::messages::msg_type`])\n/// need to use [`crate::macros::AztecConfig::custom_message_handler`] with a function of this type in order to\n/// process them. They will otherwise be **silently ignored**.\npub type CustomMessageHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* msg_type_id */ u64,\n/* msg_metadata */ u64,\n/* msg_content */ BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n/* message_context */ MessageContext,\n/* scope */ AztecAddress);\n\n/// Custom state synchronization handler.\n///\n/// When set via [`crate::macros::AztecConfig::custom_sync_state`], the generated `sync_state` function will call\n/// this handler instead of [`do_sync_state`]. It receives all of the same parameters, so it can run custom logic\n/// (e.g. fetching and decrypting custom logs) before, after, or instead of calling [`do_sync_state`].\npub type CustomSyncHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* compute_note_hash */ ComputeNoteHash,\n/* compute_note_nullifier */ ComputeNoteNullifier,\n/* process_custom_message */ Option<CustomMessageHandler>,\n/* offchain_inbox_sync */ Option<OffchainInboxSync>,\n/* scope */ AztecAddress);\n\n/// Synchronizes the contract's private state with the network.\n///\n/// As blocks are mined, it is possible for a contract's private state to change (e.g. with new notes being created),\n/// but because these changes are private they will be invisible to most actors. This is the function that processes\n/// new transactions in order to discover new notes, events, and other kinds of private state changes.\n///\n/// The private state will be synchronized up to the block that will be used for private transactions (i.e. the anchor\n/// block. This will typically be close to the tip of the chain.\npub unconstrained fn do_sync_state(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n) {\n    aztecnr_debug_log!(\"Performing state synchronization\");\n\n    // First we process all private logs, which can contain different kinds of messages e.g. private notes, partial\n    // notes, private events, etc.\n    let logs = message_processing::get_pending_tagged_logs(scope);\n    logs.for_each(|_i, pending_tagged_log: PendingTaggedLog| {\n        if pending_tagged_log.log.len() == 0 {\n            aztecnr_warn_log_format!(\"Skipping empty log from tx {0}\")([pending_tagged_log.context.tx_hash]);\n        } else {\n            aztecnr_debug_log_format!(\"Processing log with tag {0}\")([pending_tagged_log.log.get(0)]);\n\n            // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n            let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                message_ciphertext,\n                pending_tagged_log.context,\n                scope,\n            );\n        }\n    });\n\n    if offchain_inbox_sync.is_some() {\n        let msgs = offchain_inbox_sync.unwrap()(contract_address, scope);\n        msgs.for_each(|_i, msg: OffchainMessageWithContext| {\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                msg.message_ciphertext,\n                msg.message_context,\n                scope,\n            );\n        });\n    }\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::fetch_and_process_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        scope,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_and_store_enqueued_notes_and_events(scope);\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::{\n        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;\n    use crate::test::helpers::test_environment::TestEnvironment;\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            // Mock the oracle call to return a known base slot, then populate an ephemeral\n            // array at that slot so do_sync_state processes a non-empty log list.\n            let base_slot = 42;\n            let mock = std::test::OracleMock::mock(\"aztec_utl_getPendingTaggedLogs\");\n            let _ = mock.returns(base_slot);\n\n            let logs: EphemeralArray<PendingTaggedLog> = EphemeralArray::at(base_slot);\n            logs.push(PendingTaggedLog { log: BoundedVec::new(), context: std::mem::zeroed() });\n            assert_eq(logs.len(), 1);\n\n            let no_handler: Option<CustomMessageHandler> = Option::none();\n            let no_inbox_sync: Option<OffchainInboxSync> = Option::none();\n            do_sync_state(\n                contract_address,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n                no_handler,\n                no_inbox_sync,\n                scope,\n            );\n        });\n    }\n\n    unconstrained fn dummy_compute_note_hash(\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n\n    unconstrained fn dummy_compute_note_nullifier(\n        _unique_note_hash: Field,\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n}\n"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
+      "source": "use crate::logging::{aztecnr_debug_log, aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::address::AztecAddress;\nuse crate::protocol::hash::sha256_to_field;\n\npub(crate) mod nonce_discovery;\npub(crate) mod partial_notes;\npub(crate) mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    messages::{\n        discovery::process_message::process_message_ciphertext,\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{\n            MessageContext, offchain::OffchainInboxSync, OffchainMessageWithContext,\n            pending_tagged_log::PendingTaggedLog, provided_secret::ProvidedSecret,\n            validate_and_store_enqueued_notes_and_events,\n        },\n    },\n    oracle::message_processing,\n    utils::array,\n};\n\nglobal PROVIDED_SECRETS_ARRAY_BASE_SLOT: Field =\n    sha256_to_field(\"AZTEC_NR::PROVIDED_SECRETS_ARRAY_BASE_SLOT\".as_bytes());\n\npub struct NoteHashAndNullifier {\n    /// The result of [`crate::note::note_interface::NoteHash::compute_note_hash`].\n    pub note_hash: Field,\n    /// The result of [`crate::note::note_interface::NoteHash::compute_nullifier_unconstrained`].\n    ///\n    /// This value is unconstrained, as all of message discovery is unconstrained. It is `None` if the nullifier\n    /// cannot be computed (e.g. because the nullifier hiding key is not available).\n    pub inner_nullifier: Option<Field>,\n}\n\n/// A contract's way of computing note hashes.\n///\n/// Each contract in the network is free to compute their note's hash as they see fit - the hash function itself is not\n/// enshrined or standardized. Some aztec-nr functions however do need to know the details of this computation (e.g.\n/// when finding new notes), which is what this type represents.\n///\n/// This function takes a note's packed content, storage slot, note type ID, address of the emitting contract and\n/// randomness, and attempts to compute its inner note hash (not siloed by address nor uniqued by nonce).\n///\n/// ## Transient Notes\n///\n/// This function is meant to always be used on **settled** notes, i.e. those that have been inserted into the trees\n/// and for which the nonce is known. It is never invoked in the context of a transient note, as those are not involved\n/// in message processing.\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract by inspecting all note types in use and the storage layout. This injected function is a\n/// `#[contract_library_method]` called `_compute_note_hash`, and it looks something like this:\n///\n/// ```noir\n/// |packed_note, owner, storage_slot, note_type_id, _contract_address, randomness| {\n///     if note_type_id == MyNoteType::get_id() {\n///         if packed_note.len() != MY_NOTE_TYPE_SERIALIZATION_LENGTH {\n///             Option::none()\n///         } else {\n///             let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///             Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n///         }\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\npub type ComputeNoteHash = unconstrained fn(/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /*\n owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /*\nrandomness */ Field) -> Option<Field>;\n\n/// A contract's way of computing note nullifiers.\n///\n/// Like [`ComputeNoteHash`], each contract is free to derive nullifiers as they see fit. This function takes the\n/// unique note hash (used as the note hash for nullification for settled notes), plus the note's packed content and\n/// metadata, and attempts to compute the inner nullifier (not siloed by address).\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract called `_compute_note_nullifier`. It dispatches on `note_type_id` similarly to\n/// [`ComputeNoteHash`], then calls the note's\n/// [`compute_nullifier_unconstrained`](crate::note::note_interface::NoteHash::compute_nullifier_unconstrained) method.\npub type ComputeNoteNullifier = unconstrained fn(/* unique_note_hash */Field, /* packed_note */ BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/* randomness */ Field) -> Option<Field>;\n\n/// Deprecated: use [`ComputeNoteHash`] and [`ComputeNoteNullifier`] instead.\npub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/*randomness */ Field, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// A handler for custom messages.\n///\n/// Contracts that emit custom messages (i.e. any with a message type that is not in [`crate::messages::msg_type`])\n/// need to use [`crate::macros::AztecConfig::custom_message_handler`] with a function of this type in order to\n/// process them. They will otherwise be **silently ignored**.\npub type CustomMessageHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* msg_type_id */ u64,\n/* msg_metadata */ u64,\n/* msg_content */ BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n/* message_context */ MessageContext,\n/* scope */ AztecAddress);\n\n/// Custom state synchronization handler.\n///\n/// When set via [`crate::macros::AztecConfig::custom_sync_state`], the generated `sync_state` function will call\n/// this handler instead of [`do_sync_state`]. It receives all of the same parameters, so it can run custom logic\n/// (e.g. fetching and decrypting custom logs) before, after, or instead of calling [`do_sync_state`].\npub type CustomSyncHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* compute_note_hash */ ComputeNoteHash,\n/* compute_note_nullifier */ ComputeNoteNullifier,\n/* process_custom_message */ Option<CustomMessageHandler>,\n/* offchain_inbox_sync */ Option<OffchainInboxSync>,\n/* scope */ AztecAddress);\n\n/// Synchronizes the contract's private state with the network.\n///\n/// As blocks are mined, it is possible for a contract's private state to change (e.g. with new notes being created),\n/// but because these changes are private they will be invisible to most actors. This is the function that processes\n/// new transactions in order to discover new notes, events, and other kinds of private state changes.\n///\n/// The private state will be synchronized up to the block that will be used for private transactions (i.e. the anchor\n/// block. This will typically be close to the tip of the chain.\npub unconstrained fn do_sync_state(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n) {\n    aztecnr_debug_log!(\"Performing state synchronization\");\n\n    // First we process all private logs, which can contain different kinds of messages e.g. private notes, partial\n    // notes, private events, etc.\n    // TODO(F-588): populate with tagging secrets for constrained delivery\n    let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);\n    let logs = message_processing::get_pending_tagged_logs(scope, provided_secrets);\n    logs.for_each(|_i, pending_tagged_log: PendingTaggedLog| {\n        if pending_tagged_log.log.len() == 0 {\n            aztecnr_warn_log_format!(\"Skipping empty log from tx {0}\")([pending_tagged_log.context.tx_hash]);\n        } else {\n            aztecnr_debug_log_format!(\"Processing log with tag {0}\")([pending_tagged_log.log.get(0)]);\n\n            // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n            let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                message_ciphertext,\n                pending_tagged_log.context,\n                scope,\n            );\n        }\n    });\n\n    if offchain_inbox_sync.is_some() {\n        let msgs = offchain_inbox_sync.unwrap()(contract_address, scope);\n        msgs.for_each(|_i, msg: OffchainMessageWithContext| {\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                msg.message_ciphertext,\n                msg.message_context,\n                scope,\n            );\n        });\n    }\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::fetch_and_process_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        scope,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_and_store_enqueued_notes_and_events(scope);\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::{\n        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;\n    use crate::test::helpers::test_environment::TestEnvironment;\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            // Mock the oracle call to return a known base slot, then populate an ephemeral\n            // array at that slot so do_sync_state processes a non-empty log list.\n            let base_slot = 42;\n            let mock = std::test::OracleMock::mock(\"aztec_utl_getPendingTaggedLogs\");\n            let _ = mock.returns(base_slot);\n\n            let logs: EphemeralArray<PendingTaggedLog> = EphemeralArray::at(base_slot);\n            logs.push(PendingTaggedLog { log: BoundedVec::new(), context: std::mem::zeroed() });\n            assert_eq(logs.len(), 1);\n\n            let no_handler: Option<CustomMessageHandler> = Option::none();\n            let no_inbox_sync: Option<OffchainInboxSync> = Option::none();\n            do_sync_state(\n                contract_address,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n                no_handler,\n                no_inbox_sync,\n                scope,\n            );\n        });\n    }\n\n    unconstrained fn dummy_compute_note_hash(\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n\n    unconstrained fn dummy_compute_note_nullifier(\n        _unique_note_hash: Field,\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n}\n"
     },
-    "128": {
+    "129": {
       "function_locations": [
         {
           "name": "attempt_note_nonce_discovery",
@@ -163,10 +163,10 @@
           "start": 18937
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/nonce_discovery.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "129": {
+    "130": {
       "function_locations": [
         {
           "name": "process_partial_note_private_msg",
@@ -177,20 +177,20 @@
           "start": 3193
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/partial_notes.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/discovery/partial_notes.nr",
       "source": "use crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::partial_note::{decode_partial_note_private_message, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN},\n        processing::{\n            enqueue_note_for_validation,\n            get_pending_partial_notes_completion_logs,\n            log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN},\n        },\n    },\n    utils::array,\n};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, traits::{Deserialize, Serialize}};\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub(crate) global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) owner: AztecAddress,\n    pub(crate) randomness: Field,\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n}\n\npub(crate) unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n    scope: AztecAddress,\n) {\n    let decoded = decode_partial_note_private_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later\n        // search for the public log that will complete it.\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content) = decoded.unwrap();\n\n        let pending = DeliveredPendingPartialNote {\n            owner,\n            randomness,\n            note_completion_log_tag,\n            note_type_id,\n            packed_private_note_content,\n        };\n\n        CapsuleArray::at(\n            contract_address,\n            DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n            scope,\n        )\n            .push(pending);\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode partial note private message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Searches for logs that would result in the completion of pending partial notes, ultimately resulting in the notes\n/// being delivered to PXE if completed.\npub(crate) unconstrained fn fetch_and_process_partial_note_completion_logs(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    scope: AztecAddress,\n) {\n    let pending_partial_notes = CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n        scope,\n    );\n\n    aztecnr_debug_log_format!(\"{} pending partial notes\")([pending_partial_notes.len() as Field]);\n\n    // Each of the pending partial notes might get completed by a log containing its public values. For performance\n    // reasons, we fetch all of these logs concurrently and then process them one by one, minimizing the amount of time\n    // waiting for the node roundtrip.\n    let completion_logs = get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n\n    // Each entry in the completion logs array corresponds to the entry in the pending partial notes array at the same\n    // index. Each inner array contains all matching LogRetrievalResponses.\n    assert_eq(completion_logs.len(), pending_partial_notes.len());\n\n    completion_logs.for_each(|i, logs_for_tag: EphemeralArray<LogRetrievalResponse>| {\n        let pending_partial_note = pending_partial_notes.get(i);\n        let num_logs = logs_for_tag.len();\n\n        if num_logs == 0 {\n            aztecnr_debug_log_format!(\"Found no completion logs for partial note with tag {}\")(\n                [pending_partial_note.note_completion_log_tag],\n            );\n\n            // Note that we're not removing the pending partial note from the capsule array, so we will continue\n            // searching for this tagged log when performing message discovery in the future until we either find it or\n            // the entry is somehow removed from the array.\n        } else {\n            assert(num_logs == 1, f\"Expected at most 1 completion log per partial note, got {num_logs}\");\n\n            aztecnr_debug_log_format!(\"Completion log found for partial note with tag {}\")([\n                pending_partial_note.note_completion_log_tag,\n            ]);\n            let log = logs_for_tag.get(0);\n\n            // The first field in the completion log payload is the storage slot, followed by the public note\n            // content fields.\n            let storage_slot = log.log_payload.get(0);\n            let public_note_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN - 1> = array::subbvec(log.log_payload, 1);\n\n            // Public fields are assumed to all be placed at the end of the packed representation, so we combine\n            // the private and public packed fields (i.e. the contents of the private message and public log\n            // plaintext) to get the complete packed content.\n            let complete_packed_note = array::append(\n                pending_partial_note.packed_private_note_content,\n                public_note_content,\n            );\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                contract_address,\n                pending_partial_note.owner,\n                storage_slot,\n                pending_partial_note.randomness,\n                pending_partial_note.note_type_id,\n                complete_packed_note,\n            );\n\n            // TODO(#11627): is there anything reasonable we can do if we get a log but it doesn't result in a note\n            // being found?\n            if discovered_notes.len() == 0 {\n                panic(\n                    f\"A partial note's completion log did not result in any notes being found - this should never happen\",\n                );\n            }\n\n            aztecnr_debug_log_format!(\"Discovered {0} notes for partial note with tag {1}\")([\n                discovered_notes.len() as Field,\n                pending_partial_note.note_completion_log_tag,\n            ]);\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    contract_address,\n                    pending_partial_note.owner,\n                    storage_slot,\n                    pending_partial_note.randomness,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                );\n            });\n\n            // Because there is only a single log for a given tag, once we've processed the tagged log then we simply\n            // delete the pending work entry, regardless of whether it was actually completed or not.\n            pending_partial_notes.remove(i);\n        }\n    });\n}\n"
     },
-    "130": {
+    "131": {
       "function_locations": [
         {
           "name": "process_private_event_msg",
           "start": 547
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_events.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "131": {
+    "132": {
       "function_locations": [
         {
           "name": "process_private_note_msg",
@@ -201,10 +201,10 @@
           "start": 3612
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "132": {
+    "133": {
       "function_locations": [
         {
           "name": "process_message_ciphertext",
@@ -215,10 +215,10 @@
           "start": 2868
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHash, ComputeNoteNullifier, CustomMessageHandler, partial_notes::process_partial_note_private_msg,\n        private_events::process_private_event_msg, private_notes::process_private_note_msg,\n    },\n    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN},\n    encryption::{aes128::AES128, message_encryption::MessageEncryption},\n    msg_type::{\n        MIN_CUSTOM_MSG_TYPE_ID, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    processing::MessageContext,\n};\n\nuse crate::logging::{aztecnr_debug_log, aztecnr_warn_log_format};\nuse crate::protocol::address::AztecAddress;\n\n/// Processes a message that can contain notes, partial notes, or events.\n///\n/// Notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash\n/// in which the notes would've been created (typically the same transaction in which the log was emitted), along with\n/// the list of unique note hashes in said transaction and the `compute_note_hash` and `compute_note_nullifier`\n/// functions. Once discovered, the notes are enqueued for validation.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved\n/// to search for the note's completion public log.\n///\n/// Events are processed by computing an event commitment from the serialized event data and its randomness field, then\n/// enqueueing the event data and commitment for validation.\npub unconstrained fn process_message_ciphertext(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    message_context: MessageContext,\n    recipient: AztecAddress,\n) {\n    let message_plaintext_option = AES128::decrypt(message_ciphertext, recipient, contract_address);\n\n    if message_plaintext_option.is_some() {\n        process_message_plaintext(\n            contract_address,\n            compute_note_hash,\n            compute_note_nullifier,\n            process_custom_message,\n            message_plaintext_option.unwrap(),\n            message_context,\n            recipient,\n        );\n    } else {\n        aztecnr_warn_log_format!(\"Could not decrypt message ciphertext from tx {0}, ignoring\")([message_context.tx_hash]);\n    }\n}\n\npub(crate) unconstrained fn process_message_plaintext(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    message_plaintext: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n    message_context: MessageContext,\n    recipient: AztecAddress,\n) {\n    // The first thing to do after decrypting the message is to determine what type of message we're processing. We\n    // have 3 message types: private notes, partial notes and events.\n\n    // We decode the message to obtain the message type id, metadata and content.\n    let decoded = decode_message(message_plaintext);\n\n    if decoded.is_some() {\n        let (msg_type_id, msg_metadata, msg_content) = decoded.unwrap();\n\n        if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private note msg\");\n\n            process_private_note_msg(\n                contract_address,\n                message_context.tx_hash,\n                message_context.unique_note_hashes_in_tx,\n                message_context.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                msg_metadata,\n                msg_content,\n            );\n        } else if msg_type_id == PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing partial note private msg\");\n\n            process_partial_note_private_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                message_context.tx_hash,\n                recipient,\n            );\n        } else if msg_type_id == PRIVATE_EVENT_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private event msg\");\n\n            process_private_event_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                message_context.tx_hash,\n            );\n        } else if msg_type_id < MIN_CUSTOM_MSG_TYPE_ID {\n            // The message type ID falls in the range reserved for aztec.nr built-in types but wasn't matched above.\n            // This most likely means the message is malformed or a custom message was incorrectly assigned a reserved\n            // ID. Custom message types must use IDs allocated via `custom_msg_type_id`.\n            aztecnr_warn_log_format!(\n                \"Message type ID {0} is in the reserved range but is not recognized, ignoring. See https://docs.aztec.network/errors/3\",\n            )(\n                [msg_type_id as Field],\n            );\n        } else if process_custom_message.is_some() {\n            process_custom_message.unwrap()(\n                contract_address,\n                msg_type_id,\n                msg_metadata,\n                msg_content,\n                message_context,\n                recipient,\n            );\n        } else {\n            // A custom message was received but no handler is configured. This likely means the contract emits custom\n            // messages but forgot to register a handler via `AztecConfig::custom_message_handler`.\n            aztecnr_warn_log_format!(\n                \"Received custom message with type id {0} but no handler is configured, ignoring. See https://docs.aztec.network/errors/2\",\n            )(\n                [msg_type_id as Field],\n            );\n        }\n    } else {\n        aztecnr_warn_log_format!(\"Could not decode message plaintext from tx {0}, ignoring\")([message_context.tx_hash]);\n    }\n}\n"
     },
-    "133": {
+    "134": {
       "function_locations": [
         {
           "name": "encode_message",
@@ -277,10 +277,10 @@
           "start": 13280
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encoding.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "134": {
+    "135": {
       "function_locations": [
         {
           "name": "extract_many_close_to_uniformly_random_256_bits_using_poseidon2",
@@ -324,49 +324,49 @@
         },
         {
           "name": "test::encrypt_decrypt_random",
-          "start": 27182
+          "start": 27098
         },
         {
           "name": "test::encrypt_to_invalid_address",
-          "start": 28028
+          "start": 27944
         },
         {
           "name": "test::pkcs7_padding_always_adds_at_least_one_byte",
-          "start": 28478
+          "start": 28394
         },
         {
           "name": "test::encrypt_decrypt_max_size_plaintext",
-          "start": 29042
+          "start": 28958
         },
         {
           "name": "test::encrypt_oversized_plaintext",
-          "start": 29941
+          "start": 29857
         },
         {
           "name": "test::random_address_point_produces_valid_points",
-          "start": 30299
+          "start": 30215
         },
         {
           "name": "test::decrypt_invalid_ephemeral_public_key",
-          "start": 30750
+          "start": 30666
         },
         {
           "name": "test::decrypt_returns_none_on_empty_ciphertext",
-          "start": 31595
+          "start": 31511
         },
         {
           "name": "test::decrypt_returns_none_on_empty_header",
-          "start": 32149
+          "start": 32065
         },
         {
           "name": "test::decrypt_returns_none_on_oversized_ciphertext_length",
-          "start": 33075
+          "start": 32991
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
-      "source": "use crate::protocol::{address::AztecAddress, public_keys::AddressPoint, traits::ToField};\n\nuse crate::{\n    keys::{\n        ecdh_shared_secret::{\n            compute_app_siloed_shared_secret, derive_ecdh_shared_secret, derive_shared_secret_field_mask,\n            derive_shared_secret_subkey,\n        },\n        ephemeral::generate_positive_ephemeral_key_pair,\n    },\n    logging::aztecnr_warn_log_format,\n    messages::{\n        encoding::{\n            EPH_PK_X_SIZE_IN_FIELDS, HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN,\n            MESSAGE_PLAINTEXT_SIZE_IN_BYTES,\n        },\n        encryption::message_encryption::MessageEncryption,\n        logs::arithmetic_generics_utils::{\n            get_arr_of_size__message_bytes__from_PT, get_arr_of_size__message_bytes_padding__from_PT,\n        },\n    },\n    oracle::{aes128_decrypt::try_aes128_decrypt, random::random, shared_secret::get_shared_secret},\n    utils::{\n        array,\n        conversion::{\n            bytes_as_fields::{decode_bytes_from_fields, encode_bytes_as_fields},\n            fields_as_bytes::{encode_fields_as_bytes, try_decode_fields_from_bytes},\n        },\n        point::point_from_x_coord_and_sign,\n    },\n};\n\nuse std::aes128::aes128_encrypt;\n\n/// Computes N close-to-uniformly-random 256 bits from a given app-siloed shared secret.\n///\n/// NEVER re-use the same iv and sym_key. DO NOT call this function more than once with the same s_app.\n///\n/// This function is only known to be safe if s_app is derived from combining a random ephemeral key with an\n/// address point and a contract address. See big comment within the body of the function.\nfn extract_many_close_to_uniformly_random_256_bits_using_poseidon2<let N: u32>(s_app: Field) -> [[u8; 32]; N] {\n    /*\n     * Unsafe because of https://eprint.iacr.org/2010/264.pdf Page 13, Lemma 2 (and the two paragraphs below it).\n    *\n    * If you call this function, you need to be careful and aware of how the arg `s_app` has been derived.\n    *\n    * The paper says that the way you derive aes keys and IVs should be fine with poseidon2 (modelled as a RO),\n    * as long as you _don't_ use Poseidon2 as a PRG to generate the two exponents x & y which multiply to the\n    * shared secret S:\n    *\n    * S = [x*y]*G.\n    *\n    * (Otherwise, you would have to \"key\" poseidon2, i.e. generate a uniformly string K which can be public and\n    * compute Hash(x) as poseidon(K,x)).\n    * In that lemma, k would be 2*254=508, and m would be the number of points on the grumpkin curve (which is\n    * close to r according to the Hasse bound).\n    *\n    * Our shared secret S is [esk * address_sk] * G, and the question is: Can we compute hash(S) using poseidon2\n    * instead of sha256?\n    *\n    * Well, esk is random and not generated with poseidon2, so that's good.\n    * What about address_sk?\n    * Well, address_sk = poseidon2(stuff) + ivsk, so there was some discussion about whether address_sk is\n    * independent of poseidon2. Given that ivsk is random and independent of poseidon2, the address_sk is also\n    * independent of poseidon2.\n    *\n    * Tl;dr: we believe it's safe to hash S = [esk * address_sk] * G using poseidon2, in order to derive a\n    * symmetric key.\n    *\n    * If you're calling this function for a differently-derived `s_app`, be careful.\n    */\n    \n\n    /* The output of this function needs to be 32 random bytes.\n     * A single field won't give us 32 bytes of entropy. So we compute two \"random\" fields, by poseidon-hashing\n    * with two different indices. We then extract the last 16 (big endian) bytes of each \"random\" field.\n    * Note: we use to_be_bytes because it's slightly more efficient. But we have to be careful not to take bytes\n    * from the \"big end\", because the \"big\" byte is not uniformly random over the byte: it only has < 6 bits of\n    * randomness, because it's the big end of a 254-bit field element.\n    */\n\n    let mut all_bytes: [[u8; 32]; N] = std::mem::zeroed();\n    std::static_assert(N < 256, \"N too large\");\n    for k in 0..N {\n        let rand1: Field = derive_shared_secret_subkey(s_app, 2 * k);\n        let rand2: Field = derive_shared_secret_subkey(s_app, 2 * k + 1);\n\n        let rand1_bytes: [u8; 32] = rand1.to_be_bytes();\n        let rand2_bytes: [u8; 32] = rand2.to_be_bytes();\n\n        let mut bytes: [u8; 32] = [0; 32];\n        for i in 0..16 {\n            // We take bytes from the \"little end\" of the be-bytes arrays:\n            let j = 32 - i - 1;\n            bytes[i] = rand1_bytes[j];\n            bytes[16 + i] = rand2_bytes[j];\n        }\n\n        all_bytes[k] = bytes;\n    }\n\n    all_bytes\n}\n\nfn derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits<let N: u32>(\n    many_random_256_bits: [[u8; 32]; N],\n) -> [([u8; 16], [u8; 16]); N] {\n    // Many (sym_key, iv) pairs:\n    let mut many_pairs: [([u8; 16], [u8; 16]); N] = std::mem::zeroed();\n    for k in 0..N {\n        let random_256_bits = many_random_256_bits[k];\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n        for i in 0..16 {\n            sym_key[i] = random_256_bits[i];\n            iv[i] = random_256_bits[i + 16];\n        }\n        many_pairs[k] = (sym_key, iv);\n    }\n\n    many_pairs\n}\n\npub fn derive_aes_symmetric_key_and_iv_from_shared_secret<let N: u32>(s_app: Field) -> [([u8; 16], [u8; 16]); N] {\n    let many_random_256_bits: [[u8; 32]; N] = extract_many_close_to_uniformly_random_256_bits_using_poseidon2(s_app);\n\n    derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits(many_random_256_bits)\n}\n\npub struct AES128 {}\n\nimpl MessageEncryption for AES128 {\n\n    /// AES128-CBC encryption for Aztec protocol messages.\n    ///\n    /// ## Overview\n    ///\n    /// The plaintext is an array of up to `MESSAGE_PLAINTEXT_LEN` (12) fields. The output is always exactly\n    /// `MESSAGE_CIPHERTEXT_LEN` (15) fields, regardless of plaintext size. All output fields except the\n    /// ephemeral public key are uniformly random `Field` values to any observer without knowledge of the\n    /// shared secret, making all encrypted messages indistinguishable by size or content.\n    ///\n    /// ## PKCS#7 Padding\n    ///\n    /// AES operates on 16-byte blocks, so the plaintext must be padded to a multiple of 16. PKCS#7 padding always\n    /// adds at least 1 byte (so the receiver can always detect and strip it), which means:\n    /// - 1 B plaintext  -> 15 B padding -> 16 B total\n    /// - 15 B plaintext ->  1 B padding -> 16 B total\n    /// - 16 B plaintext -> 16 B padding -> 32 B total (full extra block)\n    ///\n    /// In general: if the plaintext is already a multiple of 16, a full 16-byte padding block is appended.\n    ///\n    /// ## Encryption Steps\n    ///\n    /// **1. Body encryption.** The plaintext fields are serialized to bytes (32 bytes per field) and AES-128-CBC\n    /// encrypted. Since 32 is a multiple of 16, PKCS#7 always adds a full 16-byte padding block (see above):\n    ///\n    /// ```text\n    /// +---------------------------------------------+\n    /// |                   body ct                    |\n    /// |            PlaintextLen*32 + 16 B            |\n    /// +-------------------------------+--------------+\n    /// | encrypted plaintext fields    | PKCS#7 (16B) |\n    /// | (serialized at 32 B each)     |              |\n    /// +-------------------------------+--------------+\n    /// ```\n    ///\n    /// **2. Header encryption.** The byte length of `body_ct` is stored as a 2-byte big-endian integer. This 2-byte\n    /// header plaintext is then AES-encrypted; PKCS#7 pads the remaining 14 bytes to fill one 16-byte AES block,\n    /// producing a 16-byte header ciphertext:\n    ///\n    /// ```text\n    /// +---------------------------+\n    /// |         header ct         |\n    /// |            16 B           |\n    /// +--------+------------------+\n    /// | body ct| PKCS#7 (14B)     |\n    /// | length |                  |\n    /// | (2 B)  |                  |\n    /// +--------+------------------+\n    /// ```\n    ///\n    /// ## Wire Format\n    ///\n    /// Messages are transmitted as fields, not bytes. A field is ~254 bits and can safely store 31 whole bytes, so\n    /// we need to pack our byte data into 31-byte chunks. This packing drives the wire format.\n    ///\n    /// **Step 1 -- Assemble bytes.** The ciphertexts are laid out in a byte array, padded with zero bytes to a\n    /// multiple of 31 so it divides evenly into fields:\n    ///\n    /// ```text\n    /// +------------+-------------------------+---------+\n    /// | header ct  |        body ct          | byte pad|\n    /// |   16 B     | PlaintextLen*32 + 16 B  | (zeros) |\n    /// +------------+-------------------------+---------+\n    /// |<-------- padded to a multiple of 31 B -------->|\n    /// ```\n    ///\n    /// **Step 2 -- Pack and mask.** The byte array is split into 31-byte chunks, each stored in one field. A\n    /// Poseidon2-derived mask (see `derive_shared_secret_field_mask`) is added to each so that the resulting\n    /// fields appear as uniformly random `Field` values to any observer without knowledge of the shared secret,\n    /// hiding the fact that the underlying ciphertext consists of 128-bit AES blocks.\n    ///\n    /// **Step 3 -- Assemble ciphertext.** The ephemeral public key x-coordinate is prepended and random field padding\n    /// is appended to fill to 15 fields:\n    ///\n    /// ```text\n    /// +----------+-------------------------+-------------------+\n    /// | eph_pk.x |  masked message fields   | random field pad  |\n    /// |          | (packed 31 B per field)  |  (fills to 15)    |\n    /// +----------+-------------------------+-------------------+\n    /// |<---------- MESSAGE_CIPHERTEXT_LEN = 15 fields -------->|\n    /// ```\n    ///\n    /// ## Key Derivation\n    ///\n    /// The raw ECDH shared secret point is first app-siloed into a scalar `s_app` by hashing with the contract\n    /// address (see\n    /// [`compute_app_siloed_shared_secret`](crate::keys::ecdh_shared_secret::compute_app_siloed_shared_secret)).\n    /// Two (key, IV) pairs are then derived from `s_app` via indexed Poseidon2 hashing: one pair for the body\n    /// ciphertext and one for the header ciphertext.\n    fn encrypt<let PlaintextLen: u32>(\n        plaintext: [Field; PlaintextLen],\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> [Field; MESSAGE_CIPHERTEXT_LEN] {\n        std::static_assert(\n            PlaintextLen <= MESSAGE_PLAINTEXT_LEN,\n            \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\",\n        );\n\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes. (This process is then\n        // reversed when processing the message in `process_message_ciphertext`)\n        let plaintext_bytes = encode_fields_as_bytes(plaintext);\n\n        // Derive ECDH shared secret with recipient using a fresh ephemeral keypair.\n        let (eph_sk, eph_pk) = generate_positive_ephemeral_key_pair();\n\n        let raw_shared_secret = derive_ecdh_shared_secret(\n            eph_sk,\n            recipient\n                .to_address_point()\n                .unwrap_or_else(|| {\n                    aztecnr_warn_log_format!(\n                        \"Attempted to encrypt message for an invalid recipient ({0})\",\n                    )(\n                        [recipient.to_field()],\n                    );\n\n                    // Safety: if the recipient is an invalid address, then it is not possible to encrypt a message for\n                    // them because we cannot establish a shared secret. This is never expected to occur during normal\n                    // operation. However, it is technically possible for us to receive an invalid address, and we must\n                    // therefore handle it. We could simply fail, but that'd introduce a potential security issue in\n                    // which an attacker forces a contract to encrypt a message for an invalid address, resulting in an\n                    // impossible transaction - this is sometimes called a 'king of the hill' attack. We choose instead\n                    // to not fail and encrypt the plaintext regardless using the shared secret that results from a\n                    // random valid address. The sender is free to choose this address and hence shared secret, but\n                    // this has no security implications as they already know not only the full plaintext but also the\n                    // ephemeral private key anyway.\n                    unsafe {\n                        random_address_point()\n                    }\n                })\n                .inner,\n        );\n\n        let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n        // It is safe to derive AES keys from `s_app` using Poseidon2 because `s_app` was derived from an ECDH shared\n        // secret using an AztecAddress (the recipient). See the block comment in\n        // `extract_many_close_to_uniformly_random_256_bits_using_poseidon2` for more info.\n        let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, body_iv, body_sym_key);\n\n        // Each plaintext field is 32 bytes (a multiple of the 16-byte AES block\n        // size), so PKCS#7 always appends a full 16-byte padding block:\n        //   |ciphertext| = PlaintextLen*32 + 16 = 16 * (1 + PlaintextLen*32 / 16)\n        std::static_assert(\n            ciphertext_bytes.len() == 16 * (1 + (PlaintextLen * 32) / 16),\n            \"unexpected ciphertext length\",\n        );\n\n        // Encrypt a 2-byte header containing the body ciphertext length.\n        let header_plaintext = encode_header(ciphertext_bytes.len());\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the input, according to pkcs#7; hence why\n        // the output `header_ciphertext_bytes` is 16 bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, header_iv, header_sym_key);\n        // Verify expected header ciphertext size at compile time.\n        std::static_assert(\n            header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n            \"unexpected ciphertext header length\",\n        );\n\n        // Assemble the message byte array:\n        //  [header_ct (16B)] [body_ct] [padding to mult of 31]\n        let message_bytes_padding_to_mult_31 = get_arr_of_size__message_bytes_padding__from_PT::<PlaintextLen * 32>();\n\n        let mut message_bytes = get_arr_of_size__message_bytes__from_PT::<PlaintextLen * 32>();\n\n        std::static_assert(\n            message_bytes.len() % 31 == 0,\n            \"Unexpected error: message_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        let mut offset = 0;\n        for i in 0..header_ciphertext_bytes.len() {\n            message_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            message_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..message_bytes_padding_to_mult_31.len() {\n            message_bytes[offset + i] = message_bytes_padding_to_mult_31[i];\n        }\n        offset += message_bytes_padding_to_mult_31.len();\n\n        // Ideally we would be able to have a static assert where we check that the offset would be such that we've\n        // written to the entire log_bytes array, but we cannot since Noir does not treat the offset as a comptime\n        // value (despite the values that it goes through being known at each stage). We instead check that the\n        // computation used to obtain the offset computes the expected value (which we _can_ do in a static check), and\n        // then add a cheap runtime check to also validate that the offset matches this.\n        std::static_assert(\n            header_ciphertext_bytes.len() + ciphertext_bytes.len() + message_bytes_padding_to_mult_31.len()\n                == message_bytes.len(),\n            \"unexpected message length\",\n        );\n        assert(offset == message_bytes.len(), \"unexpected encrypted message length\");\n\n        // Pack message bytes into fields (31 bytes per field) and prepend eph_pk.x.\n        let message_bytes_as_fields = encode_bytes_as_fields(message_bytes);\n\n        let mut ciphertext: [Field; MESSAGE_CIPHERTEXT_LEN] = [0; MESSAGE_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        // Mask each content field with a Poseidon2-derived value, so that they appear as uniformly random `Field`\n        // values\n        let mut offset = 1;\n        for i in 0..message_bytes_as_fields.len() {\n            let mask = derive_shared_secret_field_mask(s_app, i as u32);\n            ciphertext[offset + i] = message_bytes_as_fields[i] + mask;\n        }\n        offset += message_bytes_as_fields.len();\n\n        // Pad with random fields so that padding is indistinguishable from masked data fields.\n        for i in offset..MESSAGE_CIPHERTEXT_LEN {\n            // Safety: we assume that the sender wants for the message to be private - a malicious one could simply\n            // reveal its contents publicly. It is therefore fine to trust the sender to provide random padding.\n            ciphertext[i] = unsafe { random() };\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt(\n        ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> Option<BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>> {\n        // Extract the ephemeral public key x-coordinate and masked fields, returning None for empty ciphertext.\n        if ciphertext.len() > 0 {\n            let masked_fields: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS> =\n                array::subbvec(ciphertext, EPH_PK_X_SIZE_IN_FIELDS);\n            Option::some((ciphertext.get(0), masked_fields))\n        } else {\n            Option::none()\n        }\n            .and_then(|(eph_pk_x, masked_fields)| {\n                // With the x-coordinate of the ephemeral public key we can reconstruct the point as we know that the\n                // y-coordinate must be positive. This may fail however, as not all x-coordinates are on the curve. In\n                // that case, we simply return `Option::none`.\n                point_from_x_coord_and_sign(eph_pk_x, true).and_then(|eph_pk| {\n                    let s_app = get_shared_secret(recipient, eph_pk, contract_address);\n\n                    let unmasked_fields = masked_fields.mapi(|i, field| {\n                        let unmasked = unmask_field(s_app, i, field);\n                        // If we failed to unmask the field, we are dealing with the random padding. We'll ignore it\n                        // later, so we can simply set it to 0\n                        unmasked.unwrap_or(0)\n                    });\n                    let ciphertext_without_eph_pk_x = decode_bytes_from_fields(unmasked_fields);\n\n                    // Derive symmetric keys:\n                    let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n                    let (body_sym_key, body_iv) = pairs[0];\n                    let (header_sym_key, header_iv) = pairs[1];\n\n                    // Extract the header ciphertext\n                    let header_start = 0;\n                    let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n                        array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n                    // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's\n                    // designed to work with messages with unknown length at compile time. This would not be necessary\n                    // here as the header ciphertext length is fixed. But we do it anyway to not have to have duplicate\n                    // oracles.\n                    let header_ciphertext_bvec =\n                        BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n                    try_aes128_decrypt(header_ciphertext_bvec, header_iv, header_sym_key)\n                    // Extract ciphertext length from header (2 bytes, big-endian)\n                    .and_then(|header_plaintext| extract_ciphertext_length(header_plaintext))\n                        .filter(|ciphertext_length| ciphertext_length <= MESSAGE_PLAINTEXT_SIZE_IN_BYTES)\n                        .map(|ciphertext_length| {\n                            // Extract and decrypt main ciphertext\n                            let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n                            let ciphertext_with_padding: [u8; MESSAGE_PLAINTEXT_SIZE_IN_BYTES] =\n                                array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n                            BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length)\n                        })\n                        // Decrypt main ciphertext and return it\n                        .and_then(|ciphertext| try_aes128_decrypt(ciphertext, body_iv, body_sym_key))\n                        // Convert bytes back to fields (32 bytes per field). Returns None if the actual bytes are\n                        // not valid.\n                        .and_then(|plaintext_bytes| try_decode_fields_from_bytes(plaintext_bytes))\n                })\n            })\n    }\n}\n\n/// Encodes the body ciphertext length into a 2-byte big-endian header.\nfn encode_header(ciphertext_length: u32) -> [u8; 2] {\n    [(ciphertext_length >> 8) as u8, ciphertext_length as u8]\n}\n\n/// Extracts the body ciphertext length from a decrypted header as a 2-byte big-endian integer.\n///\n/// Returns `Option::none()` if the header has fewer than 2 bytes.\nunconstrained fn extract_ciphertext_length<let N: u32>(header: BoundedVec<u8, N>) -> Option<u32> {\n    if header.len() >= 2 {\n        Option::some(((header.get(0) as u32) << 8) | (header.get(1) as u32))\n    } else {\n        Option::none()\n    }\n}\n\n/// 2^248: upper bound for values that fit in 31 bytes\nglobal TWO_POW_248: Field = 2.pow_32(248);\n\n/// Removes the Poseidon2-derived mask from a ciphertext field. Returns the unmasked value if it fits in 31 bytes\n/// (a content field), or `None` if it doesn't (random padding). Unconstrained to prevent accidental use in\n/// constrained context.\nunconstrained fn unmask_field(s_app: Field, index: u32, masked: Field) -> Option<Field> {\n    let unmasked = masked - derive_shared_secret_field_mask(s_app, index);\n    if unmasked.lt(TWO_POW_248) {\n        Option::some(unmasked)\n    } else {\n        Option::none()\n    }\n}\n\n/// Produces a random valid address point, i.e. one that is on the curve. This is equivalent to calling\n/// [`AztecAddress::to_address_point`] on a random valid address.\nunconstrained fn random_address_point() -> AddressPoint {\n    let mut result = std::mem::zeroed();\n\n    loop {\n        // We simply produce random x coordinates until we find one that is on the curve. About half of the x\n        // coordinates fulfill this condition, so this should only take a few iterations at most.\n        let x_coord = random();\n        let point = point_from_x_coord_and_sign(x_coord, true);\n        if point.is_some() {\n            result = AddressPoint { inner: point.unwrap() };\n            break;\n        }\n    }\n\n    result\n}\n\nmod test {\n    use crate::{\n        ephemeral::EphemeralArray,\n        keys::ecdh_shared_secret::{compute_app_siloed_shared_secret, derive_ecdh_shared_secret},\n        messages::{\n            encoding::{HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_PLAINTEXT_LEN, MESSAGE_PLAINTEXT_SIZE_IN_BYTES},\n            encryption::message_encryption::MessageEncryption,\n        },\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use super::{AES128, encode_header, random_address_point};\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt_deterministic() {\n        let env = TestEnvironment::new();\n\n        // Message decryption requires oracles that are only available during private execution\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n\n            let recipient = AztecAddress::from_field(\n                0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n            );\n\n            // Mock random values for deterministic test\n            let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n            let _ = OracleMock::mock(\"aztec_utl_getRandomField\").returns(eph_sk).times(1);\n\n            let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n            let _ = OracleMock::mock(\"aztec_utl_getRandomField\").returns(randomness).times(1000000);\n\n            let _ = OracleMock::mock(\"aztec_prv_getNextAppTagAsSender\").returns(42);\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"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
+      "source": "use crate::protocol::{address::AztecAddress, public_keys::AddressPoint, traits::ToField};\n\nuse crate::{\n    keys::{\n        ecdh_shared_secret::{\n            compute_app_siloed_shared_secret, derive_ecdh_shared_secret, derive_shared_secret_field_mask,\n            derive_shared_secret_subkey,\n        },\n        ephemeral::generate_positive_ephemeral_key_pair,\n    },\n    logging::aztecnr_warn_log_format,\n    messages::{\n        encoding::{\n            EPH_PK_X_SIZE_IN_FIELDS, HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN,\n            MESSAGE_PLAINTEXT_SIZE_IN_BYTES,\n        },\n        encryption::message_encryption::MessageEncryption,\n        logs::arithmetic_generics_utils::{\n            get_arr_of_size__message_bytes__from_PT, get_arr_of_size__message_bytes_padding__from_PT,\n        },\n    },\n    oracle::{aes128_decrypt::try_aes128_decrypt, random::random, shared_secret::get_shared_secret},\n    utils::{\n        array,\n        conversion::{\n            bytes_as_fields::{decode_bytes_from_fields, encode_bytes_as_fields},\n            fields_as_bytes::{encode_fields_as_bytes, try_decode_fields_from_bytes},\n        },\n        point::point_from_x_coord_and_sign,\n    },\n};\n\nuse std::aes128::aes128_encrypt;\n\n/// Computes N close-to-uniformly-random 256 bits from a given app-siloed shared secret.\n///\n/// NEVER re-use the same iv and sym_key. DO NOT call this function more than once with the same s_app.\n///\n/// This function is only known to be safe if s_app is derived from combining a random ephemeral key with an\n/// address point and a contract address. See big comment within the body of the function.\nfn extract_many_close_to_uniformly_random_256_bits_using_poseidon2<let N: u32>(s_app: Field) -> [[u8; 32]; N] {\n    /*\n     * Unsafe because of https://eprint.iacr.org/2010/264.pdf Page 13, Lemma 2 (and the two paragraphs below it).\n    *\n    * If you call this function, you need to be careful and aware of how the arg `s_app` has been derived.\n    *\n    * The paper says that the way you derive aes keys and IVs should be fine with poseidon2 (modelled as a RO),\n    * as long as you _don't_ use Poseidon2 as a PRG to generate the two exponents x & y which multiply to the\n    * shared secret S:\n    *\n    * S = [x*y]*G.\n    *\n    * (Otherwise, you would have to \"key\" poseidon2, i.e. generate a uniformly string K which can be public and\n    * compute Hash(x) as poseidon(K,x)).\n    * In that lemma, k would be 2*254=508, and m would be the number of points on the grumpkin curve (which is\n    * close to r according to the Hasse bound).\n    *\n    * Our shared secret S is [esk * address_sk] * G, and the question is: Can we compute hash(S) using poseidon2\n    * instead of sha256?\n    *\n    * Well, esk is random and not generated with poseidon2, so that's good.\n    * What about address_sk?\n    * Well, address_sk = poseidon2(stuff) + ivsk, so there was some discussion about whether address_sk is\n    * independent of poseidon2. Given that ivsk is random and independent of poseidon2, the address_sk is also\n    * independent of poseidon2.\n    *\n    * Tl;dr: we believe it's safe to hash S = [esk * address_sk] * G using poseidon2, in order to derive a\n    * symmetric key.\n    *\n    * If you're calling this function for a differently-derived `s_app`, be careful.\n    */\n    \n\n    /* The output of this function needs to be 32 random bytes.\n     * A single field won't give us 32 bytes of entropy. So we compute two \"random\" fields, by poseidon-hashing\n    * with two different indices. We then extract the last 16 (big endian) bytes of each \"random\" field.\n    * Note: we use to_be_bytes because it's slightly more efficient. But we have to be careful not to take bytes\n    * from the \"big end\", because the \"big\" byte is not uniformly random over the byte: it only has < 6 bits of\n    * randomness, because it's the big end of a 254-bit field element.\n    */\n\n    let mut all_bytes: [[u8; 32]; N] = std::mem::zeroed();\n    std::static_assert(N < 256, \"N too large\");\n    for k in 0..N {\n        let rand1: Field = derive_shared_secret_subkey(s_app, 2 * k);\n        let rand2: Field = derive_shared_secret_subkey(s_app, 2 * k + 1);\n\n        let rand1_bytes: [u8; 32] = rand1.to_be_bytes();\n        let rand2_bytes: [u8; 32] = rand2.to_be_bytes();\n\n        let mut bytes: [u8; 32] = [0; 32];\n        for i in 0..16 {\n            // We take bytes from the \"little end\" of the be-bytes arrays:\n            let j = 32 - i - 1;\n            bytes[i] = rand1_bytes[j];\n            bytes[16 + i] = rand2_bytes[j];\n        }\n\n        all_bytes[k] = bytes;\n    }\n\n    all_bytes\n}\n\nfn derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits<let N: u32>(\n    many_random_256_bits: [[u8; 32]; N],\n) -> [([u8; 16], [u8; 16]); N] {\n    // Many (sym_key, iv) pairs:\n    let mut many_pairs: [([u8; 16], [u8; 16]); N] = std::mem::zeroed();\n    for k in 0..N {\n        let random_256_bits = many_random_256_bits[k];\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n        for i in 0..16 {\n            sym_key[i] = random_256_bits[i];\n            iv[i] = random_256_bits[i + 16];\n        }\n        many_pairs[k] = (sym_key, iv);\n    }\n\n    many_pairs\n}\n\npub fn derive_aes_symmetric_key_and_iv_from_shared_secret<let N: u32>(s_app: Field) -> [([u8; 16], [u8; 16]); N] {\n    let many_random_256_bits: [[u8; 32]; N] = extract_many_close_to_uniformly_random_256_bits_using_poseidon2(s_app);\n\n    derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits(many_random_256_bits)\n}\n\npub struct AES128 {}\n\nimpl MessageEncryption for AES128 {\n\n    /// AES128-CBC encryption for Aztec protocol messages.\n    ///\n    /// ## Overview\n    ///\n    /// The plaintext is an array of up to `MESSAGE_PLAINTEXT_LEN` (12) fields. The output is always exactly\n    /// `MESSAGE_CIPHERTEXT_LEN` (15) fields, regardless of plaintext size. All output fields except the\n    /// ephemeral public key are uniformly random `Field` values to any observer without knowledge of the\n    /// shared secret, making all encrypted messages indistinguishable by size or content.\n    ///\n    /// ## PKCS#7 Padding\n    ///\n    /// AES operates on 16-byte blocks, so the plaintext must be padded to a multiple of 16. PKCS#7 padding always\n    /// adds at least 1 byte (so the receiver can always detect and strip it), which means:\n    /// - 1 B plaintext  -> 15 B padding -> 16 B total\n    /// - 15 B plaintext ->  1 B padding -> 16 B total\n    /// - 16 B plaintext -> 16 B padding -> 32 B total (full extra block)\n    ///\n    /// In general: if the plaintext is already a multiple of 16, a full 16-byte padding block is appended.\n    ///\n    /// ## Encryption Steps\n    ///\n    /// **1. Body encryption.** The plaintext fields are serialized to bytes (32 bytes per field) and AES-128-CBC\n    /// encrypted. Since 32 is a multiple of 16, PKCS#7 always adds a full 16-byte padding block (see above):\n    ///\n    /// ```text\n    /// +---------------------------------------------+\n    /// |                   body ct                    |\n    /// |            PlaintextLen*32 + 16 B            |\n    /// +-------------------------------+--------------+\n    /// | encrypted plaintext fields    | PKCS#7 (16B) |\n    /// | (serialized at 32 B each)     |              |\n    /// +-------------------------------+--------------+\n    /// ```\n    ///\n    /// **2. Header encryption.** The byte length of `body_ct` is stored as a 2-byte big-endian integer. This 2-byte\n    /// header plaintext is then AES-encrypted; PKCS#7 pads the remaining 14 bytes to fill one 16-byte AES block,\n    /// producing a 16-byte header ciphertext:\n    ///\n    /// ```text\n    /// +---------------------------+\n    /// |         header ct         |\n    /// |            16 B           |\n    /// +--------+------------------+\n    /// | body ct| PKCS#7 (14B)     |\n    /// | length |                  |\n    /// | (2 B)  |                  |\n    /// +--------+------------------+\n    /// ```\n    ///\n    /// ## Wire Format\n    ///\n    /// Messages are transmitted as fields, not bytes. A field is ~254 bits and can safely store 31 whole bytes, so\n    /// we need to pack our byte data into 31-byte chunks. This packing drives the wire format.\n    ///\n    /// **Step 1 -- Assemble bytes.** The ciphertexts are laid out in a byte array, padded with zero bytes to a\n    /// multiple of 31 so it divides evenly into fields:\n    ///\n    /// ```text\n    /// +------------+-------------------------+---------+\n    /// | header ct  |        body ct          | byte pad|\n    /// |   16 B     | PlaintextLen*32 + 16 B  | (zeros) |\n    /// +------------+-------------------------+---------+\n    /// |<-------- padded to a multiple of 31 B -------->|\n    /// ```\n    ///\n    /// **Step 2 -- Pack and mask.** The byte array is split into 31-byte chunks, each stored in one field. A\n    /// Poseidon2-derived mask (see `derive_shared_secret_field_mask`) is added to each so that the resulting\n    /// fields appear as uniformly random `Field` values to any observer without knowledge of the shared secret,\n    /// hiding the fact that the underlying ciphertext consists of 128-bit AES blocks.\n    ///\n    /// **Step 3 -- Assemble ciphertext.** The ephemeral public key x-coordinate is prepended and random field padding\n    /// is appended to fill to 15 fields:\n    ///\n    /// ```text\n    /// +----------+-------------------------+-------------------+\n    /// | eph_pk.x |  masked message fields   | random field pad  |\n    /// |          | (packed 31 B per field)  |  (fills to 15)    |\n    /// +----------+-------------------------+-------------------+\n    /// |<---------- MESSAGE_CIPHERTEXT_LEN = 15 fields -------->|\n    /// ```\n    ///\n    /// ## Key Derivation\n    ///\n    /// The raw ECDH shared secret point is first app-siloed into a scalar `s_app` by hashing with the contract\n    /// address (see\n    /// [`compute_app_siloed_shared_secret`](crate::keys::ecdh_shared_secret::compute_app_siloed_shared_secret)).\n    /// Two (key, IV) pairs are then derived from `s_app` via indexed Poseidon2 hashing: one pair for the body\n    /// ciphertext and one for the header ciphertext.\n    fn encrypt<let PlaintextLen: u32>(\n        plaintext: [Field; PlaintextLen],\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> [Field; MESSAGE_CIPHERTEXT_LEN] {\n        std::static_assert(\n            PlaintextLen <= MESSAGE_PLAINTEXT_LEN,\n            \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\",\n        );\n\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes. (This process is then\n        // reversed when processing the message in `process_message_ciphertext`)\n        let plaintext_bytes = encode_fields_as_bytes(plaintext);\n\n        // Derive ECDH shared secret with recipient using a fresh ephemeral keypair.\n        let (eph_sk, eph_pk) = generate_positive_ephemeral_key_pair();\n\n        let raw_shared_secret = derive_ecdh_shared_secret(\n            eph_sk,\n            recipient\n                .to_address_point()\n                .unwrap_or_else(|| {\n                    aztecnr_warn_log_format!(\n                        \"Attempted to encrypt message for an invalid recipient ({0})\",\n                    )(\n                        [recipient.to_field()],\n                    );\n\n                    // Safety: if the recipient is an invalid address, then it is not possible to encrypt a message for\n                    // them because we cannot establish a shared secret. This is never expected to occur during normal\n                    // operation. However, it is technically possible for us to receive an invalid address, and we must\n                    // therefore handle it. We could simply fail, but that'd introduce a potential security issue in\n                    // which an attacker forces a contract to encrypt a message for an invalid address, resulting in an\n                    // impossible transaction - this is sometimes called a 'king of the hill' attack. We choose instead\n                    // to not fail and encrypt the plaintext regardless using the shared secret that results from a\n                    // random valid address. The sender is free to choose this address and hence shared secret, but\n                    // this has no security implications as they already know not only the full plaintext but also the\n                    // ephemeral private key anyway.\n                    unsafe {\n                        random_address_point()\n                    }\n                })\n                .inner,\n        );\n\n        let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n        // It is safe to derive AES keys from `s_app` using Poseidon2 because `s_app` was derived from an ECDH shared\n        // secret using an AztecAddress (the recipient). See the block comment in\n        // `extract_many_close_to_uniformly_random_256_bits_using_poseidon2` for more info.\n        let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, body_iv, body_sym_key);\n\n        // Each plaintext field is 32 bytes (a multiple of the 16-byte AES block\n        // size), so PKCS#7 always appends a full 16-byte padding block:\n        //   |ciphertext| = PlaintextLen*32 + 16 = 16 * (1 + PlaintextLen*32 / 16)\n        std::static_assert(\n            ciphertext_bytes.len() == 16 * (1 + (PlaintextLen * 32) / 16),\n            \"unexpected ciphertext length\",\n        );\n\n        // Encrypt a 2-byte header containing the body ciphertext length.\n        let header_plaintext = encode_header(ciphertext_bytes.len());\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the input, according to pkcs#7; hence why\n        // the output `header_ciphertext_bytes` is 16 bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, header_iv, header_sym_key);\n        // Verify expected header ciphertext size at compile time.\n        std::static_assert(\n            header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n            \"unexpected ciphertext header length\",\n        );\n\n        // Assemble the message byte array:\n        //  [header_ct (16B)] [body_ct] [padding to mult of 31]\n        let message_bytes_padding_to_mult_31 = get_arr_of_size__message_bytes_padding__from_PT::<PlaintextLen * 32>();\n\n        let mut message_bytes = get_arr_of_size__message_bytes__from_PT::<PlaintextLen * 32>();\n\n        std::static_assert(\n            message_bytes.len() % 31 == 0,\n            \"Unexpected error: message_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        let mut offset = 0;\n        for i in 0..header_ciphertext_bytes.len() {\n            message_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            message_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..message_bytes_padding_to_mult_31.len() {\n            message_bytes[offset + i] = message_bytes_padding_to_mult_31[i];\n        }\n        offset += message_bytes_padding_to_mult_31.len();\n\n        // Ideally we would be able to have a static assert where we check that the offset would be such that we've\n        // written to the entire log_bytes array, but we cannot since Noir does not treat the offset as a comptime\n        // value (despite the values that it goes through being known at each stage). We instead check that the\n        // computation used to obtain the offset computes the expected value (which we _can_ do in a static check), and\n        // then add a cheap runtime check to also validate that the offset matches this.\n        std::static_assert(\n            header_ciphertext_bytes.len() + ciphertext_bytes.len() + message_bytes_padding_to_mult_31.len()\n                == message_bytes.len(),\n            \"unexpected message length\",\n        );\n        assert(offset == message_bytes.len(), \"unexpected encrypted message length\");\n\n        // Pack message bytes into fields (31 bytes per field) and prepend eph_pk.x.\n        let message_bytes_as_fields = encode_bytes_as_fields(message_bytes);\n\n        let mut ciphertext: [Field; MESSAGE_CIPHERTEXT_LEN] = [0; MESSAGE_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        // Mask each content field with a Poseidon2-derived value, so that they appear as uniformly random `Field`\n        // values\n        let mut offset = 1;\n        for i in 0..message_bytes_as_fields.len() {\n            let mask = derive_shared_secret_field_mask(s_app, i as u32);\n            ciphertext[offset + i] = message_bytes_as_fields[i] + mask;\n        }\n        offset += message_bytes_as_fields.len();\n\n        // Pad with random fields so that padding is indistinguishable from masked data fields.\n        for i in offset..MESSAGE_CIPHERTEXT_LEN {\n            // Safety: we assume that the sender wants for the message to be private - a malicious one could simply\n            // reveal its contents publicly. It is therefore fine to trust the sender to provide random padding.\n            ciphertext[i] = unsafe { random() };\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt(\n        ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> Option<BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>> {\n        // Extract the ephemeral public key x-coordinate and masked fields, returning None for empty ciphertext.\n        if ciphertext.len() > 0 {\n            let masked_fields: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS> =\n                array::subbvec(ciphertext, EPH_PK_X_SIZE_IN_FIELDS);\n            Option::some((ciphertext.get(0), masked_fields))\n        } else {\n            Option::none()\n        }\n            .and_then(|(eph_pk_x, masked_fields)| {\n                // With the x-coordinate of the ephemeral public key we can reconstruct the point as we know that the\n                // y-coordinate must be positive. This may fail however, as not all x-coordinates are on the curve. In\n                // that case, we simply return `Option::none`.\n                point_from_x_coord_and_sign(eph_pk_x, true).and_then(|eph_pk| {\n                    let s_app = get_shared_secret(recipient, eph_pk, contract_address);\n\n                    let unmasked_fields = masked_fields.mapi(|i, field| {\n                        let unmasked = unmask_field(s_app, i, field);\n                        // If we failed to unmask the field, we are dealing with the random padding. We'll ignore it\n                        // later, so we can simply set it to 0\n                        unmasked.unwrap_or(0)\n                    });\n                    let ciphertext_without_eph_pk_x = decode_bytes_from_fields(unmasked_fields);\n\n                    // Derive symmetric keys:\n                    let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n                    let (body_sym_key, body_iv) = pairs[0];\n                    let (header_sym_key, header_iv) = pairs[1];\n\n                    // Extract the header ciphertext\n                    let header_start = 0;\n                    let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n                        array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n                    // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's\n                    // designed to work with messages with unknown length at compile time. This would not be necessary\n                    // here as the header ciphertext length is fixed. But we do it anyway to not have to have duplicate\n                    // oracles.\n                    let header_ciphertext_bvec =\n                        BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n                    try_aes128_decrypt(header_ciphertext_bvec, header_iv, header_sym_key)\n                    // Extract ciphertext length from header (2 bytes, big-endian)\n                    .and_then(|header_plaintext| extract_ciphertext_length(header_plaintext))\n                        .filter(|ciphertext_length| ciphertext_length <= MESSAGE_PLAINTEXT_SIZE_IN_BYTES)\n                        .map(|ciphertext_length| {\n                            // Extract and decrypt main ciphertext\n                            let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n                            let ciphertext_with_padding: [u8; MESSAGE_PLAINTEXT_SIZE_IN_BYTES] =\n                                array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n                            BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length)\n                        })\n                        // Decrypt main ciphertext and return it\n                        .and_then(|ciphertext| try_aes128_decrypt(ciphertext, body_iv, body_sym_key))\n                        // Convert bytes back to fields (32 bytes per field). Returns None if the actual bytes are\n                        // not valid.\n                        .and_then(|plaintext_bytes| try_decode_fields_from_bytes(plaintext_bytes))\n                })\n            })\n    }\n}\n\n/// Encodes the body ciphertext length into a 2-byte big-endian header.\nfn encode_header(ciphertext_length: u32) -> [u8; 2] {\n    [(ciphertext_length >> 8) as u8, ciphertext_length as u8]\n}\n\n/// Extracts the body ciphertext length from a decrypted header as a 2-byte big-endian integer.\n///\n/// Returns `Option::none()` if the header has fewer than 2 bytes.\nunconstrained fn extract_ciphertext_length<let N: u32>(header: BoundedVec<u8, N>) -> Option<u32> {\n    if header.len() >= 2 {\n        Option::some(((header.get(0) as u32) << 8) | (header.get(1) as u32))\n    } else {\n        Option::none()\n    }\n}\n\n/// 2^248: upper bound for values that fit in 31 bytes\nglobal TWO_POW_248: Field = 2.pow_32(248);\n\n/// Removes the Poseidon2-derived mask from a ciphertext field. Returns the unmasked value if it fits in 31 bytes\n/// (a content field), or `None` if it doesn't (random padding). Unconstrained to prevent accidental use in\n/// constrained context.\nunconstrained fn unmask_field(s_app: Field, index: u32, masked: Field) -> Option<Field> {\n    let unmasked = masked - derive_shared_secret_field_mask(s_app, index);\n    if unmasked.lt(TWO_POW_248) {\n        Option::some(unmasked)\n    } else {\n        Option::none()\n    }\n}\n\n/// Produces a random valid address point, i.e. one that is on the curve. This is equivalent to calling\n/// [`AztecAddress::to_address_point`] on a random valid address.\nunconstrained fn random_address_point() -> AddressPoint {\n    let mut result = std::mem::zeroed();\n\n    loop {\n        // We simply produce random x coordinates until we find one that is on the curve. About half of the x\n        // coordinates fulfill this condition, so this should only take a few iterations at most.\n        let x_coord = random();\n        let point = point_from_x_coord_and_sign(x_coord, true);\n        if point.is_some() {\n            result = AddressPoint { inner: point.unwrap() };\n            break;\n        }\n    }\n\n    result\n}\n\nmod test {\n    use crate::{\n        ephemeral::EphemeralArray,\n        keys::ecdh_shared_secret::{compute_app_siloed_shared_secret, derive_ecdh_shared_secret},\n        messages::{\n            encoding::{HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_PLAINTEXT_LEN, MESSAGE_PLAINTEXT_SIZE_IN_BYTES},\n            encryption::message_encryption::MessageEncryption,\n        },\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use super::{AES128, encode_header, random_address_point};\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt_deterministic() {\n        let env = TestEnvironment::new();\n\n        // Message decryption requires oracles that are only available during private execution\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n\n            let recipient = AztecAddress::from_field(\n                0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n            );\n\n            // Mock random values for deterministic test\n            let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n            let _ = OracleMock::mock(\"aztec_misc_getRandomField\").returns(eph_sk).times(1);\n\n            let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n            let _ = OracleMock::mock(\"aztec_misc_getRandomField\").returns(randomness).times(1000000);\n\n            // Encrypt the message\n            let encrypted_message = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            // Compute the same app-siloed shared secret that the oracle would return\n            let raw_shared_secret = derive_ecdh_shared_secret(\n                EmbeddedCurveScalar::from_field(eph_sk),\n                recipient.to_address_point().unwrap().inner,\n            );\n            let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n            // The shared-secrets oracle is batched: it returns a slot pointing at an EphemeralArray\n            // populated with the per-key results. Set up that array with the single expected `s_app`\n            // and mock the oracle to return its slot.\n            let response_slot: Field = 99;\n            let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n            response_array.push(s_app);\n            let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n\n            // Decrypt the message\n            let decrypted = AES128::decrypt(encrypted_message, recipient, contract_address).unwrap();\n\n            // The decryption function spits out a BoundedVec because it's designed to work with messages with unknown\n            // length at compile time. For this reason we need to convert the original input to a BoundedVec.\n            let plaintext_bvec = BoundedVec::<Field, MESSAGE_PLAINTEXT_LEN>::from_array(plaintext);\n\n            // Verify decryption matches original plaintext\n            assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n            // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n            // static methods of the struct).\n            let _ = AES128 {};\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_random() {\n        // Same as `encrypt_decrypt_deterministic`, except we don't mock any of the oracles and rely on\n        // `TestEnvironment` instead.\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_to_invalid_address() {\n        // x = 3 is a non-residue for this curve, resulting in an invalid address\n        let invalid_address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n\n        let _ = AES128::encrypt([1, 2, 3, 4], invalid_address, contract_address);\n    }\n\n    // Documents the PKCS#7 padding behavior that `encrypt` relies on (see its static_assert).\n    #[test]\n    fn pkcs7_padding_always_adds_at_least_one_byte() {\n        let key = [0 as u8; 16];\n        let iv = [0 as u8; 16];\n\n        // 1 byte input + 15 bytes padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 1], iv, key).len(), 16);\n\n        // 15 bytes input + 1 byte padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 15], iv, key).len(), 16);\n\n        // 16 bytes input (block-aligned) + full 16-byte padding block = 32 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 16], iv, key).len(), 32);\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_max_size_plaintext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let mut plaintext = [0; MESSAGE_PLAINTEXT_LEN];\n            for i in 0..MESSAGE_PLAINTEXT_LEN {\n                plaintext[i] = i as Field;\n            }\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test(should_fail_with = \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\")]\n    unconstrained fn encrypt_oversized_plaintext() {\n        let address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n        let plaintext: [Field; MESSAGE_PLAINTEXT_LEN + 1] = [0; MESSAGE_PLAINTEXT_LEN + 1];\n        let _ = AES128::encrypt(plaintext, address, contract_address);\n    }\n\n    #[test]\n    unconstrained fn random_address_point_produces_valid_points() {\n        // About half of random addresses are invalid, so testing just a couple gives us high confidence that\n        // `random_address_point` is indeed producing valid addresses.\n        for _ in 0..10 {\n            let random_address = AztecAddress { inner: random_address_point().inner.x };\n            assert(random_address.to_address_point().is_some());\n        }\n    }\n\n    #[test]\n    unconstrained fn decrypt_invalid_ephemeral_public_key() {\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3, 4];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            // The first field of the ciphertext is the x-coordinate of the ephemeral public key. We set it to a known\n            // non-residue (3), causing `decrypt` to fail to produce a decryption shared secret.\n            let mut bad_ciphertext = BoundedVec::from_array(ciphertext);\n            bad_ciphertext.set(0, 3);\n\n            assert(AES128::decrypt(bad_ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_ciphertext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            assert(AES128::decrypt(BoundedVec::new(), recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header AES decrypt oracle to return an empty result. The TS oracle never throws on invalid\n    // input: it decrypts to garbage bytes or returns empty\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_header() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let empty_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::new();\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(empty_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header oracle to return a 2-byte header that decodes to a ciphertext_length one past the maximum\n    // allowed value, verifying the edge case is handled correctly.\n    #[test]\n    unconstrained fn decrypt_returns_none_on_oversized_ciphertext_length() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let bad_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(encode_header(\n                MESSAGE_PLAINTEXT_SIZE_IN_BYTES + 1,\n            ));\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(bad_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n}\n"
     },
-    "139": {
+    "140": {
       "function_locations": [
         {
           "name": "encode_private_event_message",
@@ -389,10 +389,10 @@
           "start": 6064
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
       "source": "use crate::{\n    event::{event_interface::EventInterface, EventSelector},\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n    },\n    utils::array,\n};\nuse crate::protocol::traits::{FromField, Serialize, ToField};\n\n/// The number of fields in a private event message content that are not the event's serialized representation (1 field\n/// for randomness).\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 1;\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 0;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_event_message`].\npub fn encode_private_event_message<Event>(\n    event: Event,\n    randomness: Field,\n) -> [Field; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Event: EventInterface + Serialize,\n{\n    std::static_assert(\n        <Event as Serialize>::N <= MAX_EVENT_SERIALIZED_LEN,\n        \"event's serialized length exceeds the maximum allowed for private events\",\n    );\n\n    // We use `Serialize` because we want for events to be processable by off-chain actors, e.g. block explorers,\n    // wallets and apps, without having to rely on contract invocation. If we used `Packable` we'd need to call utility\n    // functions in order to unpack events, which would introduce a level of complexity we don't currently think is\n    // worth the savings in DA (for public events) and proving time (when encrypting private event messages).\n    let serialized_event = event.serialize();\n\n    // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_plaintext = [0; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N];\n    msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n\n    for i in 0..serialized_event.len() {\n        msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = serialized_event[i];\n    }\n\n    // The event type id is stored in the message metadata\n    encode_message(\n        PRIVATE_EVENT_MSG_TYPE_ID,\n        Event::get_event_type_id().to_field() as u64,\n        msg_plaintext,\n    )\n}\n\n/// Decodes the plaintext from a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_event_message`].\n///\n/// Note that while [`encode_private_event_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_event_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(EventSelector, Field, BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>)> {\n    if msg_content.len() <= PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n        // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // destructuring of the private event message encoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n            \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let randomness = msg_content.get(PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let serialized_event = array::subbvec(msg_content, PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((event_type_id, randomness, serialized_event))\n    }\n}\n\nmod test {\n    use crate::{\n        event::event_interface::EventInterface,\n        messages::{\n            encoding::decode_message,\n            logs::event::{decode_private_event_message, encode_private_event_message},\n            msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n        },\n    };\n    use crate::protocol::traits::Serialize;\n    use crate::test::mocks::mock_event::MockEvent;\n\n    global VALUE: Field = 7;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let event = MockEvent::new(VALUE).build_event();\n\n        let message_plaintext = encode_private_event_message(event, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_EVENT_MSG_TYPE_ID);\n\n        let (event_type_id, randomness, serialized_event) =\n            decode_private_event_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(event_type_id, MockEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event, BoundedVec::from_array(event.serialize()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_event_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0]);\n        assert(decode_private_event_message(0, content).is_none());\n    }\n}\n"
     },
-    "141": {
+    "142": {
       "function_locations": [
         {
           "name": "encode_private_note_message_with_msg_type_id",
@@ -435,10 +435,10 @@
           "start": 8407
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
       "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\n\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX: u32 = 1;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 2;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, randomness, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private note message with the given `msg_type_id`.\n///\n/// Shared encoder used by [`encode_private_note_message`] and by custom message handlers that use the same format as\n/// standard private note message but perform additional validation logic.\npub fn encode_private_note_message_with_msg_type_id<Note>(\n    msg_type_id: u64,\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    let packed_note = note.pack();\n\n    // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_content = [0; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N];\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX] = storage_slot;\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    for i in 0..packed_note.len() {\n        msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_note[i];\n    }\n\n    // Notes use the note type id for metadata\n    encode_message(msg_type_id, Note::get_id() as u64, msg_content)\n}\n\n/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_note_message`].\npub fn encode_private_note_message<Note>(\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    encode_private_note_message_with_msg_type_id(\n        PRIVATE_NOTE_MSG_TYPE_ID,\n        note,\n        owner,\n        storage_slot,\n        randomness,\n    )\n}\n\n/// Decodes the plaintext from a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_note_message`].\n///\n/// Note that while [`encode_private_note_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_note_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(Field, AztecAddress, Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>)> {\n    if msg_content.len() <= PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // decoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let owner = AztecAddress::from_field(msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX));\n        let storage_slot = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX);\n        let randomness = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((note_type_id, owner, storage_slot, randomness, packed_note))\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::note::{decode_private_note_message, encode_private_note_message, MAX_NOTE_PACKED_LEN},\n            msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global STORAGE_SLOT: Field = 9;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[derive(Packable)]\n    struct MaxSizeNote {\n        data: [Field; MAX_NOTE_PACKED_LEN],\n    }\n\n    impl NoteType for MaxSizeNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_note() {\n        let mut data = [0; MAX_NOTE_PACKED_LEN];\n        for i in 0..MAX_NOTE_PACKED_LEN {\n            data[i] = i as Field;\n        }\n        let note = MaxSizeNote { data };\n\n        let encoded = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n        let (msg_type_id, msg_metadata, msg_content) = decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MaxSizeNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(data));\n    }\n\n    #[derive(Packable)]\n    struct OversizedNote {\n        data: [Field; MAX_NOTE_PACKED_LEN + 1],\n    }\n\n    impl NoteType for OversizedNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_note_fails() {\n        let note = OversizedNote { data: [0; MAX_NOTE_PACKED_LEN + 1] };\n        let _ = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_note_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        assert(decode_private_note_message(0, content).is_none());\n    }\n}\n"
     },
-    "142": {
+    "143": {
       "function_locations": [
         {
           "name": "encode_partial_note_private_message",
@@ -461,7 +461,7 @@
           "start": 7197
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/partial_note.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "15": {
@@ -534,29 +534,29 @@
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
     },
-    "152": {
+    "153": {
       "function_locations": [
         {
           "name": "enqueue_note_for_validation",
-          "start": 3726
+          "start": 3744
         },
         {
           "name": "enqueue_event_for_validation",
-          "start": 5089
+          "start": 5107
         },
         {
           "name": "validate_and_store_enqueued_notes_and_events",
-          "start": 5757
+          "start": 5775
         },
         {
           "name": "get_pending_partial_notes_completion_logs",
-          "start": 7055
+          "start": 7073
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
-      "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\nmod message_context;\npub use message_context::MessageContext;\n\nmod note_validation_request;\npub use note_validation_request::NoteValidationRequest;\n\npub(crate) mod log_retrieval_request;\npub(crate) mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\n\nuse crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\n        discovery::partial_notes::DeliveredPendingPartialNote,\n        encoding::MESSAGE_CIPHERTEXT_LEN,\n        logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},\n        processing::{log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse},\n    },\n    oracle::message_processing,\n};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n    hash::{compute_log_tag, sha256_to_field},\n    traits::{Deserialize, Serialize},\n};\nuse event_validation_request::EventValidationRequest;\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// An offchain-delivered message with resolved context, ready for processing during sync.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessageWithContext {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub message_context: MessageContext,\n}\n\n/// Enqueues a note for validation and storage by PXE.\n///\n/// Once validated, the note becomes retrievable via the `get_notes` oracle. The note will be scoped to\n/// `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many note validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value is\n/// typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are the\n/// inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and `NoteHash::compute_nullifier`. PXE\n/// will verify that the siloed unique note hash was inserted into the tree at `tx_hash`, and will store the nullifier\n/// to later check for nullification.\n///\n/// `owner` is the address used in note hash and nullifier computation, often requiring knowledge of their nullifier\n/// secret key.\n///\n/// `scope` is the account to which the note message was delivered (i.e. the address the message was encrypted to).\n/// This determines which PXE account can see the note - other accounts will not be able to access it (e.g. other\n/// accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized. In\n/// most cases `recipient` equals `owner`, but they can differ in scenarios like delegated discovery.\npub unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(NoteValidationRequest::new(\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n    ))\n}\n\n/// Enqueues an event for validation and storage by PXE.\n///\n/// This is the primary way for custom message handlers (registered via\n/// [`crate::macros::AztecConfig::custom_message_handler`]) to deliver reassembled events back to PXE after processing\n/// application-specific message formats.\n///\n/// In order for the event validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many event validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// Note that `validate_and_store_enqueued_notes_and_events` is called by Aztec.nr after processing messages, so custom\n/// message processors do not need to be concerned with this.\npub unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    randomness: Field,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(EventValidationRequest::new(\n        contract_address,\n        event_type_id,\n        randomness,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n    ))\n}\n\n/// Validates and stores all enqueued notes and events.\n///\n/// Processes all requests enqueued via [`enqueue_note_for_validation`] and [`enqueue_event_for_validation`], inserting\n/// them into the note database and event store respectively, making them queryable via `get_notes` oracle and our TS\n/// API (PXE::getPrivateEvents).\npub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAddress) {\n    message_processing::validate_and_store_enqueued_notes_and_events(\n        EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        scope,\n    );\n\n    // Defensive clearing: purge the queues after processing to prevent double-processing if this function is called\n    // more than once in the same call frame. It is currently defensive because we only call this once per sync run.\n    let _ = EphemeralArray::<NoteValidationRequest>::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n    let _ = EphemeralArray::<EventValidationRequest>::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a nested `EphemeralArray`, one inner\n/// array per pending partial note, each containing all matching `LogRetrievalResponse`s (which may be empty if no\n/// logs were found).\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    let log_retrieval_requests = EphemeralArray::at(LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the EphemeralArray. Because we need the indices\n    // in the request array to match the indices in the partial note array, we can't use EphemeralArray::for_each, as\n    // that function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push\n    // into the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        // Partial note completion logs are emitted with a domain-separated tag. To find matching logs, we apply the\n        // same domain separation to the stored raw tag.\n        let log_tag = compute_log_tag(\n            pending_partial_note.note_completion_log_tag,\n            DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n        );\n        log_retrieval_requests.push(LogRetrievalRequest::new(contract_address, log_tag));\n        i += 1;\n    }\n\n    let responses = message_processing::get_logs_by_tag(log_retrieval_requests);\n\n    // Defensive clearing: prevent stale requests if this function is called more than once in the same call frame.\n    let _ = log_retrieval_requests.clear();\n\n    responses\n}\n"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
+      "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\nmod message_context;\npub use message_context::MessageContext;\n\nmod note_validation_request;\npub use note_validation_request::NoteValidationRequest;\n\npub mod log_retrieval_request;\npub mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\npub(crate) mod provided_secret;\n\nuse crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\n        discovery::partial_notes::DeliveredPendingPartialNote,\n        encoding::MESSAGE_CIPHERTEXT_LEN,\n        logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},\n        processing::{log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse},\n    },\n    oracle::message_processing,\n};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n    hash::{compute_log_tag, sha256_to_field},\n    traits::{Deserialize, Serialize},\n};\nuse event_validation_request::EventValidationRequest;\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// An offchain-delivered message with resolved context, ready for processing during sync.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessageWithContext {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub message_context: MessageContext,\n}\n\n/// Enqueues a note for validation and storage by PXE.\n///\n/// Once validated, the note becomes retrievable via the `get_notes` oracle. The note will be scoped to\n/// `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many note validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value is\n/// typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are the\n/// inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and `NoteHash::compute_nullifier`. PXE\n/// will verify that the siloed unique note hash was inserted into the tree at `tx_hash`, and will store the nullifier\n/// to later check for nullification.\n///\n/// `owner` is the address used in note hash and nullifier computation, often requiring knowledge of their nullifier\n/// secret key.\n///\n/// `scope` is the account to which the note message was delivered (i.e. the address the message was encrypted to).\n/// This determines which PXE account can see the note - other accounts will not be able to access it (e.g. other\n/// accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized. In\n/// most cases `recipient` equals `owner`, but they can differ in scenarios like delegated discovery.\npub unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(NoteValidationRequest::new(\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n    ))\n}\n\n/// Enqueues an event for validation and storage by PXE.\n///\n/// This is the primary way for custom message handlers (registered via\n/// [`crate::macros::AztecConfig::custom_message_handler`]) to deliver reassembled events back to PXE after processing\n/// application-specific message formats.\n///\n/// In order for the event validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many event validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// Note that `validate_and_store_enqueued_notes_and_events` is called by Aztec.nr after processing messages, so custom\n/// message processors do not need to be concerned with this.\npub unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    randomness: Field,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(EventValidationRequest::new(\n        contract_address,\n        event_type_id,\n        randomness,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n    ))\n}\n\n/// Validates and stores all enqueued notes and events.\n///\n/// Processes all requests enqueued via [`enqueue_note_for_validation`] and [`enqueue_event_for_validation`], inserting\n/// them into the note database and event store respectively, making them queryable via `get_notes` oracle and our TS\n/// API (PXE::getPrivateEvents).\npub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAddress) {\n    message_processing::validate_and_store_enqueued_notes_and_events(\n        EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        scope,\n    );\n\n    // Defensive clearing: purge the queues after processing to prevent double-processing if this function is called\n    // more than once in the same call frame. It is currently defensive because we only call this once per sync run.\n    let _ = EphemeralArray::<NoteValidationRequest>::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n    let _ = EphemeralArray::<EventValidationRequest>::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns a nested `EphemeralArray`, one inner\n/// array per pending partial note, each containing all matching `LogRetrievalResponse`s (which may be empty if no\n/// logs were found).\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    let log_retrieval_requests = EphemeralArray::at(LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the EphemeralArray. Because we need the indices\n    // in the request array to match the indices in the partial note array, we can't use EphemeralArray::for_each, as\n    // that function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push\n    // into the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        // Partial note completion logs are emitted with a domain-separated tag. To find matching logs, we apply the\n        // same domain separation to the stored raw tag.\n        let log_tag = compute_log_tag(\n            pending_partial_note.note_completion_log_tag,\n            DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n        );\n        log_retrieval_requests.push(LogRetrievalRequest::new(contract_address, log_tag));\n        i += 1;\n    }\n\n    let responses = message_processing::get_logs_by_tag(log_retrieval_requests);\n\n    // Defensive clearing: prevent stale requests if this function is called more than once in the same call frame.\n    let _ = log_retrieval_requests.clear();\n\n    responses\n}\n"
     },
-    "154": {
+    "155": {
       "function_locations": [
         {
           "name": "receive",
@@ -568,47 +568,47 @@
         },
         {
           "name": "test::setup",
-          "start": 11128
+          "start": 11124
         },
         {
           "name": "test::make_msg",
-          "start": 11458
+          "start": 11454
         },
         {
           "name": "test::advance_by",
-          "start": 11741
+          "start": 11737
         },
         {
           "name": "test::empty_inbox_returns_empty_result",
-          "start": 11932
+          "start": 11928
         },
         {
           "name": "test::tx_bound_msg_expires_after_max_msg_ttl",
-          "start": 12395
+          "start": 12391
         },
         {
           "name": "test::tx_bound_msg_not_expired_before_max_msg_ttl",
-          "start": 13360
+          "start": 13356
         },
         {
           "name": "test::tx_less_msg_expires_after_max_msg_ttl",
-          "start": 14318
+          "start": 14314
         },
         {
           "name": "test::unresolved_tx_stays_in_inbox",
-          "start": 15260
+          "start": 15256
         },
         {
           "name": "test::multiple_messages_mixed_expiration",
-          "start": 16154
+          "start": 16150
         },
         {
           "name": "test::resolved_msg_is_ready_to_process",
-          "start": 17893
+          "start": 17889
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain.nr",
-      "source": "use crate::{\n    capsules::CapsuleArray,\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithContext},\n    oracle::contract_sync::set_contract_sync_cache_invalid,\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::sha256_to_field,\n        traits::{Deserialize, Serialize},\n    },\n};\n\n/// Base capsule slot for the persistent inbox of [`PendingOffchainMsg`] entries.\n///\n/// This is the slot where we accumulate messages received through [`receive`].\nglobal OFFCHAIN_INBOX_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_INBOX_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to pass tx hash resolution requests to PXE.\nglobal OFFCHAIN_CONTEXT_REQUESTS_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_CONTEXT_REQUESTS_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to collect messages ready for processing.\nglobal OFFCHAIN_READY_MESSAGES_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_READY_MESSAGES_SLOT\".as_bytes());\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// Tolerance added to the `MAX_TX_LIFETIME` cap for message expiration.\nglobal TX_EXPIRATION_TOLERANCE: u64 = 7200; // 2 hours\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\nglobal MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + TX_EXPIRATION_TOLERANCE;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an `OffchainInboxSync` is [`sync_inbox`], which manages an inbox with expiration\n/// based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\n/// An offchain message awaiting processing (or re-processing) in the inbox.\n///\n/// Messages remain in the inbox until they expire, even if they have already been processed. This is necessary to\n/// handle reorgs: a processed message may need to be re-processed if the transaction that provided its context is\n/// reverted. On each sync, resolved messages are promoted to [`OffchainMessageWithContext`] for processing.\n#[derive(Serialize, Deserialize)]\nstruct PendingOffchainMsg {\n    /// The encrypted message payload.\n    ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. A value of 0 indicates a tx-less message.\n    tx_hash: Field,\n    /// Anchor block timestamp at message emission. Used to compute the effective expiration: messages are evicted\n    /// after `anchor_block_timestamp + MAX_MSG_TTL`.\n    anchor_block_timestamp: u64,\n}\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Each message is routed to the inbox scoped to its `recipient` field, so messages for different accounts are\n/// automatically isolated.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The effective expiration is\n/// `anchor_block_timestamp + MAX_MSG_TTL`.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // May contain duplicates if multiple messages target the same recipient. This is harmless since\n    // cache invalidation on the TS side is idempotent (deleting an already-deleted key is a no-op).\n    let mut scopes: BoundedVec<AztecAddress, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n    let mut i = 0;\n    let messages_len = messages.len();\n    while i < messages_len {\n        let msg = messages.get(i);\n        let tx_hash = if msg.tx_hash.is_some() {\n            msg.tx_hash.unwrap()\n        } else {\n            0\n        };\n        let inbox: CapsuleArray<PendingOffchainMsg> =\n            CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, msg.recipient);\n        inbox.push(\n            PendingOffchainMsg {\n                ciphertext: msg.ciphertext,\n                recipient: msg.recipient,\n                tx_hash,\n                anchor_block_timestamp: msg.anchor_block_timestamp,\n            },\n        );\n        scopes.push(msg.recipient);\n        i += 1;\n    }\n\n    set_contract_sync_cache_invalid(contract_address, scopes);\n}\n\n/// Returns offchain-delivered messages to process during sync.\n///\n/// Messages remain in the inbox and are reprocessed on each sync until their originating transaction is no longer at\n/// risk of being dropped by a reorg.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, scope);\n    let context_resolution_requests: EphemeralArray<Field> = EphemeralArray::at(OFFCHAIN_CONTEXT_REQUESTS_SLOT).clear();\n    let ready_to_process: EphemeralArray<OffchainMessageWithContext> =\n        EphemeralArray::at(OFFCHAIN_READY_MESSAGES_SLOT).clear();\n\n    // Build a request list aligned with the inbox indices.\n    let mut i = 0;\n    let inbox_len = inbox.len();\n    while i < inbox_len {\n        let msg = inbox.get(i);\n        context_resolution_requests.push(msg.tx_hash);\n        i += 1;\n    }\n\n    // Ask PXE to resolve contexts for all requested tx hashes. The oracle returns responses in a new\n    // ephemeral array.\n    let resolved_contexts =\n        crate::oracle::message_processing::get_message_contexts_by_tx_hash(context_resolution_requests);\n\n    assert_eq(resolved_contexts.len(), inbox_len);\n\n    let now = UtilityContext::new().timestamp();\n\n    let mut j = inbox_len;\n    while j > 0 {\n        // This loop decides what to do with each message in the offchain message inbox. We need to handle 3\n        // different scenarios for each message.\n        //\n        // 1. The TX that emitted this message is still not known to PXE: in this case we can't yet process this\n        // message, as any notes or events discovered will fail to be validated. So we leave the message in the inbox,\n        // awaiting for future syncs to detect that the TX became available.\n        //\n        // 2. The message is not associated to a TX to begin with. The current version of offchain message processing\n        // does not support this case, but in the future it will. Right now, a message without an associated TX will\n        // sit in the inbox until it expires.\n        //\n        // 3. The TX that emitted this message has been found by PXE. That gives us all the information needed to\n        // process the message. We add the message to the `ready_to_process` EphemeralArray so that the `sync_state`\n        // loop\n        // processes it.\n        //\n        // In all cases, if the message has expired (i.e. `now > anchor_block_timestamp + MAX_MSG_TTL`), we remove it\n        // from the inbox.\n        //\n        // Note: the loop runs backwards because it might call `inbox.remove(j)` to purge expired messages and we also\n        // need to align it with `resolved_contexts.get(j)`. Going from last to first simplifies the algorithm as\n        // not yet visited element indexes remain stable.\n        j -= 1;\n        let maybe_ctx = resolved_contexts.get(j);\n        let msg = inbox.get(j);\n\n        // Compute the message's effective expiration timestamp to determine if we can purge it from the inbox.\n        let effective_expiration = msg.anchor_block_timestamp + MAX_MSG_TTL;\n\n        // Message expired. We remove it from the inbox.\n        if now > effective_expiration {\n            inbox.remove(j);\n        }\n\n        // Scenario 1: associated TX not yet available. We keep the message in the inbox, as it might become\n        // processable as new blocks get mined.\n        // Scenario 2: no TX associated to message. The message will sit in the inbox until it expires.\n        if maybe_ctx.is_none() {\n            continue;\n        }\n\n        // Scenario 3: Message is ready to process, add to result array. Note we still keep it in the inbox unless we\n        // consider it has expired: this is because we need to account for reorgs. If reorg occurs after we processed\n        // a message, the effects of processing the message get rewind. However, the associated TX can be included in\n        // a subsequent block. Should that happen, the message must be re-processed to ensure consistency.\n        let message_context = maybe_ctx.unwrap();\n        ready_to_process.push(OffchainMessageWithContext { message_ciphertext: msg.ciphertext, message_context });\n    }\n\n    ready_to_process\n}\n\nmod test {\n    use crate::{\n        capsules::CapsuleArray, oracle::random::random, protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{\n        MAX_MSG_TTL, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OFFCHAIN_INBOX_SLOT, OffchainMessage, PendingOffchainMsg,\n        receive, sync_inbox,\n    };\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let result = sync_inbox(context.this_address(), scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> =\n                CapsuleArray::at(context.this_address(), OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(inbox.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_not_expired_before_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance, but not past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_less_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::none(), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_tx_stays_in_inbox() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // not resolved, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let survivor_tx_hash = random();\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor_ts in the past so it expires at\n            // anchor_ts + MAX_MSG_TTL. We set anchor to 0 so it expires quickly.\n            msgs.push(make_msg(scope, Option::some(random()), 0));\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(make_msg(scope, Option::some(survivor_tx_hash), anchor_ts));\n            // Message 2: tx-less, anchor_ts=0 so it also expires.\n            msgs.push(make_msg(scope, Option::none(), 0));\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor_ts=0, but not for anchor_ts=anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            // Message 0 expired (anchor=0), message 1 survived (anchor=anchor_ts),\n            // Message 2 expired (anchor=0).\n            assert_eq(inbox.len(), 1);\n            assert_eq(inbox.get(0).tx_hash, survivor_tx_hash);\n        });\n    }\n\n    // -- Resolved context (ready to process) ------------------------------\n\n    #[test]\n    unconstrained fn resolved_msg_is_ready_to_process() {\n        let (env, scope) = setup();\n        // TestEnvironment::new() deploys protocol contracts, creating blocks with tx effects.\n        // In TXE, tx hashes equal Fr(blockNumber), so Fr(1) is the tx effect from block 1.\n        // We use this as a \"known resolvable\" tx hash.\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(known_tx_hash), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            // The message should be ready to process since its tx context was resolved.\n            assert_eq(result.len(), 1);\n\n            let ctx = result.get(0).message_context;\n            assert_eq(ctx.tx_hash, known_tx_hash);\n            assert(ctx.first_nullifier_in_tx != 0, \"resolved context must have a first nullifier\");\n\n            // Message stays in inbox (not expired) for potential reorg reprocessing.\n            assert_eq(inbox.len(), 1);\n        });\n    }\n}\n"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/messages/processing/offchain.nr",
+      "source": "use crate::{\n    capsules::CapsuleArray,\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithContext},\n    oracle::contract_sync::set_contract_sync_cache_invalid,\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::sha256_to_field,\n        traits::{Deserialize, Serialize},\n    },\n};\n\n/// Base capsule slot for the persistent inbox of [`PendingOffchainMsg`] entries.\n///\n/// This is the slot where we accumulate messages received through [`receive`].\nglobal OFFCHAIN_INBOX_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_INBOX_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to pass tx hash resolution requests to PXE.\nglobal OFFCHAIN_CONTEXT_REQUESTS_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_CONTEXT_REQUESTS_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to collect messages ready for processing.\nglobal OFFCHAIN_READY_MESSAGES_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_READY_MESSAGES_SLOT\".as_bytes());\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// Tolerance added to the `MAX_TX_LIFETIME` cap for message expiration.\nglobal TX_EXPIRATION_TOLERANCE: u64 = 7200; // 2 hours\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\nglobal MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + TX_EXPIRATION_TOLERANCE;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an `OffchainInboxSync` is [`sync_inbox`], which manages an inbox with expiration\n/// based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\n/// An offchain message awaiting processing (or re-processing) in the inbox.\n///\n/// Messages remain in the inbox until they expire, even if they have already been processed. This is necessary to\n/// handle reorgs: a processed message may need to be re-processed if the transaction that provided its context is\n/// reverted. On each sync, resolved messages are promoted to [`OffchainMessageWithContext`] for processing.\n#[derive(Serialize, Deserialize)]\nstruct PendingOffchainMsg {\n    /// The encrypted message payload.\n    ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. A value of 0 indicates a tx-less message.\n    tx_hash: Field,\n    /// Anchor block timestamp at message emission. Used to compute the effective expiration: messages are evicted\n    /// after `anchor_block_timestamp + MAX_MSG_TTL`.\n    anchor_block_timestamp: u64,\n}\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Each message is routed to the inbox scoped to its `recipient` field, so messages for different accounts are\n/// automatically isolated.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The effective expiration is\n/// `anchor_block_timestamp + MAX_MSG_TTL`.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // May contain duplicates if multiple messages target the same recipient. This is harmless since\n    // cache invalidation on the TS side is idempotent (deleting an already-deleted key is a no-op).\n    let mut scopes: BoundedVec<AztecAddress, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n    let mut i = 0;\n    let messages_len = messages.len();\n    while i < messages_len {\n        let msg = messages.get(i);\n        let tx_hash = if msg.tx_hash.is_some() {\n            msg.tx_hash.unwrap()\n        } else {\n            0\n        };\n        let inbox: CapsuleArray<PendingOffchainMsg> =\n            CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, msg.recipient);\n        inbox.push(\n            PendingOffchainMsg {\n                ciphertext: msg.ciphertext,\n                recipient: msg.recipient,\n                tx_hash,\n                anchor_block_timestamp: msg.anchor_block_timestamp,\n            },\n        );\n        scopes.push(msg.recipient);\n        i += 1;\n    }\n\n    set_contract_sync_cache_invalid(contract_address, scopes);\n}\n\n/// Returns offchain-delivered messages to process during sync.\n///\n/// Messages remain in the inbox and are reprocessed on each sync until their originating transaction is no longer at\n/// risk of being dropped by a reorg.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, scope);\n    let context_resolution_requests: EphemeralArray<Field> = EphemeralArray::empty_at(OFFCHAIN_CONTEXT_REQUESTS_SLOT);\n    let ready_to_process: EphemeralArray<OffchainMessageWithContext> =\n        EphemeralArray::empty_at(OFFCHAIN_READY_MESSAGES_SLOT);\n\n    // Build a request list aligned with the inbox indices.\n    let mut i = 0;\n    let inbox_len = inbox.len();\n    while i < inbox_len {\n        let msg = inbox.get(i);\n        context_resolution_requests.push(msg.tx_hash);\n        i += 1;\n    }\n\n    // Ask PXE to resolve contexts for all requested tx hashes. The oracle returns responses in a new\n    // ephemeral array.\n    let resolved_contexts =\n        crate::oracle::message_processing::get_message_contexts_by_tx_hash(context_resolution_requests);\n\n    assert_eq(resolved_contexts.len(), inbox_len);\n\n    let now = UtilityContext::new().timestamp();\n\n    let mut j = inbox_len;\n    while j > 0 {\n        // This loop decides what to do with each message in the offchain message inbox. We need to handle 3\n        // different scenarios for each message.\n        //\n        // 1. The TX that emitted this message is still not known to PXE: in this case we can't yet process this\n        // message, as any notes or events discovered will fail to be validated. So we leave the message in the inbox,\n        // awaiting for future syncs to detect that the TX became available.\n        //\n        // 2. The message is not associated to a TX to begin with. The current version of offchain message processing\n        // does not support this case, but in the future it will. Right now, a message without an associated TX will\n        // sit in the inbox until it expires.\n        //\n        // 3. The TX that emitted this message has been found by PXE. That gives us all the information needed to\n        // process the message. We add the message to the `ready_to_process` EphemeralArray so that the `sync_state`\n        // loop\n        // processes it.\n        //\n        // In all cases, if the message has expired (i.e. `now > anchor_block_timestamp + MAX_MSG_TTL`), we remove it\n        // from the inbox.\n        //\n        // Note: the loop runs backwards because it might call `inbox.remove(j)` to purge expired messages and we also\n        // need to align it with `resolved_contexts.get(j)`. Going from last to first simplifies the algorithm as\n        // not yet visited element indexes remain stable.\n        j -= 1;\n        let maybe_ctx = resolved_contexts.get(j);\n        let msg = inbox.get(j);\n\n        // Compute the message's effective expiration timestamp to determine if we can purge it from the inbox.\n        let effective_expiration = msg.anchor_block_timestamp + MAX_MSG_TTL;\n\n        // Message expired. We remove it from the inbox.\n        if now > effective_expiration {\n            inbox.remove(j);\n        }\n\n        // Scenario 1: associated TX not yet available. We keep the message in the inbox, as it might become\n        // processable as new blocks get mined.\n        // Scenario 2: no TX associated to message. The message will sit in the inbox until it expires.\n        if maybe_ctx.is_none() {\n            continue;\n        }\n\n        // Scenario 3: Message is ready to process, add to result array. Note we still keep it in the inbox unless we\n        // consider it has expired: this is because we need to account for reorgs. If reorg occurs after we processed\n        // a message, the effects of processing the message get rewind. However, the associated TX can be included in\n        // a subsequent block. Should that happen, the message must be re-processed to ensure consistency.\n        let message_context = maybe_ctx.unwrap();\n        ready_to_process.push(OffchainMessageWithContext { message_ciphertext: msg.ciphertext, message_context });\n    }\n\n    ready_to_process\n}\n\nmod test {\n    use crate::{\n        capsules::CapsuleArray, oracle::random::random, protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{\n        MAX_MSG_TTL, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OFFCHAIN_INBOX_SLOT, OffchainMessage, PendingOffchainMsg,\n        receive, sync_inbox,\n    };\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let result = sync_inbox(context.this_address(), scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> =\n                CapsuleArray::at(context.this_address(), OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(inbox.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_not_expired_before_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance, but not past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_less_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::none(), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_tx_stays_in_inbox() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // not resolved, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let survivor_tx_hash = random();\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor_ts in the past so it expires at\n            // anchor_ts + MAX_MSG_TTL. We set anchor to 0 so it expires quickly.\n            msgs.push(make_msg(scope, Option::some(random()), 0));\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(make_msg(scope, Option::some(survivor_tx_hash), anchor_ts));\n            // Message 2: tx-less, anchor_ts=0 so it also expires.\n            msgs.push(make_msg(scope, Option::none(), 0));\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor_ts=0, but not for anchor_ts=anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            // Message 0 expired (anchor=0), message 1 survived (anchor=anchor_ts),\n            // Message 2 expired (anchor=0).\n            assert_eq(inbox.len(), 1);\n            assert_eq(inbox.get(0).tx_hash, survivor_tx_hash);\n        });\n    }\n\n    // -- Resolved context (ready to process) ------------------------------\n\n    #[test]\n    unconstrained fn resolved_msg_is_ready_to_process() {\n        let (env, scope) = setup();\n        // TestEnvironment::new() deploys protocol contracts, creating blocks with tx effects.\n        // In TXE, tx hashes equal Fr(blockNumber), so Fr(1) is the tx effect from block 1.\n        // We use this as a \"known resolvable\" tx hash.\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(known_tx_hash), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            // The message should be ready to process since its tx context was resolved.\n            assert_eq(result.len(), 1);\n\n            let ctx = result.get(0).message_context;\n            assert_eq(ctx.tx_hash, known_tx_hash);\n            assert(ctx.first_nullifier_in_tx != 0, \"resolved context must have a first nullifier\");\n\n            // Message stays in inbox (not expired) for potential reorg reprocessing.\n            assert_eq(inbox.len(), 1);\n        });\n    }\n}\n"
     },
     "16": {
       "function_locations": [
@@ -986,7 +986,7 @@
       "path": "std/hash/mod.nr",
       "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n        },\n    );\n}\n"
     },
-    "172": {
+    "174": {
       "function_locations": [
         {
           "name": "aes128_decrypt_oracle",
@@ -1005,10 +1005,10 @@
           "start": 3150
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/aes128_decrypt.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "174": {
+    "176": {
       "function_locations": [
         {
           "name": "address",
@@ -1241,12 +1241,16 @@
         {
           "name": "storage_write_opcode",
           "start": 7247
+        },
+        {
+          "name": "test::avm_storage_read",
+          "start": 7410
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/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"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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\nmod test {\n    use crate::macros::oracle_testing::oracle_test;\n    use super::storage_read_opcode;\n\n    #[oracle_test]\n    unconstrained fn avm_storage_read() {\n        let result = storage_read_opcode(10, 1);\n        assert_eq(result, 42);\n    }\n}\n"
     },
-    "178": {
+    "180": {
       "function_locations": [
         {
           "name": "store",
@@ -1337,10 +1341,10 @@
           "start": 11311
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\n// TODO(F-498): review naming consistency\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T, scope: AztecAddress)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    set_capsule_oracle(contract_address, slot, serialized, scope);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns\n/// Option::none() if nothing was stored at the given slot.\n// TODO(F-498): review naming consistency\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field, scope: AztecAddress) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = get_capsule_oracle(contract_address, slot, <T as Deserialize>::N, scope);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field, scope: AztecAddress) {\n    delete_oracle(contract_address, slot, scope);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`. Supports overlapping source and\n/// destination regions (which will result in the overlapped source values being overwritten). All copied slots must\n/// exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n    scope: AztecAddress,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries, scope);\n}\n\n#[oracle(aztec_utl_setCapsule)]\nunconstrained fn set_capsule_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n    scope: AztecAddress,\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the\n/// expected shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(aztec_utl_getCapsule)]\nunconstrained fn get_capsule_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n    scope: AztecAddress,\n) -> Option<[Field; N]> {}\n\n#[oracle(aztec_utl_deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field, scope: AztecAddress) {}\n\n#[oracle(aztec_utl_copyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n    scope: AztecAddress,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::MockStruct},\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n\n            assert_eq(load(contract_address, SLOT, scope).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value, scope);\n\n            assert_eq(load(contract_address, SLOT, scope).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n            delete(contract_address, SLOT, scope);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT, scope);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src, scope).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1, scope).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2, scope).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src, scope).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1, scope).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2, scope).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0, scope);\n        });\n    }\n}\n"
     },
-    "179": {
+    "181": {
       "function_locations": [
         {
           "name": "set_contract_sync_cache_invalid_oracle",
@@ -1351,10 +1355,10 @@
           "start": 700
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/contract_sync.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "181": {
+    "183": {
       "function_locations": [
         {
           "name": "get_utility_context_oracle",
@@ -1365,56 +1369,56 @@
           "start": 344
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use crate::context::UtilityContext;\n\n#[oracle(aztec_utl_getUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContext {}\n\n/// Returns a utility context built from the global variables of anchor block and the contract address of the function\n/// being executed.\npub unconstrained fn get_utility_context() -> UtilityContext {\n    get_utility_context_oracle()\n}\n"
     },
-    "191": {
+    "193": {
       "function_locations": [
         {
           "name": "get_pending_tagged_logs",
-          "start": 689
+          "start": 1064
         },
         {
           "name": "get_pending_tagged_logs_oracle",
-          "start": 883
+          "start": 1337
         },
         {
           "name": "validate_and_store_enqueued_notes_and_events",
-          "start": 1190
+          "start": 1644
         },
         {
           "name": "validate_and_store_enqueued_notes_and_events_oracle",
-          "start": 1609
+          "start": 2063
         },
         {
           "name": "get_logs_by_tag",
-          "start": 2056
+          "start": 2503
         },
         {
           "name": "get_logs_by_tag_oracle",
-          "start": 2282
+          "start": 2729
         },
         {
           "name": "get_message_contexts_by_tx_hash",
-          "start": 2542
+          "start": 2989
         },
         {
           "name": "get_message_contexts_by_tx_hash_oracle",
-          "start": 2786
+          "start": 3233
         },
         {
           "name": "get_tx_effect",
-          "start": 2923
+          "start": 3370
         },
         {
           "name": "get_tx_effect_oracle",
-          "start": 3069
+          "start": 3516
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
-      "source": "use crate::ephemeral::EphemeralArray;\nuse crate::messages::processing::{\n    event_validation_request::EventValidationRequest, log_retrieval_request::LogRetrievalRequest,\n    log_retrieval_response::LogRetrievalResponse, MessageContext, NoteValidationRequest,\n    pending_tagged_log::PendingTaggedLog,\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.\npub(crate) unconstrained fn get_pending_tagged_logs(scope: AztecAddress) -> EphemeralArray<PendingTaggedLog> {\n    get_pending_tagged_logs_oracle(scope)\n}\n\n#[oracle(aztec_utl_getPendingTaggedLogs)]\nunconstrained fn get_pending_tagged_logs_oracle(scope: AztecAddress) -> 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(crate) unconstrained fn get_logs_by_tag(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    get_logs_by_tag_oracle(requests)\n}\n\n#[oracle(aztec_utl_getLogsByTag)]\nunconstrained fn get_logs_by_tag_oracle(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {}\n\n/// Resolves message contexts for tx hashes in an ephemeral request array and returns a response ephemeral array.\npub(crate) unconstrained fn get_message_contexts_by_tx_hash(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {\n    get_message_contexts_by_tx_hash_oracle(requests)\n}\n\n#[oracle(aztec_utl_getMessageContextsByTxHash)]\nunconstrained fn get_message_contexts_by_tx_hash_oracle(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {}\n\n/// Fetches all effects of a settled transaction by its hash.\npub unconstrained fn get_tx_effect(tx_hash: Field) -> Option<TxEffect> {\n    get_tx_effect_oracle(tx_hash)\n}\n\n#[oracle(aztec_utl_getTxEffect)]\nunconstrained fn get_tx_effect_oracle(tx_hash: Field) -> Option<TxEffect> {}\n"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
+      "source": "use crate::ephemeral::EphemeralArray;\nuse crate::messages::processing::{\n    event_validation_request::EventValidationRequest, log_retrieval_request::LogRetrievalRequest,\n    log_retrieval_response::LogRetrievalResponse, MessageContext, NoteValidationRequest,\n    pending_tagged_log::PendingTaggedLog, provided_secret::ProvidedSecret,\n};\nuse crate::protocol::address::AztecAddress;\nuse crate::protocol::blob_data::TxEffect;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and\n/// returns them in an ephemeral array with an oracle-allocated base slot.\n///\n/// # Arguments\n///\n/// * `scope` - The account scope to search under.\n/// * `provided_secrets` - Tagging secrets the app supplies explicitly, searched alongside the secrets PXE manages\n///   internally. Used for secrets PXE cannot derive itself (e.g. handshake-derived ones).\npub(crate) unconstrained fn get_pending_tagged_logs(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {\n    get_pending_tagged_logs_oracle(scope, provided_secrets)\n}\n\n#[oracle(aztec_utl_getPendingTaggedLogs)]\nunconstrained fn get_pending_tagged_logs_oracle(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {}\n\n/// Validates note/event requests stored in ephemeral arrays.\npub(crate) unconstrained fn validate_and_store_enqueued_notes_and_events(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {\n    validate_and_store_enqueued_notes_and_events_oracle(note_validation_requests, event_validation_requests, scope);\n}\n\n#[oracle(aztec_utl_validateAndStoreEnqueuedNotesAndEvents)]\nunconstrained fn validate_and_store_enqueued_notes_and_events_oracle(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {}\n\n/// Fetches all logs matching each request's tag and returns a nested ephemeral array.\n///\n/// Each element in the outer array is an inner `EphemeralArray<LogRetrievalResponse>` containing all matching logs for\n/// the request at the same index (which may be empty if no logs were found).\npub unconstrained fn get_logs_by_tag(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    get_logs_by_tag_oracle(requests)\n}\n\n#[oracle(aztec_utl_getLogsByTag)]\nunconstrained fn get_logs_by_tag_oracle(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {}\n\n/// Resolves message contexts for tx hashes in an ephemeral request array and returns a response ephemeral array.\npub(crate) unconstrained fn get_message_contexts_by_tx_hash(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {\n    get_message_contexts_by_tx_hash_oracle(requests)\n}\n\n#[oracle(aztec_utl_getMessageContextsByTxHash)]\nunconstrained fn get_message_contexts_by_tx_hash_oracle(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {}\n\n/// Fetches all effects of a settled transaction by its hash.\npub unconstrained fn get_tx_effect(tx_hash: Field) -> Option<TxEffect> {\n    get_tx_effect_oracle(tx_hash)\n}\n\n#[oracle(aztec_utl_getTxEffect)]\nunconstrained fn get_tx_effect_oracle(tx_hash: Field) -> Option<TxEffect> {}\n"
     },
-    "198": {
+    "200": {
       "function_locations": [
         {
           "name": "get_shared_secrets_oracle",
@@ -1430,25 +1434,25 @@
         },
         {
           "name": "test::preserves_ephemeral_key_ordering",
-          "start": 2945
+          "start": 2943
         },
         {
           "name": "test::returns_secrets_in_order",
-          "start": 3816
+          "start": 3814
         },
         {
           "name": "test::cannot_return_mismatched_length",
-          "start": 4524
+          "start": 4522
         },
         {
           "name": "test::mock_get_shared_secrets",
-          "start": 5040
+          "start": 5038
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
-      "source": "use crate::ephemeral::EphemeralArray;\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, point::EmbeddedCurvePoint};\n\nglobal GET_SHARED_SECRETS_REQUEST_SLOT: Field = sha256_to_field(\"AZTEC_NR::GET_SHARED_SECRETS_REQUEST_SLOT\".as_bytes());\n\n#[oracle(aztec_utl_getSharedSecrets)]\nunconstrained fn get_shared_secrets_oracle(\n    address: AztecAddress,\n    eph_pks: EphemeralArray<EmbeddedCurvePoint>,\n    contract_address: AztecAddress,\n) -> EphemeralArray<Field> {}\n\n/// Convenience wrapper around [`get_shared_secrets`] for a single ephemeral public key.\npub unconstrained fn get_shared_secret(\n    address: AztecAddress,\n    eph_pk: EmbeddedCurvePoint,\n    contract_address: AztecAddress,\n) -> Field {\n    get_shared_secrets::<1>(address, BoundedVec::from_array([eph_pk]), contract_address).get(0)\n}\n\n/// Returns app-siloed shared secrets between `address` and someone who knows the secret keys behind the given\n/// ephemeral public keys.\n///\n/// Each returned Field `s_app` is computed as:\n///\n/// ```text\n/// S     = address_secret * ephPk          (raw ECDH point)\n/// s_app = h(DOM_SEP, S.x, S.y, contract)  (app-siloed scalar)\n/// ```\n///\n/// where `contract` is the address of the calling contract. The oracle host validates this matches its execution\n/// context.\n///\n/// Without app-siloing, a malicious contract could call this oracle with public information (address, ephPk) and\n/// obtain the same raw secret as the legitimate contract, enabling cross-contract decryption. By including the\n/// contract address in the hash, each contract receives a different `s_app`, preventing this attack.\n///\n/// Callers derive indexed subkeys from `s_app` via\n/// [`derive_shared_secret_subkey`](crate::keys::ecdh_shared_secret::derive_shared_secret_subkey).\npub unconstrained fn get_shared_secrets<let N: u32>(\n    address: AztecAddress,\n    eph_pks: BoundedVec<EmbeddedCurvePoint, N>,\n    contract_address: AztecAddress,\n) -> BoundedVec<Field, N> {\n    let request_array: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::at(GET_SHARED_SECRETS_REQUEST_SLOT).clear();\n    eph_pks.for_each(|pk| request_array.push(pk));\n\n    let response_array = get_shared_secrets_oracle(address, request_array, contract_address);\n    assert(response_array.len() == eph_pks.len(), \"get_shared_secrets: response length does not match request length\");\n\n    let mut results: BoundedVec<Field, N> = BoundedVec::new();\n    for i in 0..eph_pks.len() {\n        results.push(response_array.get(i));\n    }\n    results\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::oracle::shared_secret::{get_shared_secrets, GET_SHARED_SECRETS_REQUEST_SLOT};\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 _: BoundedVec<Field, 3> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                BoundedVec::from_array([pk_a, pk_b, pk_c]),\n                AztecAddress::from_field(2),\n            );\n\n            let request_array: EphemeralArray<_> = EphemeralArray::at(GET_SHARED_SECRETS_REQUEST_SLOT);\n            assert_eq(request_array.get(0), pk_a);\n            assert_eq(request_array.get(1), pk_b);\n            assert_eq(request_array.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 results: BoundedVec<Field, 3> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                BoundedVec::from_array([pk, pk, pk]),\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(results.get(0), 111);\n            assert_eq(results.get(1), 222);\n            assert_eq(results.get(2), 333);\n        });\n    }\n\n    #[test(should_fail_with = \"response length does not match request length\")]\n    unconstrained fn cannot_return_mismatched_length() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111, 222]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let _: BoundedVec<Field, 1> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                BoundedVec::from_array([pk]),\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"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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_SECRETS_REQUEST_SLOT: Field = sha256_to_field(\"AZTEC_NR::GET_SHARED_SECRETS_REQUEST_SLOT\".as_bytes());\n\n#[oracle(aztec_utl_getSharedSecrets)]\nunconstrained fn get_shared_secrets_oracle(\n    address: AztecAddress,\n    eph_pks: EphemeralArray<EmbeddedCurvePoint>,\n    contract_address: AztecAddress,\n) -> EphemeralArray<Field> {}\n\n/// Convenience wrapper around [`get_shared_secrets`] for a single ephemeral public key.\npub unconstrained fn get_shared_secret(\n    address: AztecAddress,\n    eph_pk: EmbeddedCurvePoint,\n    contract_address: AztecAddress,\n) -> Field {\n    get_shared_secrets::<1>(address, BoundedVec::from_array([eph_pk]), contract_address).get(0)\n}\n\n/// Returns app-siloed shared secrets between `address` and someone who knows the secret keys behind the given\n/// ephemeral public keys.\n///\n/// Each returned Field `s_app` is computed as:\n///\n/// ```text\n/// S     = address_secret * ephPk          (raw ECDH point)\n/// s_app = h(DOM_SEP, S.x, S.y, contract)  (app-siloed scalar)\n/// ```\n///\n/// where `contract` is the address of the calling contract. The oracle host validates this matches its execution\n/// context.\n///\n/// Without app-siloing, a malicious contract could call this oracle with public information (address, ephPk) and\n/// obtain the same raw secret as the legitimate contract, enabling cross-contract decryption. By including the\n/// contract address in the hash, each contract receives a different `s_app`, preventing this attack.\n///\n/// Callers derive indexed subkeys from `s_app` via\n/// [`derive_shared_secret_subkey`](crate::keys::ecdh_shared_secret::derive_shared_secret_subkey).\npub unconstrained fn get_shared_secrets<let N: u32>(\n    address: AztecAddress,\n    eph_pks: BoundedVec<EmbeddedCurvePoint, N>,\n    contract_address: AztecAddress,\n) -> BoundedVec<Field, N> {\n    let request_array: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(GET_SHARED_SECRETS_REQUEST_SLOT);\n    eph_pks.for_each(|pk| request_array.push(pk));\n\n    let response_array = get_shared_secrets_oracle(address, request_array, contract_address);\n    assert(response_array.len() == eph_pks.len(), \"get_shared_secrets: response length does not match request length\");\n\n    let mut results: BoundedVec<Field, N> = BoundedVec::new();\n    for i in 0..eph_pks.len() {\n        results.push(response_array.get(i));\n    }\n    results\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::oracle::shared_secret::{get_shared_secrets, GET_SHARED_SECRETS_REQUEST_SLOT};\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 _: BoundedVec<Field, 3> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                BoundedVec::from_array([pk_a, pk_b, pk_c]),\n                AztecAddress::from_field(2),\n            );\n\n            let request_array: EphemeralArray<_> = EphemeralArray::at(GET_SHARED_SECRETS_REQUEST_SLOT);\n            assert_eq(request_array.get(0), pk_a);\n            assert_eq(request_array.get(1), pk_b);\n            assert_eq(request_array.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 results: BoundedVec<Field, 3> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                BoundedVec::from_array([pk, pk, pk]),\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(results.get(0), 111);\n            assert_eq(results.get(1), 222);\n            assert_eq(results.get(2), 333);\n        });\n    }\n\n    #[test(should_fail_with = \"response length does not match request length\")]\n    unconstrained fn cannot_return_mismatched_length() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111, 222]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let _: BoundedVec<Field, 1> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                BoundedVec::from_array([pk]),\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"
     },
-    "250": {
+    "252": {
       "function_locations": [
         {
           "name": "append",
@@ -1467,10 +1471,10 @@
           "start": 1387
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "253": {
+    "255": {
       "function_locations": [
         {
           "name": "subarray",
@@ -1497,10 +1501,10 @@
           "start": 1941
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "254": {
+    "256": {
       "function_locations": [
         {
           "name": "subbvec",
@@ -1539,10 +1543,10 @@
           "start": 3579
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(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"
     },
-    "256": {
+    "258": {
       "function_locations": [
         {
           "name": "compare",
@@ -1553,10 +1557,10 @@
           "start": 987
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "257": {
+    "259": {
       "function_locations": [
         {
           "name": "encode_bytes_as_fields",
@@ -1579,10 +1583,10 @@
           "start": 2454
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_as_fields.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "258": {
+    "260": {
       "function_locations": [
         {
           "name": "encode_fields_as_bytes",
@@ -1629,10 +1633,10 @@
           "start": 6544
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_as_bytes.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "261": {
+    "263": {
       "function_locations": [
         {
           "name": "get_sign_of_point",
@@ -1679,10 +1683,10 @@
           "start": 6628
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "271": {
+    "273": {
       "function_locations": [
         {
           "name": "Poseidon2::hash",
@@ -1724,7 +1728,7 @@
       "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"
     },
-    "360": {
+    "362": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -1843,10 +1847,10 @@
           "start": 16359
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "362": {
+    "364": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -1914,13 +1918,13 @@
         },
         {
           "name": "log_oracle",
-          "start": 2801
+          "start": 2802
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
-      "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_utl_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"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "381": {
+    "383": {
       "function_locations": [
         {
           "name": "Poseidon2Sponge::hash",
@@ -1947,7 +1951,7 @@
           "start": 2544
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "40": {
@@ -2048,7 +2052,7 @@
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n"
     },
-    "400": {
+    "402": {
       "function_locations": [
         {
           "name": "<impl ToField for Field>::to_field",
@@ -2083,10 +2087,20 @@
           "start": 912
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits/to_field.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "408": {
+    "41": {
+      "function_locations": [
+        {
+          "name": "panic",
+          "start": 196
+        }
+      ],
+      "path": "std/panic.nr",
+      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n"
+    },
+    "410": {
       "function_locations": [
         {
           "name": "field_from_bytes",
@@ -2197,20 +2211,10 @@
           "start": 11828
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n    if f1.lt(f2) {\n        f1\n    } else {\n        f2\n    }\n}\n\n// TODO: write doc-comments and tests for these magic constants.\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// @dev: only use this for _huge_ exponents y, when writing a constrained function.\n// If you're only exponentiating by a small value, first consider writing-out the multiplications by hand.\n// Only after you've measured the gates of that approach, consider using the native Field::pow_32 function.\n// Only if your exponent is larger than 32 bits, resort to using this function.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [bool; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n/// Returns Option::some(sqrt) if there is a square root, and Option::none() if there isn't.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\nunconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field2.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n\n#[test]\nunconstrained fn sqrt_valid_test() {\n    let x = 16; // examples: 16, 9, 25, 81\n    let result = sqrt(x);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), x);\n}\n\n#[test]\nunconstrained fn sqrt_invalid_test() {\n    let x = KNOWN_NON_RESIDUE; // has no square root in the field\n    let result = sqrt(x);\n    assert(result.is_none());\n}\n\n#[test]\nunconstrained fn sqrt_zero_test() {\n    let result = sqrt(0);\n    assert(result.is_some());\n    assert_eq(result.unwrap(), 0);\n}\n\n#[test]\nunconstrained fn sqrt_one_test() {\n    let result = sqrt(1);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), 1);\n}\n\n#[test]\nunconstrained fn field_from_bytes_empty_test() {\n    let empty: [u8; 0] = [];\n    let result = field_from_bytes(empty, true);\n    assert_eq(result, 0);\n\n    let result_le = field_from_bytes(empty, false);\n    assert_eq(result_le, 0);\n}\n\n#[test]\nunconstrained fn field_from_bytes_little_endian_test() {\n    // Test little-endian conversion: [0x01, 0x02] should be 0x0201 = 513\n    let bytes = [0x01, 0x02];\n    let result_le = field_from_bytes(bytes, false);\n    assert_eq(result_le, 0x0201);\n\n    // Compare with big-endian: [0x01, 0x02] should be 0x0102 = 258\n    let result_be = field_from_bytes(bytes, true);\n    assert_eq(result_be, 0x0102);\n}\n\n#[test]\nunconstrained fn pow_test() {\n    assert_eq(pow(2, 0), 1);\n    assert_eq(pow(2, 1), 2);\n    assert_eq(pow(2, 10), 1024);\n    assert_eq(pow(3, 5), 243);\n    assert_eq(pow(0, 5), 0);\n    assert_eq(pow(1, 100), 1);\n}\n\n#[test]\nunconstrained fn min_test() {\n    assert_eq(min(5, 10), 5);\n    assert_eq(min(10, 5), 5);\n    assert_eq(min(7, 7), 7);\n    assert_eq(min(0, 1), 0);\n}\n\n#[test]\nunconstrained fn sqrt_has_two_roots_test() {\n    // Every square has two roots: r and -r (i.e., p - r)\n    // sqrt(16) can return 4 or -4\n    let x = 16;\n    let result = sqrt(x).unwrap();\n    assert(result * result == x);\n    // The other root is -result\n    let other_root = 0 - result;\n    assert(other_root * other_root == x);\n    // Verify they are different (unless x = 0)\n    assert(result != other_root);\n\n    // Same for 9: roots are 3 and -3\n    let y = 9;\n    let result_y = sqrt(y).unwrap();\n    assert(result_y * result_y == y);\n    let other_root_y = 0 - result_y;\n    assert(other_root_y * other_root_y == y);\n    assert(result_y != other_root_y);\n}\n\n#[test]\nunconstrained fn sqrt_negative_one_test() {\n    let x = 0 - 1;\n    let result = sqrt(x);\n    assert(result.unwrap() == 0x30644e72e131a029048b6e193fd841045cea24f6fd736bec231204708f703636);\n}\n\n#[test]\nunconstrained fn validate_sqrt_hint_valid_test() {\n    // 4 is a valid sqrt of 16\n    validate_sqrt_hint(16, 4);\n    // -4 is also a valid sqrt of 16\n    validate_sqrt_hint(16, 0 - 4);\n    // 0 is a valid sqrt of 0\n    validate_sqrt_hint(0, 0);\n    // 1 is a valid sqrt of 1\n    validate_sqrt_hint(1, 1);\n    // -1 is also a valid sqrt of 1\n    validate_sqrt_hint(1, 0 - 1);\n}\n\n#[test(should_fail_with = \"is not the sqrt of x\")]\nunconstrained fn validate_sqrt_hint_invalid_test() {\n    // 5 is not a valid sqrt of 16\n    validate_sqrt_hint(16, 5);\n}\n\n#[test]\nunconstrained fn validate_not_sqrt_hint_valid_test() {\n    // 5 (KNOWN_NON_RESIDUE) is not a square.\n    let x = KNOWN_NON_RESIDUE;\n    let hint = tonelli_shanks_sqrt(x * KNOWN_NON_RESIDUE);\n    validate_not_sqrt_hint(x, hint);\n}\n\n#[test(should_fail_with = \"0 has a square root\")]\nunconstrained fn validate_not_sqrt_hint_zero_test() {\n    // 0 has a square root, so we cannot claim it is not square\n    validate_not_sqrt_hint(0, 0);\n}\n\n#[test(should_fail_with = \"does not demonstrate that\")]\nunconstrained fn validate_not_sqrt_hint_wrong_hint_test() {\n    // Provide a wrong hint for a non-square\n    let x = KNOWN_NON_RESIDUE;\n    validate_not_sqrt_hint(x, 123);\n}\n"
     },
-    "41": {
-      "function_locations": [
-        {
-          "name": "panic",
-          "start": 196
-        }
-      ],
-      "path": "std/panic.nr",
-      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n"
-    },
-    "414": {
+    "416": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -2257,10 +2261,10 @@
           "start": 1426
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "415": {
+    "417": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -2283,10 +2287,10 @@
           "start": 12469
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "417": {
+    "419": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -2597,10 +2601,10 @@
           "start": 21226
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
-    "418": {
+    "420": {
       "function_locations": [
         {
           "name": "Writer<N>::new",
@@ -2643,7 +2647,7 @@
           "start": 1263
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/writer.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "49": {
@@ -2657,7 +2661,7 @@
           "start": 1364
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/standard/public_checks_contract/src/main.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "59": {
@@ -2739,7 +2743,7 @@
           "start": 13383
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
       "source": "use crate::oracle::capsules;\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n    /// Scope for capsule isolation. Capsule operations are scoped to the given address, allowing multiple independent\n    /// namespaces within the same contract.\n    scope: AztecAddress,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray scoped to a specific address.\n    ///\n    /// Array elements are stored in contiguous slots\n    /// following the base slot, so there should be sufficient space between array base slots to accommodate elements.\n    /// A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field, scope: AztecAddress) -> Self {\n        Self { contract_address, base_slot, scope }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot, self.scope).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(\n            self.contract_address,\n            self.slot_at(current_length),\n            value,\n            self.scope,\n        );\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            new_length,\n            self.scope,\n        );\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index), self.scope).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n                self.scope,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(\n            self.contract_address,\n            self.slot_at(current_length - 1),\n            self.scope,\n        );\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            current_length - 1,\n            self.scope,\n        );\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index. The order in which values\n    /// are processed is arbitrary.\n    ///\n    /// ## Array Mutation\n    ///\n    /// It is safe to delete the current element (and only the current element) from inside the callback via `remove`:\n    /// ```noir\n    /// array.for_each(|index, value| {\n    ///   if some_condition(value) {\n    ///     array.remove(index); // safe only for this index\n    ///   }\n    /// }\n    /// ```\n    ///\n    /// If all elements in the array need to iterated over and then removed, then using `for_each` results in optimal\n    /// efficiency.\n    ///\n    /// It is **not** safe to push new elements into the array from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        // Iterating over all elements is simple, but we want to do it in such a way that a) deleting the current\n        // element is safe to do, and b) deleting *all* elements is optimally efficient. This is because CapsuleArrays\n        // are typically used to hold pending tasks, so iterating them while clearing completed tasks (sometimes\n        // unconditionally, resulting in a full clear) is a very common access pattern.\n        //\n        // The way we achieve this is by iterating backwards: each element can always be deleted since it won't change\n        // any preceding (lower) indices, and if every element is deleted then every element will (in turn) be the last\n        // element. This results in an optimal full clear since `remove` will be able to skip the `capsules::copy` call\n        // to shift any elements past the deleted one (because there will be none).\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n\n    global SLOT: Field = 1230;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT, scope);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(5);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 8);\n            assert_eq(array.get(2), 9);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We store all values that we were called with and check that all (value, index) tuples are present. Note\n            // that we do not care about the order in which each tuple was passed to the closure.\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n            assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n            assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| {\n                if index == 1 {\n                    array.remove(index);\n                }\n            });\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 4);\n            assert_eq(array.get(1), 6);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all_no_copy() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We test that the aztec_utl_copyCapsule was never called, which is the expensive operation we want to\n            // avoid.\n            let mock = std::test::OracleMock::mock(\"aztec_utl_copyCapsule\");\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(mock.times_called(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn different_scopes_are_isolated() {\n        let mut env = TestEnvironment::new();\n        let scope_a = env.create_light_account();\n        let scope_b = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array_a = CapsuleArray::at(contract_address, SLOT, scope_a);\n            let array_b = CapsuleArray::at(contract_address, SLOT, scope_b);\n\n            array_a.push(10);\n            array_a.push(20);\n            array_b.push(99);\n\n            assert_eq(array_a.len(), 2);\n            assert_eq(array_a.get(0), 10);\n            assert_eq(array_a.get(1), 20);\n\n            assert_eq(array_b.len(), 1);\n            assert_eq(array_b.get(0), 99);\n        });\n    }\n}\n"
     },
     "6": {
@@ -3251,7 +3255,7 @@
           "start": 34193
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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    pub args_hash: Option<Field>,\n    pub 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"
     },
     "70": {
@@ -3297,7 +3301,7 @@
           "start": 1596
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
       "source": "use crate::oracle::{execution::get_utility_context, storage::storage_read};\nuse crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress, traits::Packable};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n    block_header: BlockHeader,\n    contract_address: AztecAddress,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        get_utility_context()\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        // We get a context with default contract address, and then we construct the final context with the provided\n        // contract address.\n        let default_context = get_utility_context();\n\n        Self { block_header: default_context.block_header, contract_address }\n    }\n\n    pub fn block_header(self) -> BlockHeader {\n        self.block_header\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_header.block_number()\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.block_header.timestamp()\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.block_header.version()\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.block_header.chain_id()\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        storage_read(self.block_header, self.this_address(), storage_slot)\n    }\n\n    pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
     "72": {
@@ -3323,7 +3327,7 @@
           "start": 6480
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/contract_self/contract_self_public.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "75": {
@@ -3332,125 +3336,133 @@
           "name": "EphemeralArray<T>::at",
           "start": 1367
         },
+        {
+          "name": "EphemeralArray<T>::empty_at",
+          "start": 1545
+        },
         {
           "name": "EphemeralArray<T>::len",
-          "start": 1500
+          "start": 1687
         },
         {
           "name": "EphemeralArray<T>::push",
-          "start": 1680
+          "start": 1867
         },
         {
           "name": "EphemeralArray<T>::pop",
-          "start": 1950
+          "start": 2137
         },
         {
           "name": "EphemeralArray<T>::get",
-          "start": 2238
+          "start": 2425
         },
         {
           "name": "EphemeralArray<T>::set",
-          "start": 2537
+          "start": 2724
         },
         {
           "name": "EphemeralArray<T>::remove",
-          "start": 2805
+          "start": 2992
         },
         {
           "name": "EphemeralArray<T>::clear",
-          "start": 3084
+          "start": 3273
         },
         {
           "name": "EphemeralArray<T>::for_each",
-          "start": 3655
+          "start": 3844
         },
         {
           "name": "<impl Serialize for EphemeralArray<T>>::serialize",
-          "start": 4046
+          "start": 4235
         },
         {
           "name": "<impl Serialize for EphemeralArray<T>>::stream_serialize",
-          "start": 4141
+          "start": 4330
         },
         {
           "name": "<impl Deserialize for EphemeralArray<T>>::deserialize",
-          "start": 4459
+          "start": 4648
         },
         {
           "name": "<impl Deserialize for EphemeralArray<T>>::stream_deserialize",
-          "start": 4571
+          "start": 4760
         },
         {
           "name": "test::empty_array",
-          "start": 4883
+          "start": 5072
         },
         {
           "name": "test::empty_array_read",
-          "start": 5180
+          "start": 5369
         },
         {
           "name": "test::empty_array_pop",
-          "start": 5450
+          "start": 5639
         },
         {
           "name": "test::array_push",
-          "start": 5683
+          "start": 5872
         },
         {
           "name": "test::read_past_len",
-          "start": 6022
+          "start": 6211
         },
         {
           "name": "test::array_pop",
-          "start": 6276
+          "start": 6465
         },
         {
           "name": "test::array_set",
-          "start": 6683
+          "start": 6872
         },
         {
           "name": "test::array_remove_last",
-          "start": 6981
+          "start": 7170
         },
         {
           "name": "test::array_remove_some",
-          "start": 7276
+          "start": 7465
         },
         {
           "name": "test::array_remove_all",
-          "start": 7747
+          "start": 7936
         },
         {
           "name": "test::for_each_called_with_all_elements",
-          "start": 8173
+          "start": 8362
         },
         {
           "name": "test::for_each_remove_some",
-          "start": 8909
+          "start": 9098
         },
         {
           "name": "test::for_each_remove_all",
-          "start": 9461
+          "start": 9650
         },
         {
           "name": "test::different_slots_are_isolated",
-          "start": 9860
+          "start": 10049
         },
         {
           "name": "test::works_with_multi_field_type",
-          "start": 10434
+          "start": 10623
+        },
+        {
+          "name": "test::empty_at_wipes_previous_data",
+          "start": 11247
         },
         {
           "name": "test::clear_returns_self",
-          "start": 11048
+          "start": 11656
         },
         {
           "name": "test::clear_wipes_previous_data",
-          "start": 11435
+          "start": 12043
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/ephemeral/mod.nr",
-      "source": "use crate::oracle::ephemeral;\nuse crate::protocol::traits::{Deserialize, Serialize};\nuse crate::protocol::utils::{reader::Reader, writer::Writer};\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.\npub struct EphemeralArray<T> {\n    pub slot: Field,\n}\n\nimpl<T> EphemeralArray<T> {\n    /// Returns a handle to an ephemeral array at the given slot, which may already contain data (e.g. populated\n    /// by an oracle).\n    pub unconstrained fn at(slot: Field) -> Self {\n        Self { slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        ephemeral::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 _ = ephemeral::push_oracle(self.slot, serialized);\n    }\n\n    /// Removes and returns the last element. Panics if the array is empty.\n    pub unconstrained fn pop(self) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = ephemeral::pop_oracle(self.slot);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Retrieves the value stored at `index`. Panics 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 = ephemeral::get_oracle(self.slot, index);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Overwrites the value stored at `index`. Panics 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        ephemeral::set_oracle(self.slot, index, serialized);\n    }\n\n    /// Removes the element at `index`, shifting subsequent elements backward. Panics if out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        ephemeral::remove_oracle(self.slot, index);\n    }\n\n    /// Removes all elements from the array and returns self for chaining (e.g. `EphemeralArray::at(slot).clear()`\n    /// to get a guaranteed-empty array at a given slot).\n    pub unconstrained fn clear(self) -> Self {\n        ephemeral::clear_oracle(self.slot);\n        self\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index. Iteration proceeds\n    /// backwards so that it is safe to remove the current element (and only the current element) inside the\n    /// callback.\n    ///\n    /// It is **not** safe to push new elements from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n}\n\n/// Serializes an `EphemeralArray` as its slot identifier, allowing oracle function signatures to use\n/// `EphemeralArray<T>` instead of opaque `Field` slots.\nimpl<T> Serialize for EphemeralArray<T> {\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.\n/// This is the inverse of [`Serialize`].\nimpl<T> Deserialize for EphemeralArray<T> {\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\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use crate::test::mocks::MockStruct;\n    use super::EphemeralArray;\n\n    global SLOT: Field = 1230;\n    global OTHER_SLOT: Field = 5670;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn empty_array_read() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test(should_fail_with = \"is empty\")]\n    unconstrained fn empty_array_pop() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            let _: Field = array.pop();\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn read_past_len() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_pop() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n            array.push(10);\n\n            let popped: Field = array.pop();\n            assert_eq(popped, 10);\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_set() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n            array.set(0, 99);\n            assert_eq(array.get(0), 99);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n            array.remove(0);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n            assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n            assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| {\n                if index == 1 {\n                    array.remove(index);\n                }\n            });\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 4);\n            assert_eq(array.get(1), 6);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn different_slots_are_isolated() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array_a = EphemeralArray::at(SLOT);\n            let array_b = EphemeralArray::at(OTHER_SLOT);\n\n            array_a.push(10);\n            array_a.push(20);\n            array_b.push(99);\n\n            assert_eq(array_a.len(), 2);\n            assert_eq(array_a.get(0), 10);\n            assert_eq(array_a.get(1), 20);\n\n            assert_eq(array_b.len(), 1);\n            assert_eq(array_b.get(0), 99);\n        });\n    }\n\n    #[test]\n    unconstrained fn works_with_multi_field_type() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<MockStruct> = EphemeralArray::at(SLOT);\n\n            let a = MockStruct::new(5, 6);\n            let b = MockStruct::new(7, 8);\n            array.push(a);\n            array.push(b);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), a);\n            assert_eq(array.get(1), b);\n\n            let popped: MockStruct = array.pop();\n            assert_eq(popped, b);\n            assert_eq(array.len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn clear_returns_self() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT).clear();\n            assert_eq(array.len(), 0);\n\n            array.push(42);\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 42);\n        });\n    }\n\n    #[test]\n    unconstrained fn clear_wipes_previous_data() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT);\n            array.push(1);\n            array.push(2);\n            array.push(3);\n            assert_eq(array.len(), 3);\n\n            // Clear the same slot, previous data should be gone.\n            let fresh: EphemeralArray<Field> = EphemeralArray::at(SLOT).clear();\n            assert_eq(fresh.len(), 0);\n            fresh.push(4);\n            assert_eq(fresh.get(0), 4);\n        });\n    }\n}\n"
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/noir-projects/aztec-nr/aztec/src/ephemeral/mod.nr",
+      "source": "use crate::oracle::ephemeral;\nuse crate::protocol::traits::{Deserialize, Serialize};\nuse crate::protocol::utils::{reader::Reader, writer::Writer};\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.\npub struct EphemeralArray<T> {\n    pub slot: Field,\n}\n\nimpl<T> EphemeralArray<T> {\n    /// Returns a handle to an ephemeral array at the given slot, which may already contain data (e.g. populated\n    /// by an oracle).\n    pub unconstrained fn at(slot: Field) -> Self {\n        Self { slot }\n    }\n\n    /// Returns an empty ephemeral array at the given slot, clearing any pre-existing data.\n    pub unconstrained fn empty_at(slot: Field) -> Self {\n        Self::at(slot).clear()\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        ephemeral::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 _ = ephemeral::push_oracle(self.slot, serialized);\n    }\n\n    /// Removes and returns the last element. Panics if the array is empty.\n    pub unconstrained fn pop(self) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = ephemeral::pop_oracle(self.slot);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Retrieves the value stored at `index`. Panics 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 = ephemeral::get_oracle(self.slot, index);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Overwrites the value stored at `index`. Panics 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        ephemeral::set_oracle(self.slot, index, serialized);\n    }\n\n    /// Removes the element at `index`, shifting subsequent elements backward. Panics if out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        ephemeral::remove_oracle(self.slot, index);\n    }\n\n    /// Removes all elements from the array and returns self for chaining.\n    ///\n    /// Prefer [`EphemeralArray::empty_at`] when the intent is to start with a fresh array.\n    pub unconstrained fn clear(self) -> Self {\n        ephemeral::clear_oracle(self.slot);\n        self\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index. Iteration proceeds\n    /// backwards so that it is safe to remove the current element (and only the current element) inside the\n    /// callback.\n    ///\n    /// It is **not** safe to push new elements from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n}\n\n/// Serializes an `EphemeralArray` as its slot identifier, allowing oracle function signatures to use\n/// `EphemeralArray<T>` instead of opaque `Field` slots.\nimpl<T> Serialize for EphemeralArray<T> {\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.\n/// This is the inverse of [`Serialize`].\nimpl<T> Deserialize for EphemeralArray<T> {\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\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use crate::test::mocks::MockStruct;\n    use super::EphemeralArray;\n\n    global SLOT: Field = 1230;\n    global OTHER_SLOT: Field = 5670;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn empty_array_read() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test(should_fail_with = \"is empty\")]\n    unconstrained fn empty_array_pop() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            let _: Field = array.pop();\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn read_past_len() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_pop() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n            array.push(10);\n\n            let popped: Field = array.pop();\n            assert_eq(popped, 10);\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_set() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n            array.set(0, 99);\n            assert_eq(array.get(0), 99);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n            array.push(5);\n            array.remove(0);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n            assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n            assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| {\n                if index == 1 {\n                    array.remove(index);\n                }\n            });\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 4);\n            assert_eq(array.get(1), 6);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array = EphemeralArray::at(SLOT);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn different_slots_are_isolated() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array_a = EphemeralArray::at(SLOT);\n            let array_b = EphemeralArray::at(OTHER_SLOT);\n\n            array_a.push(10);\n            array_a.push(20);\n            array_b.push(99);\n\n            assert_eq(array_a.len(), 2);\n            assert_eq(array_a.get(0), 10);\n            assert_eq(array_a.get(1), 20);\n\n            assert_eq(array_b.len(), 1);\n            assert_eq(array_b.get(0), 99);\n        });\n    }\n\n    #[test]\n    unconstrained fn works_with_multi_field_type() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<MockStruct> = EphemeralArray::at(SLOT);\n\n            let a = MockStruct::new(5, 6);\n            let b = MockStruct::new(7, 8);\n            array.push(a);\n            array.push(b);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), a);\n            assert_eq(array.get(1), b);\n\n            let popped: MockStruct = array.pop();\n            assert_eq(popped, b);\n            assert_eq(array.len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn empty_at_wipes_previous_data() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT);\n            array.push(1);\n            assert_eq(array.len(), 1);\n\n            let fresh: EphemeralArray<Field> = EphemeralArray::empty_at(SLOT);\n            assert_eq(fresh.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn clear_returns_self() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT).clear();\n            assert_eq(array.len(), 0);\n\n            array.push(42);\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 42);\n        });\n    }\n\n    #[test]\n    unconstrained fn clear_wipes_previous_data() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let array: EphemeralArray<Field> = EphemeralArray::at(SLOT);\n            array.push(1);\n            array.push(2);\n            array.push(3);\n            assert_eq(array.len(), 3);\n\n            // Clear the same slot, previous data should be gone.\n            let fresh: EphemeralArray<Field> = EphemeralArray::at(SLOT).clear();\n            assert_eq(fresh.len(), 0);\n            fresh.push(4);\n            assert_eq(fresh.get(0), 4);\n        });\n    }\n}\n"
     },
     "77": {
       "function_locations": [
@@ -3471,7 +3483,7 @@
           "start": 2814
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/event/event_interface.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "79": {
@@ -3501,7 +3513,7 @@
           "start": 985
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/event/event_selector.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "92": {
@@ -3539,7 +3551,7 @@
           "start": 5055
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/keys/ecdh_shared_secret.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "97": {
@@ -3609,7 +3621,7 @@
           "start": 4151
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/logging.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     },
     "99": {
@@ -3627,7 +3639,7 @@
           "start": 7724
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec/compute_note_hash_and_nullifier.nr",
+      "path": "/home/nico-chamo/repos/aztec-packages-oracle-hash-calculation/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"
     }
   },
@@ -3676,7 +3688,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rZfRbuIwEEX/Jc88eMbjsc2vrKqK0rRCQoAorLSq+Pcdp74hVHJUZfeF3FzHxx57PCGf3Wv/cn1/3h3ejh/d+tdn93Le7fe79+f9cbu57I4Hcz87V36I7BJWdg3dOtuV7Z64CDPIm/AOIlUh3oQWUZxoIhQnFWEOOxNqDhewFqc8nNREeTjTl2BXmqwXc2my0VmkW3tXRK5CrcmTiSQQuYoMJ1fHO4GAQ3AIDsNhOB6OhyNwBE4J8EukKhSOwolwYqwiEUSNwmcHESDqEILJi6tAIQ9RgcIMUYHiCaICRRwEgIhCEIUgClEAFUNEACOGSAAmDIEtEGyB5AoMzkNUYCCGqMDABFGAllGh5NiXgCNwSo4NYpj8IGIVw+QHAWeYfBFDtgwiV5Hh5Oqo8xC1uxJBaBUMh+Fgqoqp6jAxMRHLfCznoy8PW87HYQv0dlt1OHrPl3Pfl5M3OYt2Qk+bc3+4dOvDdb9fdb83++vw0Mdpcxiul83ZWu1A9IdXuxrwbbfvi7qt7r1du2twQWvvQBRHAJE+IKiNEKdcEUIsTQS3EZQyYrAy4JoI30awE0UkptMdoumBITOMmEDIkzii/DQO5kgg2LlvxqFthBWZUBFeNIyIyA+E+B9WIv3rSszlleYxryK3V4JmGJ7umWU6+VYgNJOd1g8TsZdaXhZLymMsos1YZhAkBARZAR4Rkh8DmUtOVfXYFNXEzdUIbYgypqHBLVmLh0BCaAUyRwhuPOuBZAnBZxkJnJuLmWdSayTY+3UEcNAfE+ydCwKnJoFnMjOGjGIRdbIQ38smzxULorFY0CS5wyNipm5655BV3k2r9zfETGbauYoyOWOxFcrsesq4I9Et2pHgxorj/TJCRGaGrIsI0/O1jBDH0xF5ISEiM2POiwjJI4qk7Tn4uRehwxx4klNCPw/C4wUUFy6klUhsRWof8dkyc8/qENNDmXmyu812d374dLoV1nm3edn39fbtethOWi9/TmjBp9fpfNz2r9dzX0j37y/76/iLgqxI5al8hQ23tLIPqqdbGf0v",
+      "debug_symbols": "rZfRbuIwEEX/Jc88eMbjsc2vrKqK0rRCQoAorLSq+Pcdp74hVHJUZfeF3FzHxx57PCGf3Wv/cn1/3h3ejh/d+tdn93Le7fe79+f9cbu57I4Hcz87V36I7BJWdg3dOtuV7Z64CDPIm/AOIlUh3oQWUZxoIhQnFWEOOxNqDhewFqc8nNREeTjTl2BXmqwXc2my0VmkW3tXRK5CrcmTiSQQuYoMJ1fHO4GAQ3AIDsNhOB6OhyNwBE4J8EukKhSOwolwYqwiEUSNwmcHESDqEILJi6tAIQ9RgcIMUYHiCaICRRwEgIhCEIUgClEAFUNEACOGSAAmDIEtEGyB5AoMzkNUYCCGqMDABFGAllGh5NiXgCNwSo4NYpj8IGIVw+QHAWeYfBFDtgwiV5Hh5Oqo8xC1uxJBaBUMh+Fgqoqp6jAxMRHLfCznoy8PW87HYQv0dlt1OHrPl3Pfl5M3OYt2Qk+bc3+4dOvDdb9fdb83++vw0Mdpcxiul83ZWu1A9IdXuxrwbbfvi7qt7r1du2twQWvvQBRHAJE+IKiNEKdcEUIsTQS3EZQyYrAy4JoI30awE0UkptMdoumBITOMmEDIkzjij+NgjgSCnftmHNpGWJEJFeFFw4iI/ECI/2El0r+uxFxeaR7zKnJ7JWiG4emeWaaTbwVCM9lp/TARe6nlZbGkPMYi2oxlBkFCQJAV4BEh+TGQueRUVY9NUU3cXI3QhihjGhrckrV4CCSEViBzhODGsx5IlhB8lpHAubmYeSa1RoK9X0cAh/Rjgr1zQeDUJPBMZsaQUSyiThbie9nkuWJBNBYLmiR3eETM1E3vHLLKu2n1/oaYyUw7V1EmZyy2QpldTxl3JLpFOxLcWHG8X0aIyMyQdRFher6WEeJ4OiIvJERkZsx5ESF5RJG0PQc/9yJ0mANPckro50F4vIDiwoW0EomtSO0jPltm7lkdYnooM092t9nuzg+fTrfCOu82L/u+3r5dD9tJ6+XPCS349Dqdj9v+9XruC+n+/WV/HX9RkBWpPJWvsOGWVvZB9XQro/8F",
       "is_unconstrained": true,
       "name": "check_block_number"
     },
@@ -3724,7 +3736,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rZfRbuIwEEX/Jc88eOzxjM2vVFVFaVohIUAUVlpV/PuOU18IlRyx2X0hNzfx8Ywz45Cv7q1/PX+8bHbv+89u+fTVvR432+3m42W7X69Om/3O3K/OlR8iO8SFHWO3zHb0dk6+CDMomAgOIlXBwYQUURw1EYuTijDHOxNiji9gKU65OYmJcnOmb+FduWSjvC+XbHbP3C2DKyJXIXYpkInEELmKDCdXJziGgENwCI6H4+EEOAEOw2E4JcFvkaoQOAJH4ahWkQiiZhGyg4gQdQpG8OwqkClAVCB7D1GBHAiiApkdBIDIgpEFIwsWAAVTKICKKRKACVPgETAeAecKjC5AVGAkD1GB0RNEAVpFxVJj3wIOwyk1Nogh+EFoFUPwg4AzBF/EUC2DyFVkOLk64gJEHS5EEFKFh+PhIFRBqDIExia0xGM1r6HcbDWvwyOQy2XRofVeTse+L5036kXr0MPq2O9O3XJ33m4X3a/V9jzc9HlY7YbjaXW0q9YQ/e7NjgZ832z7oi6L22jXHhpdlDo6EukVQCR3CGoj2ImvCCbPTYRvIyhl5GDbgGsiQhvhHQsyMZ1uEEl3DJ5gaAIhj/JQfjQP75VAsL5v5iFthG0ysSICS7wi1N8R9D+sRPrXlZiqK8nXulLfXgmaYAS6VZbpFFqJ0ER12jgEYi+1PC+XlK+5sDRzmUAk1UpI+RYD5/s0JktTFXVhOlNzLWIbIhl56LjVH1+JWxrjLv2RxsT4HPAscpw1XjA/OafNdcwTNZUZe5W7FbaP8jDBXrYg+NQk+ImS1JixS6jQqL1+IPzULkF03SVoVNXxHjGxYQbnAhBuvG3/QEwUpTWU8qi5tJXK5Hry9Ymom/VEortuNSHMIyhePzHLLIJ4tJbEeQR1iEH9TIKiMnW0yfwNIQVkkaQdQ5h6AzrE4Ec1xfR4EgFvHp25kCIgSGq3+OQuc/0z4gLd7TLPdrZab453n0yXgjpuVq/bvp6+n3fr0dXT7wOu4JPrcNyv+7fzsS+k23eX/WV8osgLEn4uX1/lVKKd6vOlzP4H",
+      "debug_symbols": "rZfRbuIwEEX/Jc88eOzxjN1fqaqK0rRCQoAorLSq+Pcdp74hVHLUze4LubmJjz3OzIR8dq/9y+X9ebt/O3x0D4+f3ctpu9tt3593h836vD3szf3sXPkhskNc2TF2D9mO3s7JF2EGBRPBQaQqOJiQIoqjJmJxUhHmeGdCzPEFLMUpNycxUW7O9CW8K5dslPflks3umbuH4IrIVYhdCmQiMUSuIsPJ1QmOIeAQHILj4Xg4AU6Aw3AYTgnwS6QqBI7AUTiqVSSCqFGE7CAiRJ2CsXh2FcgUICqQvYeoQA4EUYHMDgJARMGIghEFC4CCKRRAxRQJwIQp8AgYj4BzBUYXICowkoeowOgJogAto2LJsS8Bh+GUHBvEsPhBaBXD4gcBZ1h8EUO2DCJXkeHk6ogLEHW4EEFIFR6Oh4OlCpYqw8LYhJb1WM5rKDdbzuvwCOR6XXUovefzqe9L5U1q0Sr0uD71+3P3sL/sdqvu13p3GW76OK73w/G8PtlVK4h+/2pHA75td31R19VttGsPjS5KHR2JdAQQyR2C2gh24iuCyXMT4dsIShkxWBtwTURoI7xjQSSm0w0i6Y7BMwxNIORJHPrjOLxXAsHqvhmHtBHWZGJFBJY4ItTfEfQ/7ET6152YyyvJY16pb+8EzTAC3TLLdAqtQGgmO20cFmIvtbwslpTHWFiascwgkmolpHxbA+f7MGZTUxV5YTpTcy9iGyIZcei01HVBGNMq/RbGzPgc8CxyXDReMD85p819zDM5lRm9yt0S28f0Y4K9bEHwqUnwMympMaNLqNCkvL71GT/XJYjGLkGTrI73iJmGGZwLQLhp2/6GmElKKyjlSXFpK5TZ/eTxiahb9ESiG1tNCMsIitdPzLKIIB6lJXEZQR3WoH4hQZGZOmkyf0NIAVEkaa8hzL0BHdbgJznF9PMgAt48unAjRUCQ1C7x2S4z/hlxge66zJOdrTfb090n07WgTtv1y66vp2+X/WZy9fz7iCv45DqeDpv+9XLqC+n23WV/GR8p8oqEn8rXVzmVaKf6dC2z/wE=",
       "is_unconstrained": true,
       "name": "check_timestamp"
     },
@@ -3862,7 +3874,7 @@
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "tZnRTiM7DIbfpde9iJM4TngVtEIFyqpSVVAXjnSEePe1mfzplFWi7pS9IR/Q+ep47CTTvq8et/dvP+92h6fnX6ub2/fV/XG33+9+3u2fHzavu+eD/vV95exH8nl1E9Y6ltVN0jG4OlIdfR1DHWMduY6pjlLHXMfqi9UXqy9WH+vrRMekfy82+jqqn8iAAfoOZCEmAWRAqSAOQAAPCIAIYADMArPALDBnmDPMGeYMc4Y5w5xhzjBnmDPMBeYCc4G5wFxgLtUszq5iAwJ4gL0mGSSAAPTdvTMoFcgBCOABAaDv7u1yYkACCMDMYlAqeAcwczFQc7DgfQBEAAMSQAAZUCpYbU5AAJgDzAFmK9BgabEKnUAAZrYIrUg/wap0ArvcYo764kgG+uJowlgqsANoGDEaeEAARAADEkAAZrZ4uFRIDkAAM1tgKQAiwMzZIAEEkAGlgjXIBAQws83UGmSCCGCAmtmSYA0yQQaomb2CNcgEBPCAAIgABpjZcmgNMkEGlArWIGyJsgZhKzZrkAkCwMyWDWuQCRJAABlQJsjWRBOYORt4QABEgK10ziABBGCLHRmUCtZWyRsQwAMCwJbQZGBmewtrqwkEkAGlgrXVBAQwczEIADWLhWFtJfZe1lYTqFmCQQaUCtZWExDAAwLAzNGAAQkgADOzQalgbTUBAewqm7v11wQZYFfZLKy/JiCAxpMt4dZfE0QAAxJAABmg5mxpsf6agAAeYDOVj4/1Cpvk3etxu7U9crZr6l76sjluD6+rm8Pbfr9e/bfZv32+6NfL5vA5vm6O+l992+3hUUcVPu32W6OP9elq17+UfHRcL1eOvinInUuoL4m2OH8qYpQmkPPrff/6wJhBkHwKINNfzMIqsc6COXVnEfsSTg7T4OTDScHxTMF9hU/eV4VPs1ymy2MoATHo9tmNYaDQwxOyqecj6SpyXyEtEbqUnwRSLp6GtBhY5jX1JQYa3NPgCbkMPrtOLseG0uoquNwzDAozkochUigL7qeu2kiELo/9RAwcpSmKP4UQL6/rYoeNqSCck0U15eik8H2FvarboyWhqqhIbA4+ryoa1CVJKwnSU0JXUQbJJARR8myp0WXnYkOJiMERdxV+sF56H+HwnnPvnvpBZZJrKw05pn4YYVSczcG6bZ3CIDl3DCvDlVNluL5jtGpGboumzAxxWWGUfmHI6J4Eavckhp7CD6JIzC0XXOKiKCih0TSebhRhsOpFbpux9OsijLZzSr6temV+T/ncMapPbjeEw8zwF1H4VlnRi/SjiKNzgWA7pRC5H8fAESQgjpBnu8gfcaR/66BEseU0kYRur4VBjRZuB4wyr9E/HMNIwmkN1M9a+l0fR7tzOh36YvfODA2xJfVs9fpiGO3vLmDpiS5Kfx4Dh29HHc9+URQ+t/Uvp36NyvDo2lZyLZP+PNI35CJdnYt0dS7S9blgd30uRo7LcjE0XJ0LDT63eSRa1O0X54L/rePCfPLV+RzuSaXNIwzWcS7fsCeN6lOw8nF0/VPs6KARMo4J+gnAsrNKpHaK5dkR9IsihWvPKmm0O7vSnhKJ+nti4tFzYiqnJ02/0NGmorrcd8i1FT7M50V1MTrOe0GBp3mTfH3Qk0Fx6hccSIV+sxE6D81jQ7sh+k1IWmLIvj2w6md9iwySm0EWPPrrl1otDYH6z8zD01pqZ+CSKC078c0dod8h8g3nC8nX7wEjx2UdMjT094Af+uvmYXc8++Lyw1TH3eZ+v62/Pr0dHmb/ff3/Bf/BF58vx+eH7ePbcWum07ef+uM262fXufgf65V+Anyrp/i1dpz+Zh/g3+ZS1sXRjw+L5Tc=",
+      "debug_symbols": "tZnRTiM7DIbfpde9iJM4TngVtFoVKKtKVUFdONIR4t3XZvJnpqwSlZa9IR/Q+ep47CTTvq0etnevv37uDo9Pv1c3t2+ru+Nuv9/9+rl/ut+87J4O+te3lbMfyefVTVjrWFY3Scfg6kh19HUMdYx15DqmOkodcx2rL1ZfrL5YfayvEx2T/r3Y6OuofiIDBug7kIWYBJABpYI4AAE8IAAigAEwC8wCs8CcYc4wZ5gzzBnmDHOGOcOcYc4wF5gLzAXmAnOBuVSzOLuKDQjgAfaaZJAAAtB3986gVCAHIIAHBIC+u7fLiQEJIAAzi0Gp4B3AzMVAzcGC9wEQAQxIAAFkQKlgtTkBAWAOMAeYrUCDpcUqdAIBmNkitCL9AKvSCexyiznqiyMZ6IujCWOpwA6gYcRo4AEBEAEMSAABmNni4VIhOQABzGyBpQCIADNngwQQQAaUCtYgExDAzDZTa5AJIoABamZLgjXIBBmgZvYK1iATEMADAiACGGBmy6E1yAQZUCpYg7AlyhqErdisQSYIADNbNqxBJkgAAWRAmSBbE01g5mzgAQEQAbbSOYMEEIAtdmRQKlhbJW9AAA8IAFtCk4GZ7S2srSYQQAaUCtZWExDAzMUgANQsFoa1ldh7WVtNoGYJBhlQKlhbTUAADwgAM0cDBiSAAMzMBqWCtdUEBLCrbO7WXxNkgF1ls7D+moAAGk+2hFt/TRABDEgAAWSAmrOlxfprAgJ4gM1U3t/XK2ySP1+O263tkYtdU/fS581xe3hZ3Rxe9/v16r/N/vXjRb+fN4eP8WVz1P/q224PDzqq8HG33xq9r+erXf9S8tFxvVw5+qYgdyqhviTa4vyhiFGaQE6v9/3rA2MGQfIcQA5fmIVVYp0Fc+rOIvYlnBymwcmHWcF8ouC+wifvq8KnRS7T+TGUgBh0++zGMFDo4QnZ1PORdBW5r5CWCF3KF/eDzp6GtBhYljX1KQYa3NPgCbkMPrtOLseG0uoquNwzDAozkochUigX3E9dtZEIXR77iRg4SlMUP4cQz6/rYoeNqSCck4tqytGs8H2FvarboyWhqqhIbA4up4pBXZK0kiA9JXQVZZBMQhAlL5cad76hRMTgiLsKP1gvvY9weM+5d0/9oDLJtZWGHFM/jDAqzuZg3bbmMOg0n35YGa7MleH6jtGqGbktmrIwpMsKo/QLQ0b3JFC7JzH0FH4QRWJuueASL4qCEhpN4+lGEQarXuS2GUu/LsJoO6fk26pXlvdUTh2j+uR2Q3ieRvRfiMK3yopepB9FHJ0LBNsphcj9OAaOIAFxhLzYRf6KI/1bByWKLaeJJHR7LQxqtHA7YJRljf7lGEYS5jVQP2vpd30c7c5pPvTF7p0ZGmJL6nL1+mwY7e8uYOmJLkp/HgOHb0cdz/6iKHxu619O/RqV4dG1reRaJv15pG/IRbo6F+nqXKTrc8Hu+lyMHOflYmi4OhcafG7zSHRRt5+dC/63jjPzyVfnc7gnlTaPMFjHuXzDnjSqT8HKx9H1T7Gjg0bIOCboJwCXnVUitVMsL46gnxQpXHtWSaPd2ZX2lEjU3xMTj54TU5mfNP2FjjYV1eW+Q66t8GE+z6qL0XHeCwo8LZvk84OeDIpTv+BAKvSbjdB5aB4b2g3Rb0LSJYbs2wOrftZ3kUFyM8gFj/76pVZLQ6D+M/PwtJbaGbikRSK+dOJbOkK/Q+QbzheSr98DRo7zOmRo6O8BP/TXzf3uePLF5bupjrvN3X5bf318Pdwv/vvy/zP+gy8+n49P99uH1+PWTPO3n/rjNutn17n4H+uVfgJ8q6f4tXac/mYf4N/mUtbF0Y93i+UP",
       "is_unconstrained": true,
       "name": "offchain_receive"
     },
@@ -3915,7 +3927,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "tZnbbhs5DIbfxde50IEUpbxKURRp6hYGDCdwkwUWRd59yZF+jh1Ag9Tb3lSf6M7Pw1AHO7923/ZfX398OZy+P/3c3X/6tft6PhyPhx9fjk+PDy+Hp5Naf+2C/RMp7u7j3S5yGCPv7pOOJYxxzGXMhcbY+ljHvI55y2Osy5hCGqP0kVSHbKQxtj7ymPOYlzEXfV5slD5WjbfaWPrYxrzpPIa7XQ4RoJFHTSnHADCLiuRkyZglWXbqJmezsEEdQJZINTBLU2C1ZFPmOqAkQBlgZepAgDagwlLxeLPHNQwKAdCrTaFXkyKN0R7JCikDZEBOAFgsYBNj6aPwUkqSXlqqNMYxb2Pe+pxDLzXHNMZeak5xjGOedZ7ZoAywl5uLAQ9Y2spElr7SaHhpLHOzdJY9JRlgWWqluaqFgoFayJ6ytuogHYq95w4MaAOsah1gSRlgj2tFS+YB1Bu7EI2xl77wqHThUftSEmBUuggsFnC2p5Z3a9BgacMiIQNgibBEWFICyIAMS4aFYKEywIrcgQFtgC2jDnAhcCoQrBCsELRF1WEI1hAABBguKrKoyKIii4osao6A4aISBAkuCIIMFwzBAhcFggIXAsEKFxWCDS4aBNtw0fAuGt5FiwkwXLQUAcNFywHAAAgSASDIcMEQLHBRIChwIRCscLEsUjJoA9qwxGB76iABxehUQMltts91sv2tk21wg9zGbmNXLq5SXMW2uUFuq26rHimCj6G5coO3aNsw8UKqwsHIasx2EEWLiu0oiRZVJ/PL2cgWGptKCpovm0qyGnRK9mkxskXSiaOT24rbitvEbeI2y20Qg5rbGmw5BCdyQizZVsogAdlaGQRvOUcnVyZXJle2FdOJXZndW3Hl4t48t+y5Zc8te265unJzbw3KFLITlCkmJyhTik5QphycyAneiFyZ3Bubcl1IQMVtS0d0YqcGsk4c5DbrxIV46ZyFls7p5LbktsROUOHsKraiOpHbyG0ePXv0vETajKy6Jby93e1wNfvyct7v7WZ2cVfTG9zzw3l/etndn16Px7vdPw/H1+U//Xx+OC3jy8NZP9UVtD9901EFvx+Oe6O3u/XpMH+UopTxNMUmLqA7wUcltGsQgGK6RUK3akTRQohTiTyX0BtlGhJJ39IqIfTRKJpWAFFQrdMoeCOKaDfOHoVuRy6hZb6SKFuJMBSKXAjQTTHkMI1hQ4KIBF1BXKcS7S+mcRXDlYR8uDNLgITe0Hn6QmOaa3BgtKZuFxcLJJZrjY3epFCSL7JEcw2aa8R1lcUWw1xjqzMCFSSjXFeVUq9FtvpTKiQaTZfZVipJz1pIZMnzVOrGqyXvr0xlfbWSriXaH6hGCv+7GlsNVpo3mKR5NdKGhn7X9Q5TrnmaykaX6nMIJOp17cZkavNkqMxf7YZGFSxavbivy75dJ7LZoSK++Yh+q5lWQ+YipSERuVz1v1GLNY/L9foujy2BViBgN/7bFHzPCDnOFDbPdm7r2Z7nB/NWcwb2+4F+b5jWkrc28oJlprfaNj0LMv3FA+kqiDo/FLdeSFyvGHrXpdkbyRuNqV9ZSvZMSk2z7s4b22dJCKNwuKm7rzJhvqU77VsGJPSKfZuErBJSb+hwDgmHkR7180sfbd09g189L053ih9eZV4HCuvz+n31w7f45PeLVKcCtLFn6k9HKIPoD2lrGd5JyNaR7PdOxYvz410ht071ELJvFZcXpXcSG6e6Hl1rS+gxJrNUwubVE+WUcMv70K+Y6KmLryK/IyDYMrmVWwQuF/hNAhIQgaTbBAQ9KRfH+G8I1IwUaplHwPL31qVkbPhyWxHXE6PUdwv7s04fHg/nqz/OvJnU+fDw9bgf0++vp8eLT1/+fcYn+OPO8/npcf/t9bw3pfUvPPqbxKesyzWzfLYfzmyq6egPSp/fzPt/",
+      "debug_symbols": "tVlbbls5DN2Lv/OhBylK2UpRFGnqFgYMJ3CTAQZF9j7klQ5tB9BFeqf9KY/o6vAhUqKdX7tv+6+vP74cTt+ffu7uP/3afT0fjsfDjy/Hp8eHl8PTSbW/dsH+iRR39/FuFzkMybv7pLKEIcdaxlpoyNZlHes61i0PWReZQhpSuiTlIZM0ZOuSx5rHuoy16H4xKV1W9beaLF22sW66juFul0MEUM+jhpRjADCNkuRkwZgmWXRqJmfTsIE6AFkg1YBpmgJWTTZmrgOUBFAGsDR1QABtgApNxfZm29UNCgGgZ5tCzyZFGtK2ZAUpA8gAOQFAYw4bGUuXwksqSXpqqdKQY93GuvU1h55qjmnInmpOccixzrrObKAMYIebiwEeYCkrI1nqSr3hpbDMzFJZtksygEWpmeaqGgoGVEO2y8qqA+mg2Dl3wABtAMtaB9CkDGDbNaMl8wDUC7sQDdlTX3hkuvDIfSkJYGS6CDTmcLZdy9kaaNC0oZGQAaCJ0ERoUgKQATI0GRqChsoAluQOGKANYG3UAUwIjAoIKwgrCK2pOhiENQQAAhgmKqKoiKIiioooao4Aw0QlEBJMEAgZJhiEBSYKCAUmBIQVJioIG0w0ELZhouEsGs6ixQQwTLQUAYaJlgMAA4CQCACEDBMMwgITBYQCEwLCChNLk5KBNkAbmhjsTh1IgGJ0VICS6+ye68jut47sghvIdew6dubiLMVZ7JobyHXVddU9hfMxNGdusBbtGiZekLJwMGQ5ZnuIonnF9pRE86ojs8vZkDUaG0sKGi8bS7IcdJTs02LImqQjjo5cV1xXXCeuE9dZbAMxUHNdgy6H4IgcwZdsnTKQAFmvDARrOUdHzkzOTM5sHdMROzO7teLMxa15bNljyx5b9thydebm1hqYKWRHYKaYHIGZUnQEZsrBETmCNSJnJrfGxlwXJEDFdUtFdMSOGpBV4kCus0pcEC+Vs6ClcjpyXXJdYkdg4ews1lEdkevIde49u/e8eNoMWXZLeHu722E0+/Jy3u9tMrua1XSCe344708vu/vT6/F4t/vn4fi6/Kefzw+nRb48nPVT7aD96ZtKJfx+OO4Nvd1ddof5VopSxm6KTZxAb4KPUmjVwAGFaQuFXtXwooUQpxR5TqETZRoUSU/pQiHlo140zQC8oFqnXvCKF9Emzu6FXkdOocw3FGUtEAZDkSuCssmHHKY+rFAQkaAqiOuUov3FMG58uKFoH67MEkChEzpPDzSmOQcHRmnqdXHVIO8iiSu1SaEkb7JEcw6ac8RLl8UWw5xjrTICFQSjuF5YSr0lWatPqaBoNG2ztVCSvrWgyJLnodSVoyWvr0zlcrSSbinaH8hGCv87G2sFVpoXmKR5NtIKh37X9QpTXPM0lJUq1X1wJOq4tjGY2jwYKvOjXeGogqbVwf3S9rddn1YrVMQvH9FvNdNsyJykNAQi110vW+K47td3cawRtAICm/i3MfidEXKcMay+7dwub3ueP8xrxRnY5wP93jDNJa9d5AVtplNtm74Fmf7ig3TjRJ0/imsHEi8jhs66NDuRvFKY+pWlZI+k1DSr7rxyfZYENwqHTdV9Ewnzluq0bxmg0BF7G4VcKKRuqHAOCY+RPvXzoY/WZs/go+fV607xw13meaBw2Z+4fniKTz5fpDoloJU7U386QhpEf0i7pOG2IkjWnmSfO7P1hFO8S+Taqx5C9qvielB6R7HyquvTdSkJfcZkFkpYHT2RTglbzkO/YqKmrr6K/A6B4MrkVrYQXDf4JgIJ8EDSNgJBTcrVM/4bBDUjhFrmHrD8vb6UjAtftiXx8mKU+q6xP+vy4fFwvvnjzJtRnQ8PX4/7sfz+enq8+vTl32d8gj/uPJ+fHvffXs97Y7r8hUd/k/iUtV0zy2f74cyWGo7+oPT5zaz/Bw==",
       "is_unconstrained": true,
       "name": "public_dispatch"
     },
@@ -4059,11 +4071,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"
     }
@@ -4286,5 +4298,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "0.0.1-commit.993d240"
+  "aztec_version": "0.0.1-commit.b9865e97"
 }