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

package/artifacts/SchnorrInitializerlessAccount.json

@@ -18,7 +18,7 @@
       "path": "std/aes128.nr",
       "source": "// docs:start:aes128\n/// Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.\npub fn aes128_encrypt<let N: u32>(\n    input: [u8; N],\n    iv: [u8; 16],\n    key: [u8; 16],\n) -> [u8; N + 16 - N % 16] {\n    let padding_length = (16 - N % 16) as u8;\n    let mut padded_input: [u8; N + 16 - N % 16] = [0; N + 16 - N % 16];\n    for i in 0..N {\n        padded_input[i] = input[i];\n    }\n    for i in N..N + 16 - N % 16 {\n        padded_input[i] = padding_length;\n    }\n    let output = aes128_encrypt_padded_input(padded_input, iv, key);\n    output\n}\n\n#[foreign(aes128_encrypt)]\nfn aes128_encrypt_padded_input<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8; N] {}\n\n// docs:end:aes128\n\nmod tests {\n    use super::aes128_encrypt;\n\n    #[test]\n    fn encrypt() {\n        let input = \"kevlovesrust\".as_bytes();\n        let iv = \"0000000000000000\".as_bytes();\n        let key = \"0000000000000000\".as_bytes();\n        let output = [244, 14, 126, 172, 171, 40, 208, 186, 173, 184, 226, 105, 238, 122, 205, 191];\n        assert_eq(aes128_encrypt(input, iv, key), output);\n    }\n}\n"
     },
-    "101": {
+    "102": {
       "function_locations": [
         {
           "name": "AztecConfig::new",
@@ -56,7 +56,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
       "source": "mod compute_note_hash_and_nullifier;\n\nuse crate::{\n    macros::{\n        calls_generation::{\n            external_functions::{generate_external_function_calls, generate_external_function_self_calls_structs},\n            internal_functions::generate_call_internal_struct,\n        },\n        dispatch::generate_public_dispatch,\n        emit_public_init_nullifier::generate_emit_public_init_nullifier,\n        internals_functions_generation::{create_fn_abi_exports, process_functions},\n        offchain_receive::{\n            OFFCHAIN_RECEIVE_FN_NAME, OFFCHAIN_RECEIVE_PARAM_NAME, offchain_receive_param_type,\n            OFFCHAIN_RECEIVE_RETURN_TYPE,\n        },\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{is_fn_contract_library_method, is_fn_external, is_fn_internal, is_fn_test, module_has_storage},\n    },\n    messages::discovery::{CustomMessageHandler, CustomSyncHandler},\n};\n\nuse compute_note_hash_and_nullifier::generate_contract_library_methods_compute_note_hash_and_nullifier;\n\n/// Configuration for the [`aztec`] macro.\n///\n/// This type lets users override different parts of the default aztec-nr contract behavior, such\n/// as message handling and state synchronization. These are advanced features that require careful\n/// understanding of the behavior of these systems.\n///\n/// ## Examples\n///\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyContract { ... }\n/// ```\npub struct AztecConfig {\n    custom_message_handler: Option<CustomMessageHandler>,\n    custom_sync_state: Option<CustomSyncHandler>,\n}\n\nimpl AztecConfig {\n    /// Creates a new `AztecConfig` with default values.\n    ///\n    /// Calling `new` is equivalent to invoking the [`aztec`] macro with no parameters. The different methods\n    /// (e.g. [`AztecConfig::custom_message_handler`]) can then be used to change the default behavior.\n    pub comptime fn new() -> Self {\n        Self { custom_message_handler: Option::none(), custom_sync_state: Option::none() }\n    }\n\n    /// Sets a handler for custom messages.\n    ///\n    /// This enables contracts to process non-standard messages (i.e. any with a message type that is not in\n    /// [`crate::messages::msg_type`]).\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomMessageHandler`] type signature.\n    pub comptime fn custom_message_handler(&mut self, handler: CustomMessageHandler) -> Self {\n        self.custom_message_handler = Option::some(handler);\n        *self\n    }\n\n    /// Overrides the default state synchronization logic.\n    ///\n    /// The generated `sync_state` function will call `handler` instead of\n    /// [`crate::messages::discovery::do_sync_state`]. The handler receives all of the same parameters, so it can\n    /// run custom logic (e.g. fetching and decrypting custom logs) before, after, or instead of calling\n    /// `do_sync_state`.\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomSyncHandler`] type signature.\n    pub comptime fn custom_sync_state(&mut self, handler: CustomSyncHandler) -> Self {\n        self.custom_sync_state = Option::some(handler);\n        *self\n    }\n}\n\n/// Enables aztec-nr features on a `contract`.\n///\n/// All aztec-nr contracts should have this macro invoked on them, as it is the one that processes all contract\n/// functions, notes, storage, generates interfaces for external calls, and creates the message processing\n/// boilerplate.\n///\n/// ## Examples\n///\n/// Most contracts can simply invoke the macro with no parameters, resulting in default aztec-nr behavior:\n/// ```noir\n/// #[aztec]\n/// contract MyContract { ... }\n/// ```\n///\n/// Advanced contracts can use [`AztecConfig`] to customize parts of its behavior, such as message\n/// processing.\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyAdvancedContract { ... }\n/// ```\n#[varargs]\npub comptime fn aztec(m: Module, args: [AztecConfig]) -> Quoted {\n    let num_args = args.len();\n    let config = if num_args == 0 {\n        AztecConfig::new()\n    } else if num_args == 1 {\n        args[0]\n    } else {\n        panic(f\"#[aztec] expects 0 or 1 arguments, got {num_args}\")\n    };\n\n    // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n    check_each_fn_macroified(m);\n\n    // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n    // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n    let functions = process_functions(m);\n\n    // We generate structs and their implementations necessary for convenient functions calls.\n    let interface = generate_contract_interface(m);\n    let self_call_structs = generate_external_function_self_calls_structs(m);\n    let call_internal_struct = generate_call_internal_struct(m);\n\n    // We generate ABI exports for all the external functions in the contract.\n    let fn_abi_exports = create_fn_abi_exports(m);\n\n    // We generate `_compute_note_hash`, `_compute_note_nullifier` (and the deprecated\n    // `_compute_note_hash_and_nullifier` wrapper) only if they are not already implemented.\n    // If they are implemented we just insert empty quotes.\n    let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n        // Note that we don't test for `_compute_note_hash` or `_compute_note_nullifier` in order to make this simpler\n        // - users must either implement all three or none.\n        // Down the line we'll remove this check and use `AztecConfig`.\n        f.name() == quote { _compute_note_hash_and_nullifier }\n    }) {\n        generate_contract_library_methods_compute_note_hash_and_nullifier()\n    } else {\n        quote {}\n    };\n    let process_custom_message_option = if config.custom_message_handler.is_some() {\n        let handler = config.custom_message_handler.unwrap();\n        quote { Option::some($handler) }\n    } else {\n        quote { Option::<aztec::messages::discovery::CustomMessageHandler>::none() }\n    };\n\n    let offchain_inbox_sync_option = quote {\n        Option::some(aztec::messages::processing::offchain::sync_inbox)\n    };\n\n    if m.functions().any(|f| f.name() == quote { sync_state }) {\n        panic(\n            \"User-defined 'sync_state' is not allowed. Use AztecConfig::custom_sync_state() to customize sync behavior.\",\n        );\n    }\n\n    let custom_sync_handler = if config.custom_sync_state.is_some() {\n        let handler = config.custom_sync_state.unwrap();\n        Option::some(quote { $handler })\n    } else {\n        Option::none()\n    };\n\n    let sync_state_fn_and_abi_export = generate_sync_state(\n        process_custom_message_option,\n        offchain_inbox_sync_option,\n        custom_sync_handler,\n    );\n\n    if m.functions().any(|f| f.name() == quote { offchain_receive }) {\n        panic(\n            \"User-defined 'offchain_receive' is not allowed. The function is auto-injected by the #[aztec] macro. See https://docs.aztec.network/errors/7\",\n        );\n    }\n    let offchain_receive_fn_and_abi_export = generate_offchain_receive();\n\n    let (has_public_init_nullifier_fn, emit_public_init_nullifier_fn_body) = generate_emit_public_init_nullifier(m);\n    let public_dispatch = generate_public_dispatch(m, has_public_init_nullifier_fn);\n\n    quote {\n        $interface\n        $self_call_structs\n        $call_internal_struct\n        $functions\n        $fn_abi_exports\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_state_fn_and_abi_export\n        $emit_public_init_nullifier_fn_body\n        $offchain_receive_fn_and_abi_export\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let calls = generate_external_function_calls(m);\n\n    let module_name = m.name();\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: aztec::protocol::address::AztecAddress\n        }\n\n        impl $module_name {\n            $calls\n\n            pub fn at(\n                addr: aztec::protocol::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates the `sync_state` utility function that performs message discovery.\ncomptime fn generate_sync_state(\n    process_custom_message_option: Quoted,\n    offchain_inbox_sync_option: Quoted,\n    custom_sync_handler: Option<Quoted>,\n) -> Quoted {\n    let body = if custom_sync_handler.is_some() {\n        let handler = custom_sync_handler.unwrap();\n        quote {\n            $handler(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    } else {\n        quote {\n            aztec::messages::discovery::do_sync_state(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    };\n\n    quote {\n        pub struct sync_state_parameters {\n            pub scope: aztec::protocol::address::AztecAddress,\n        }\n\n        #[abi(functions)]\n        pub struct sync_state_abi {\n            parameters: sync_state_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn sync_state(scope: aztec::protocol::address::AztecAddress) {\n            let address = aztec::context::UtilityContext::new().this_address();\n            $body\n        }\n    }\n}\n\n/// Generates an `offchain_receive` utility function that lets callers add messages to the offchain message inbox.\n///\n/// For more details, see `aztec::messages::processing::offchain::receive`.\ncomptime fn generate_offchain_receive() -> Quoted {\n    let param_type = offchain_receive_param_type(quote { aztec });\n    let parameters_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_parameters\".quoted_contents();\n    let abi_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_abi\".quoted_contents();\n\n    quote {\n        pub struct $parameters_struct_name {\n            pub $OFFCHAIN_RECEIVE_PARAM_NAME: $param_type,\n        }\n\n        #[abi(functions)]\n        pub struct $abi_struct_name {\n            parameters: $parameters_struct_name,\n        }\n\n        /// Receives offchain messages into this contract's offchain inbox for subsequent processing.\n        ///\n        /// Each message is routed to the inbox scoped to its `recipient` field.\n        ///\n        /// For more details, see `aztec::messages::processing::offchain::receive`.\n        ///\n        /// This function is automatically injected by the `#[aztec]` macro.\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn $OFFCHAIN_RECEIVE_FN_NAME($OFFCHAIN_RECEIVE_PARAM_NAME: $param_type) -> $OFFCHAIN_RECEIVE_RETURN_TYPE {\n            let address = aztec::context::UtilityContext::new().this_address();\n            aztec::messages::processing::offchain::receive(address, $OFFCHAIN_RECEIVE_PARAM_NAME);\n        }\n    }\n}\n\n/// Checks that all functions in the module have a context macro applied.\n///\n/// Non-macroified functions are not allowed in contracts. They must all be one of\n/// [`crate::macros::functions::external`], [`crate::macros::functions::internal`] or `test`.\ncomptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_external(f) & !is_fn_contract_library_method(f) & !is_fn_internal(f) & !is_fn_test(f) {\n            // We  don't suggest that #[contract_library_method] is allowed because we don't want to introduce another\n            // concept\n            panic(\n                f\"Function {name} must be marked as either #[external(...)], #[internal(...)], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
-    "116": {
+    "117": {
       "function_locations": [
         {
           "name": "generate_private_external",
@@ -66,7 +66,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/private.nr",
       "source": "use crate::macros::{\n    functions::initialization_utils::has_public_init_checked_functions,\n    internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},\n    utils::{\n        fn_has_allow_phase_change, fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self,\n        is_fn_view, module_has_initializer, module_has_storage,\n    },\n};\nuse crate::protocol::meta::utils::derive_serialization_quotes;\nuse std::meta::type_of;\n\npub(crate) comptime fn generate_private_external(f: FunctionDefinition) -> Quoted {\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to\n    // the Private Kernel Circuit. First we change the function signature so that it also receives\n    // `PrivateContextInputs`, which contain information about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n\n    let original_params_quotes =\n        original_params.map(|(param_name, param_type)| quote { $param_name: $param_type }).join(quote {, });\n\n    let params = quote { inputs: aztec::context::inputs::PrivateContextInputs, $original_params_quotes };\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    let (args_serialization, _, serialized_args_name) = derive_serialization_quotes(original_params, false);\n\n    let storage_init = if module_has_storage {\n        // Contract has Storage defined so we initialize it.\n        quote {\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelfPrivate\n        // requires a storage struct in its constructor. Using an Option type would lead to worse developer experience\n        // and higher constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            $args_serialization\n            let args_hash = aztec::hash::hash_args($serialized_args_name);\n            let mut context = aztec::context::PrivateContext::new(inputs, args_hash);\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<&mut aztec::context::PrivateContext> = CallSelf { address: self_address, context: &mut context };\n            let enqueue_self: EnqueueSelf<&mut aztec::context::PrivateContext> = EnqueueSelf { address: self_address, context: &mut context };\n            let call_self_static: CallSelfStatic<&mut aztec::context::PrivateContext> = CallSelfStatic { address: self_address, context: &mut context };\n            let enqueue_self_static: EnqueueSelfStatic<&mut aztec::context::PrivateContext> = EnqueueSelfStatic { address: self_address, context: &mut context };\n            let internal: CallInternal<&mut aztec::context::PrivateContext> = CallInternal { context: &mut context };\n            let call_self_utility = CallSelfUtility { address: self_address };\n            let utility: aztec::contract_self::PrivateUtilityCalls<CallSelfUtility> = aztec::contract_self::PrivateUtilityCalls { call_self: call_self_utility };\n            aztec::contract_self::ContractSelfPrivate::new(&mut context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal, utility)\n        };\n    };\n\n    let original_function_name = f.name();\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_only_self(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called by the same contract\";\n        quote { assert(self.msg_sender() == self.address, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called statically\".as_quoted_str();\n        quote { assert(self.context.inputs.call_context.is_static_call, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        let has_public_fns_with_init_check = has_public_init_checked_functions(f.module());\n        (\n            quote {\n                aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_private(*self.context);\n            },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_from_private_initializer(self.context, $has_public_fns_with_init_check); },\n        )\n    } else {\n        (quote {}, quote {})\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_private(self.context); }\n    } else {\n        quote {}\n    };\n\n    // Phase checks are skipped in functions that request to manually handle phases\n    let initial_phase_store = if fn_has_allow_phase_change(f) {\n        quote {}\n    } else {\n        quote { let within_revertible_phase: bool = self.context.in_revertible_phase(); }\n    };\n\n    let no_phase_change_check = if fn_has_allow_phase_change(f) {\n        quote {}\n    } else {\n        quote {\n            assert_eq(\n                within_revertible_phase,\n                self.context.in_revertible_phase(),\n                f\"Phase change detected on function with phase check. If this is expected, use #[allow_phase_change]\",\n            );\n        }\n    };\n\n    // Inject the authwit check if the function is marked with #[authorize_once].\n    let authorize_once_check = if fn_has_authorize_once(f) {\n        create_authorize_once_check(f, true)\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is serialized and hashed before being passed to the context.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment = quote { let $return_value_var_name: $return_value_type = $return_value; };\n\n        let (return_serialization, _, serialized_return_name) =\n            derive_serialization_quotes([(return_value_var_name, return_value_type)], false);\n\n        body = body_without_return;\n\n        quote {\n            $return_value_assignment\n            $return_serialization\n            self.context.set_return_hash($serialized_return_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(quote { let $unused_return_value_name = $last_body_expr; }\n                .as_expr()\n                .unwrap());\n        }\n        quote {}\n    };\n\n    let context_finish = quote { self.context.finish() };\n\n    // Preserve all attributes that are relevant to the function's ABI.\n    let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n\n    let to_prepend = quote {\n        aztec::oracle::version::assert_compatible_oracle_version();\n        $contract_self_creation\n        $initial_phase_store\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $authorize_once_check\n    };\n\n    let body_quote = body.map(|expr| expr.quoted()).join(quote { });\n\n    // `mark_as_initialized` is placed after the user's function body. If it ran at the beginning, the contract\n    // would appear initialized while the initializer is still running, allowing contracts called by the initializer\n    // to re-enter into a half-initialized contract.\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $no_phase_change_check\n        $context_finish\n    };\n\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n        $abi_relevant_attributes\n        fn $fn_name($params) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n            $to_prepend\n            $body_quote\n            $to_append\n        }\n    }\n}\n"
     },
-    "118": {
+    "119": {
       "function_locations": [
         {
           "name": "generate_utility_self_creator",
@@ -658,59 +658,125 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [bool; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n    pub fn sgn0(self) -> bool {\n        (self as u8) % 2 == 1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_le_bytes\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_be_bytes\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes\n        static_assert(\n            N <= modulus_be_bytes().len(),\n            \"N must be less than or equal to modulus_be_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a little endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_le_bytes_checked\n    pub fn from_le_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes_checked\n        let p = modulus_le_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[N - 1 - i] != p[N - 1 - i] {\n                    assert(\n                        bytes[N - 1 - i] < p[N - 1 - i],\n                        \"input bytes are not a canonical field representation\",\n                    );\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_le_bytes(bytes)\n    }\n\n    /// Convert a big endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_be_bytes_checked\n    pub fn from_be_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes_checked\n        let p = modulus_be_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[i] != p[i] {\n                    assert(bytes[i] < p[i], \"input bytes are not a canonical field representation\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_be_bytes(bytes)\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_be_bits();\n        assert_eq(bits, [false, false, false, false, false, false, true, false]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_le_bits();\n        assert_eq(bits, [false, true, false, false, false, false, false, false]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_le_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_be_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_be_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n            let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n            let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n            let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n            let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_bytes_checked_small_n() {\n        // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n        // variants behave identically to the unchecked ones.\n        let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n        assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n        let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n        assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn max_bit_size_too_large() {\n        let x: Field = 0x010000;\n        x.assert_max_bit_size::<16>();\n    }\n\n}\n"
     },
-    "160": {
+    "163": {
       "function_locations": [
         {
           "name": "receive",
-          "start": 5315
+          "start": 2571
         },
         {
           "name": "sync_inbox",
-          "start": 6758
+          "start": 3354
         },
         {
           "name": "test::setup",
-          "start": 11124
+          "start": 5138
         },
         {
           "name": "test::make_msg",
-          "start": 11454
+          "start": 5468
         },
         {
           "name": "test::advance_by",
-          "start": 11737
+          "start": 5751
         },
         {
           "name": "test::empty_inbox_returns_empty_result",
-          "start": 11928
+          "start": 5942
         },
         {
-          "name": "test::tx_bound_msg_expires_after_max_msg_ttl",
-          "start": 12391
+          "name": "test::multiple_messages_mixed_expiration",
+          "start": 6330
         },
         {
-          "name": "test::tx_bound_msg_not_expired_before_max_msg_ttl",
-          "start": 13356
+          "name": "test::redelivery_is_idempotent",
+          "start": 8312
         },
         {
-          "name": "test::tx_less_msg_expires_after_max_msg_ttl",
-          "start": 14314
+          "name": "test::redelivery_after_processing_keeps_processed_guard",
+          "start": 9177
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/mod.nr",
+      "source": "use crate::{\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithContext},\n    oracle::{contract_sync::set_contract_sync_cache_invalid, tx_resolution::get_resolved_txs},\n    protocol::{address::AztecAddress, traits::{Deserialize, Serialize}},\n};\n\nmod reception;\nuse reception::OffchainReception;\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an [`OffchainInboxSync`] is [`sync_inbox`], which manages an inbox with\n/// expiration\n/// based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The expiration is set to `anchor_block_timestamp + MAX_MSG_TTL`\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // Offchain reception facts are scoped to the recipient. Note that because offchain messages have no integrity or\n    // authenticity checks it is not possible to verify that this is indeed the intended recipient. In this case we're\n    // assuming a cooperative environment, which is on par with other offchain delivery expectations.\n    messages.for_each(|msg| OffchainReception::init(contract_address, msg));\n\n    // Clear cache for message recipients so the next sync runs.\n    set_contract_sync_cache_invalid(contract_address, messages.map(|msg| msg.recipient));\n}\n\n/// Returns offchain-delivered messages to process during sync.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let active_receptions = OffchainReception::load_all(contract_address, scope);\n\n    // Ask PXE to resolve each message's originating tx. We pass the tx hashes in reception order, so the resolved txs\n    // come back aligned with the reception indices and can be matched back positionally.\n    let resolved_txs = get_resolved_txs(active_receptions.map(|reception: OffchainReception| {\n        reception.read_message().tx_hash.unwrap_or(0)\n    }));\n\n    let processable_messages: EphemeralArray<OffchainMessageWithContext> = EphemeralArray::empty();\n    let now = UtilityContext::new().timestamp();\n\n    active_receptions.for_each(|i, reception| {\n        let maybe_message = reception.step(resolved_txs.get(i), now);\n        if maybe_message.is_some() {\n            processable_messages.push(maybe_message.unwrap());\n        }\n    });\n\n    processable_messages\n}\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\nmod test {\n    use crate::{\n        oracle::random::random, protocol::address::AztecAddress, test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OffchainMessage, receive, sync_inbox};\n    use super::reception::{MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(OffchainReception::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let expired_a_tx_hash = random();\n        let survivor_tx_hash = random();\n\n        let expired_a = make_msg(scope, Option::some(expired_a_tx_hash), 0);\n        let survivor = make_msg(scope, Option::some(survivor_tx_hash), anchor_ts);\n        let expired_b = make_msg(scope, Option::none(), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor=0 so it expires quickly.\n            msgs.push(expired_a);\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(survivor);\n            // Message 2: tx-less, anchor=0 so it also expires.\n            msgs.push(expired_b);\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor=0, but not for anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            assert(\n                !OffchainReception::is_active(address, scope, expired_a),\n                \"expired tx-bound reception should be terminated\",\n            );\n            assert(\n                !OffchainReception::is_active(address, scope, expired_b),\n                \"expired tx-less reception should be terminated\",\n            );\n            assert(OffchainReception::is_active(address, scope, survivor), \"survivor reception should stay active\");\n            assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n        });\n    }\n\n    // -- Idempotent re-delivery (first-write-wins fact recording) ---------\n\n    #[test]\n    unconstrained fn redelivery_is_idempotent() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n        let msg = make_msg(scope, Option::some(random()), anchor_ts);\n\n        // First delivery, committed as its own job.\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n        // Re-delivering the same content-addressed message must not panic and must not create a second reception.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([msg]));\n\n            assert(OffchainReception::is_active(address, scope, msg), \"reception should be active\");\n            assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn redelivery_after_processing_keeps_processed_guard() {\n        let (env, scope) = setup();\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n        let msg = make_msg(scope, Option::some(known_tx_hash), anchor_ts);\n\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n        let _now = advance_by(env, 100);\n\n        // First sync resolves the message and marks it as processed.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            assert_eq(sync_inbox(address, scope).len(), 1);\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n\n        // Re-deliver the same message. The next sync recognizes it as already processed and does not re-push it.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([msg]));\n\n            assert(\n                OffchainReception::is_processed(address, scope, msg),\n                \"re-delivery must preserve the processed guard\",\n            );\n            assert_eq(sync_inbox(address, scope).len(), 0);\n        });\n    }\n}\n"
+    },
+    "164": {
+      "function_locations": [
+        {
+          "name": "OffchainReception::init",
+          "start": 8508
         },
         {
-          "name": "test::unresolved_tx_stays_in_inbox",
-          "start": 15256
+          "name": "OffchainReception::load_all",
+          "start": 9026
         },
         {
-          "name": "test::multiple_messages_mixed_expiration",
-          "start": 16150
+          "name": "OffchainReception::read_message",
+          "start": 9375
+        },
+        {
+          "name": "OffchainReception::id_for",
+          "start": 10076
+        },
+        {
+          "name": "OffchainReception::is_active",
+          "start": 10395
+        },
+        {
+          "name": "OffchainReception::step",
+          "start": 11055
+        },
+        {
+          "name": "OffchainReception::is_processed",
+          "start": 12512
+        },
+        {
+          "name": "OffchainReception::mark_processed",
+          "start": 13080
+        },
+        {
+          "name": "OffchainReception::terminate",
+          "start": 13648
+        },
+        {
+          "name": "to_payload",
+          "start": 14022
         },
         {
-          "name": "test::resolved_msg_is_ready_to_process",
-          "start": 17889
+          "name": "test::setup",
+          "start": 14579
+        },
+        {
+          "name": "test::make_msg",
+          "start": 14909
+        },
+        {
+          "name": "test::resolved_tx",
+          "start": 15140
+        },
+        {
+          "name": "test::expired_reception_is_terminated",
+          "start": 15419
+        },
+        {
+          "name": "test::unresolved_reception_stays_active",
+          "start": 16101
+        },
+        {
+          "name": "test::resolved_reception_is_ready_to_process",
+          "start": 16896
+        },
+        {
+          "name": "test::already_processed_reception_is_not_re_pushed",
+          "start": 17946
+        },
+        {
+          "name": "test::expired_resolved_reception_is_processed_once_before_termination",
+          "start": 19064
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain.nr",
-      "source": "use crate::{\n    capsules::CapsuleArray,\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithContext},\n    oracle::contract_sync::set_contract_sync_cache_invalid,\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::sha256_to_field,\n        traits::{Deserialize, Serialize},\n    },\n};\n\n/// Base capsule slot for the persistent inbox of [`PendingOffchainMsg`] entries.\n///\n/// This is the slot where we accumulate messages received through [`receive`].\nglobal OFFCHAIN_INBOX_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_INBOX_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to pass tx hash resolution requests to PXE.\nglobal OFFCHAIN_CONTEXT_REQUESTS_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_CONTEXT_REQUESTS_SLOT\".as_bytes());\n\n/// Ephemeral array slot used by [`sync_inbox`] to collect messages ready for processing.\nglobal OFFCHAIN_READY_MESSAGES_SLOT: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_READY_MESSAGES_SLOT\".as_bytes());\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// Tolerance added to the `MAX_TX_LIFETIME` cap for message expiration.\nglobal TX_EXPIRATION_TOLERANCE: u64 = 7200; // 2 hours\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\nglobal MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + TX_EXPIRATION_TOLERANCE;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an `OffchainInboxSync` is [`sync_inbox`], which manages an inbox with expiration\n/// based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\n/// An offchain message awaiting processing (or re-processing) in the inbox.\n///\n/// Messages remain in the inbox until they expire, even if they have already been processed. This is necessary to\n/// handle reorgs: a processed message may need to be re-processed if the transaction that provided its context is\n/// reverted. On each sync, resolved messages are promoted to [`OffchainMessageWithContext`] for processing.\n#[derive(Serialize, Deserialize)]\nstruct PendingOffchainMsg {\n    /// The encrypted message payload.\n    ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. A value of 0 indicates a tx-less message.\n    tx_hash: Field,\n    /// Anchor block timestamp at message emission. Used to compute the effective expiration: messages are evicted\n    /// after `anchor_block_timestamp + MAX_MSG_TTL`.\n    anchor_block_timestamp: u64,\n}\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Each message is routed to the inbox scoped to its `recipient` field, so messages for different accounts are\n/// automatically isolated.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The effective expiration is\n/// `anchor_block_timestamp + MAX_MSG_TTL`.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // May contain duplicates if multiple messages target the same recipient. This is harmless since\n    // cache invalidation on the TS side is idempotent (deleting an already-deleted key is a no-op).\n    let mut scopes: BoundedVec<AztecAddress, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n    let mut i = 0;\n    let messages_len = messages.len();\n    while i < messages_len {\n        let msg = messages.get(i);\n        let tx_hash = if msg.tx_hash.is_some() {\n            msg.tx_hash.unwrap()\n        } else {\n            0\n        };\n        let inbox: CapsuleArray<PendingOffchainMsg> =\n            CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, msg.recipient);\n        inbox.push(\n            PendingOffchainMsg {\n                ciphertext: msg.ciphertext,\n                recipient: msg.recipient,\n                tx_hash,\n                anchor_block_timestamp: msg.anchor_block_timestamp,\n            },\n        );\n        scopes.push(msg.recipient);\n        i += 1;\n    }\n\n    set_contract_sync_cache_invalid(contract_address, scopes);\n}\n\n/// Returns offchain-delivered messages to process during sync.\n///\n/// Messages remain in the inbox and are reprocessed on each sync until their originating transaction is no longer at\n/// risk of being dropped by a reorg.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, scope);\n    let context_resolution_requests: EphemeralArray<Field> = EphemeralArray::empty_at(OFFCHAIN_CONTEXT_REQUESTS_SLOT);\n    let ready_to_process: EphemeralArray<OffchainMessageWithContext> =\n        EphemeralArray::empty_at(OFFCHAIN_READY_MESSAGES_SLOT);\n\n    // Build a request list aligned with the inbox indices.\n    let mut i = 0;\n    let inbox_len = inbox.len();\n    while i < inbox_len {\n        let msg = inbox.get(i);\n        context_resolution_requests.push(msg.tx_hash);\n        i += 1;\n    }\n\n    // Ask PXE to resolve contexts for all requested tx hashes. The oracle returns responses in a new\n    // ephemeral array.\n    let resolved_contexts =\n        crate::oracle::message_processing::get_message_contexts_by_tx_hash(context_resolution_requests);\n\n    assert_eq(resolved_contexts.len(), inbox_len);\n\n    let now = UtilityContext::new().timestamp();\n\n    let mut j = inbox_len;\n    while j > 0 {\n        // This loop decides what to do with each message in the offchain message inbox. We need to handle 3\n        // different scenarios for each message.\n        //\n        // 1. The TX that emitted this message is still not known to PXE: in this case we can't yet process this\n        // message, as any notes or events discovered will fail to be validated. So we leave the message in the inbox,\n        // awaiting for future syncs to detect that the TX became available.\n        //\n        // 2. The message is not associated to a TX to begin with. The current version of offchain message processing\n        // does not support this case, but in the future it will. Right now, a message without an associated TX will\n        // sit in the inbox until it expires.\n        //\n        // 3. The TX that emitted this message has been found by PXE. That gives us all the information needed to\n        // process the message. We add the message to the `ready_to_process` EphemeralArray so that the `sync_state`\n        // loop\n        // processes it.\n        //\n        // In all cases, if the message has expired (i.e. `now > anchor_block_timestamp + MAX_MSG_TTL`), we remove it\n        // from the inbox.\n        //\n        // Note: the loop runs backwards because it might call `inbox.remove(j)` to purge expired messages and we also\n        // need to align it with `resolved_contexts.get(j)`. Going from last to first simplifies the algorithm as\n        // not yet visited element indexes remain stable.\n        j -= 1;\n        let maybe_ctx = resolved_contexts.get(j);\n        let msg = inbox.get(j);\n\n        // Compute the message's effective expiration timestamp to determine if we can purge it from the inbox.\n        let effective_expiration = msg.anchor_block_timestamp + MAX_MSG_TTL;\n\n        // Message expired. We remove it from the inbox.\n        if now > effective_expiration {\n            inbox.remove(j);\n        }\n\n        // Scenario 1: associated TX not yet available. We keep the message in the inbox, as it might become\n        // processable as new blocks get mined.\n        // Scenario 2: no TX associated to message. The message will sit in the inbox until it expires.\n        if maybe_ctx.is_none() {\n            continue;\n        }\n\n        // Scenario 3: Message is ready to process, add to result array. Note we still keep it in the inbox unless we\n        // consider it has expired: this is because we need to account for reorgs. If reorg occurs after we processed\n        // a message, the effects of processing the message get rewind. However, the associated TX can be included in\n        // a subsequent block. Should that happen, the message must be re-processed to ensure consistency.\n        let message_context = maybe_ctx.unwrap();\n        ready_to_process.push(OffchainMessageWithContext { message_ciphertext: msg.ciphertext, message_context });\n    }\n\n    ready_to_process\n}\n\nmod test {\n    use crate::{\n        capsules::CapsuleArray, oracle::random::random, protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{\n        MAX_MSG_TTL, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OFFCHAIN_INBOX_SLOT, OffchainMessage, PendingOffchainMsg,\n        receive, sync_inbox,\n    };\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let result = sync_inbox(context.this_address(), scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> =\n                CapsuleArray::at(context.this_address(), OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(inbox.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_not_expired_before_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance, but not past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_less_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::none(), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_tx_stays_in_inbox() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // not resolved, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let survivor_tx_hash = random();\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor_ts in the past so it expires at\n            // anchor_ts + MAX_MSG_TTL. We set anchor to 0 so it expires quickly.\n            msgs.push(make_msg(scope, Option::some(random()), 0));\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(make_msg(scope, Option::some(survivor_tx_hash), anchor_ts));\n            // Message 2: tx-less, anchor_ts=0 so it also expires.\n            msgs.push(make_msg(scope, Option::none(), 0));\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor_ts=0, but not for anchor_ts=anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            // Message 0 expired (anchor=0), message 1 survived (anchor=anchor_ts),\n            // Message 2 expired (anchor=0).\n            assert_eq(inbox.len(), 1);\n            assert_eq(inbox.get(0).tx_hash, survivor_tx_hash);\n        });\n    }\n\n    // -- Resolved context (ready to process) ------------------------------\n\n    #[test]\n    unconstrained fn resolved_msg_is_ready_to_process() {\n        let (env, scope) = setup();\n        // TestEnvironment::new() deploys protocol contracts, creating blocks with tx effects.\n        // In TXE, tx hashes equal Fr(blockNumber), so Fr(1) is the tx effect from block 1.\n        // We use this as a \"known resolvable\" tx hash.\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(known_tx_hash), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            // The message should be ready to process since its tx context was resolved.\n            assert_eq(result.len(), 1);\n\n            let ctx = result.get(0).message_context;\n            assert_eq(ctx.tx_hash, known_tx_hash);\n            assert(ctx.first_nullifier_in_tx != 0, \"resolved context must have a first nullifier\");\n\n            // Message stays in inbox (not expired) for potential reorg reprocessing.\n            assert_eq(inbox.len(), 1);\n        });\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/reception.nr",
+      "source": "//! The state machine of a single offchain message reception process.\n//!\n//! Offchain processing needs to handle some complexity, including the possibility of reorgs reverting message effects,\n//! and the need to reprocess messages in that case. The state chart below summarizes the current behavior.\n//!\n//! ```text\n//!                   offchain_receive() (process starts)\n//!                         |\n//!                         v\n//!                     +-----------+     tx found onchain        +-----------+\n//!                ---- |           | --------------------------> |           |\n//!  tx not found  |    |           |                             |           |     discover notes,\n//!                |--> | RECEIVED  |                             | PROCESSED | ~~> events, etc\n//!                     |           | <-------------------------- |           |\n//!                     |           |   tx block re-orged         |           |\n//!                     +-----------+                             +-----------+\n//!                         |                                         |\n//!                         |  TTL expired                            |  TTL expired\n//!                         v                                         v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Received**: the message is stored but its originating transaction has not been found onchain yet (or the\n//!   message is tx-less; see below). While the reception process is in this state, it keeps looking for the\n//    transaction onchain.\n//! - **Processed**: the message has been handed off for processing. If there weren't reorgs, reaching this state would\n//!   be equivalent to terminating the reception process. Since reorgs are a possibility, this state is not terminal.\n//! - **Terminated**: the message has reached its TTL which means nothing else can be done with it. This is the\n//!   terminal state of this process.\n//!\n//! ## Transitions (each evaluated by [`OffchainReception::step`])\n//!\n//! - **Received -> Processed**: the originating transaction is found onchain. The message (packaged with its\n//!   transaction context) is queued to have its actual contents processed (which can lead for example to the discovery\n//!   of notes and events).\n//! - **Processed -> Received**: the block where the message transaction was originally found is re-orged out.\n//! - **Received -> Terminated**: the message TTL has elapsed (see below), so the message is no longer processable.\n//! - **Processed -> Terminated**: the message TTL has elapsed (see below), so the effects of its processing are\n//!   permanent.\n//!\n//! # Message reception lifecycle and the TTL\n//!\n//! A reception expires once `now > anchor_block_timestamp + MAX_MSG_TTL`, where `MAX_MSG_TTL = MAX_TX_LIFETIME + 2h`.\n//! A transaction anchored at a given block can only be mined within\n//! [`MAX_TX_LIFETIME`](crate::protocol::constants::MAX_TX_LIFETIME) of that block, so once that\n//! window (plus a safety margin of 2 hours) has elapsed the originating transaction can no longer appear, and it is\n//! safe to stop looking for it.\n//!\n//! Already-processed receptions reuse the same TTL: we could instead wait for the block that included the transaction\n//! to finalize, but we currently do not have the primitives to reliably get that information.\n//!\n//! # Current limitations, future plans\n//!\n//! - Tx-less messages never reach `Processed` and are only ever removed by expiry. This will be supported in the\n//!   future.\n//! - Already-processed receptions stay active longer than needed. As discussed, we need access to block finality\n//!   information to properly implement that case, which will be added in the future.\n//!\n//! # Implementation\n//!\n//! [`OffchainReception::init`] creates a [fact collection](crate::facts::FactCollection) of type\n//! `OFFCHAIN_RECEPTION_TYPE_ID`. The fact collection is identified by a hash of the `OffchainMessage` it tracks, which\n//! makes duplicate calls to `init` idempotent.\n//!\n//! Upon reception, an `OFFCHAIN_MESSAGE_RECEIVED` [non-retractable fact](crate::facts::record_non_retractable_fact) is\n//! recorded. The fact's payload is the `OffchainMessage` itself, which persists it to be subsequently processed.\n//! A fact collection with just an `OFFCHAIN_MESSAGE_RECEIVED` fact represents an active reception process in the\n//! RECEIVED state from our state chart above.\n//!\n//! The message reception state machine is driven externally, advancing one step at a time each time\n//! [`OffchainReception::step`] is invoked. [`OffchainReception::step`] implements the rest of the reception state\n//! machine described above.\n//!\n//! When stepping, if the transaction to the message is found onchain, an `OFFCHAIN_MESSAGE_PROCESSED`\n//! [retractable fact](crate::facts::record_retractable_fact) associated to the block where the transaction was found is\n//! recorded.\n//! Note that since this fact is retractable, a reorg dropping said block would result in the fact being automatically\n//! removed by PXE, effectively pushing the reception process back to `RECEIVED` state.\n//!\n//! To determine in which state of the reception process we are we just need to analyze the recorded facts available\n//! in combination with the TTL:\n//!\n//! - If the TTL has elapsed, we reached the end of the process and the [fact collection](crate::facts::FactCollection)\n//! can (and should) be deleted.\n//! - Otherwise:\n//!     - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state and there is nothing to do.\n//!     - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we need to check if the\n//!       message transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition.\n//!\n//! The PROCESSED->RECEIVED transition is transparently handled by PXE: if a re-org caused the message transaction to\n//! fall off the chain, the `OFFCHAIN_MESSAGE_PROCESSED` fact disappears, taking us back to the RECEIVED state.\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    facts::{\n        delete_fact_collection, Fact, FactCollection, get_fact_collection, get_fact_collections_by_type, OriginBlock,\n        record_non_retractable_fact, record_retractable_fact,\n    },\n    messages::processing::{MessageContext, OffchainMessageWithContext},\n    oracle::tx_resolution::ResolvedTx,\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::{poseidon2_hash, sha256_to_field},\n        traits::{Deserialize, Serialize},\n    },\n};\nuse super::OffchainMessage;\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\n/// (7200 == 2 hours)\npub(crate) global MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Fact type id of the fact that stores the offchain message body inside a reception collection.\nglobal OFFCHAIN_MESSAGE_RECEIVED: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_RECEIVED\".as_bytes());\n\n/// Fact type id to mark an offchain message as processed.\n///\n/// A reception is in \"processed state\" exactly when its collection carries a fact of this type.\npub(crate) global OFFCHAIN_MESSAGE_PROCESSED: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_PROCESSED\".as_bytes());\n\n/// Fact-collection type id shared by every offchain message reception in the [fact store](crate::facts).\npub(crate) global OFFCHAIN_RECEPTION_TYPE_ID: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_RECEPTION_TYPE_ID\".as_bytes());\n\n/// A single offchain message reception machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n///\n/// Wraps the fact collection that tracks one message's progress through the reception state machine (see the\n/// [module documentation](super)); the [`OffchainMessage`] it carries is decoded on demand.\n#[derive(Deserialize, Serialize)]\npub(crate) struct OffchainReception {\n    collection: FactCollection,\n}\n\nimpl OffchainReception {\n    /// Initializes a new reception for a freshly received message, in the `Received` state.\n    ///\n    /// Re-initializing the same message is a no-op, which makes redelivery idempotent.\n    pub(crate) unconstrained fn init(contract_address: AztecAddress, message: OffchainMessage) {\n        record_non_retractable_fact(\n            contract_address,\n            message.recipient,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n            OFFCHAIN_MESSAGE_RECEIVED,\n            to_payload(message),\n        );\n    }\n\n    /// Loads every active reception for the given contract and scope, decoding each message body.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<OffchainReception> {\n        get_fact_collections_by_type(contract_address, scope, OFFCHAIN_RECEPTION_TYPE_ID)\n            .map(|collection: FactCollection| OffchainReception { collection })\n    }\n\n    /// Reads and returns the message this reception carries, decoding it from its fact collection.\n    pub(crate) unconstrained fn read_message(self) -> OffchainMessage {\n        let message_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_RECEIVED).unwrap();\n        let n = <OffchainMessage as Deserialize>::N;\n        let mut fields = [0; <OffchainMessage as Deserialize>::N];\n        for i in 0..n {\n            fields[i] = message_fact.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Computes the fact-collection id that identifies a message's reception machine in the [fact store](crate::facts).\n    ///\n    /// The id is a hash of the message, which makes duplicate receptions of the same message collapse onto a single\n    /// reception.\n    pub(crate) fn id_for(message: OffchainMessage) -> Field {\n        poseidon2_hash(message.serialize())\n    }\n\n    /// Returns `true` if a reception for `message` is currently active for the given contract and scope.\n    pub(crate) unconstrained fn is_active(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        get_fact_collection(\n            contract_address,\n            scope,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        )\n            .is_some()\n    }\n\n    /// Advances this reception by one step of its state machine. See the [module documentation](super) for the\n    /// states, transitions, and expiry rules.\n    ///\n    /// Returns `Some` with the message and its resolved context when this step determines the message is ready to be\n    /// processed.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_resolved_tx: Option<ResolvedTx>,\n        now: u64,\n    ) -> Option<OffchainMessageWithContext> {\n        // TODO(@mverzilli): we could annotate retractable facts as \"final\" when their corresponding blocks are below\n        // the final tip. Then we could use that as termination condition instead of relying on timestamp arithmetics.\n        let message = self.read_message();\n        let expired = now > message.anchor_block_timestamp + MAX_MSG_TTL;\n        let already_processed = self.collection.facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n        if !already_processed & maybe_resolved_tx.is_some() {\n            let resolved = maybe_resolved_tx.unwrap();\n            self.mark_processed(resolved.block_number, resolved.block_hash);\n            let message_context = MessageContext {\n                tx_hash: resolved.tx_hash,\n                unique_note_hashes_in_tx: resolved.unique_note_hashes_in_tx,\n                first_nullifier_in_tx: resolved.first_nullifier_in_tx,\n            };\n            Option::some(\n                OffchainMessageWithContext { message_ciphertext: message.ciphertext, message_context },\n            )\n        } else if expired {\n            self.terminate();\n            Option::none()\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `true` if the reception for `message` has been marked processed.\n    pub(crate) unconstrained fn is_processed(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        let maybe_collection = get_fact_collection(\n            contract_address,\n            scope,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        );\n        if maybe_collection.is_some() {\n            maybe_collection.unwrap().facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED)\n        } else {\n            false\n        }\n    }\n\n    /// Records the retractable processed marker for this reception, originated at the resolved block.\n    unconstrained fn mark_processed(self, block_number: u32, block_hash: Field) {\n        let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n        record_retractable_fact(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n            OFFCHAIN_MESSAGE_PROCESSED,\n            empty_payload,\n            OriginBlock { block_number, block_hash },\n        );\n    }\n\n    /// Terminates this reception by deleting its [fact collection](crate::facts::FactCollection).\n    unconstrained fn terminate(self) {\n        delete_fact_collection(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n        );\n    }\n}\n\n/// Serializes an [`OffchainMessage`] into a fact payload.\nunconstrained fn to_payload(message: OffchainMessage) -> EphemeralArray<Field> {\n    let fields = message.serialize();\n    let payload: EphemeralArray<Field> = EphemeralArray::empty();\n    for i in 0..fields.len() {\n        payload.push(fields[i]);\n    }\n    payload\n}\n\nmod test {\n    use crate::{\n        messages::processing::offchain::OffchainMessage,\n        oracle::{random::random, tx_resolution::ResolvedTx},\n        protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Builds the resolved-tx context PXE would return for `tx_hash`.\n    fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n        ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: BoundedVec::new(),\n            first_nullifier_in_tx: 0,\n            block_number: 1,\n            block_hash: 0,\n        }\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_terminated() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Past the TTL with no resolved tx: the reception is terminated.\n            assert(reception.step(Option::none(), MAX_MSG_TTL + 1).is_none());\n            assert(!OffchainReception::is_active(address, scope, msg), \"expired reception should be terminated\");\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_reception_stays_active() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Within the TTL with no resolved tx: nothing to process, the reception stays.\n            assert(reception.step(Option::none(), 100).is_none());\n            assert(OffchainReception::is_active(address, scope, msg), \"unresolved reception should stay active\");\n            assert(!OffchainReception::is_processed(address, scope, msg), \"should still be unprocessed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn resolved_reception_is_ready_to_process() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // A resolved tx within the TTL: the message is handed off with its tx context attached.\n            let processable = reception.step(Option::some(resolved_tx(tx_hash)), 100);\n            assert(processable.is_some());\n            assert_eq(processable.unwrap().message_context.tx_hash, tx_hash);\n\n            // It stays active for reorg safety and is now marked processed.\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should stay active\");\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn already_processed_reception_is_not_re_pushed() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // First step processes the message.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Second step (still resolved, not expired) recognizes it as processed and does not re-push it.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none(), \"already processed\");\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n        });\n    }\n\n    #[test]\n    unconstrained fn expired_resolved_reception_is_processed_once_before_termination() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // Expired but resolved: the message is processed once (not terminated yet).\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Next step: still expired and now processed, so the reception is terminated.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_none());\n            assert(\n                !OffchainReception::is_active(address, scope, msg),\n                \"expired processed reception is terminated on the next step\",\n            );\n        });\n    }\n}\n"
     },
     "17": {
       "function_locations": [
@@ -898,7 +964,7 @@
       "path": "std/hash/mod.nr",
       "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A> Hash for (A,)\nwhere\n    A: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_> Hash for (A, B, C, D, E, F, G, H_)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I> Hash for (A, B, C, D, E, F, G, H_, I)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J> Hash for (A, B, C, D, E, F, G, H_, I, J)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K> Hash for (A, B, C, D, E, F, G, H_, I, J, K)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K, L> Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n    L: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n        self.11.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n        },\n    );\n}\n"
     },
-    "180": {
+    "184": {
       "function_locations": [
         {
           "name": "get_auth_witness_oracle",
@@ -924,21 +990,21 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/auth_witness.nr",
       "source": "#[oracle(aztec_utl_getAuthWitness)]\nunconstrained fn get_auth_witness_oracle<let N: u32>(_message_hash: Field) -> [Field; N] {}\n\n/// Oracle wrapper to fetch an `auth_witness` for a given `message_hash` from the PXE.\npub unconstrained fn get_auth_witness<let N: u32>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n\n/// Fetches an auth witness and casts each field to a byte.\n///\n/// Each field is range-checked to `[0, 256)` before casting to prevent silent truncation (e.g. a field value of\n/// `b + 256` would truncate to the same byte as `b`).\npub unconstrained fn get_auth_witness_as_bytes<let N: u32>(message_hash: Field) -> [u8; N] {\n    let witness = get_auth_witness::<N>(message_hash);\n    let mut result: [u8; N] = [0; N];\n    for i in 0..N {\n        assert(witness[i].lt(256), \"auth witness field is not a single byte\");\n        result[i] = witness[i] as u8;\n    }\n    result\n}\n\nmod test {\n    use super::get_auth_witness_as_bytes;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn get_auth_witness_as_bytes_casts_valid_witness() {\n        let witness: [Field; 3] = [0, 127, 255];\n        let _ = OracleMock::mock(\"aztec_utl_getAuthWitness\").returns(witness);\n        let bytes: [u8; 3] = get_auth_witness_as_bytes(0);\n        assert_eq(bytes, [0, 127, 255]);\n    }\n\n    #[test(should_fail_with = \"auth witness field is not a single byte\")]\n    unconstrained fn get_auth_witness_as_bytes_rejects_field_above_byte_range() {\n        let witness: [Field; 1] = [256];\n        let _ = OracleMock::mock(\"aztec_utl_getAuthWitness\").returns(witness);\n        let _: [u8; 1] = get_auth_witness_as_bytes(0);\n    }\n}\n"
     },
-    "183": {
+    "187": {
       "function_locations": [
         {
           "name": "call_private_function_oracle",
-          "start": 383
+          "start": 362
         },
         {
           "name": "call_private_function_internal",
-          "start": 619
+          "start": 598
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
-      "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader};\n\n#[oracle(aztec_prv_callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
+      "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(aztec_prv_callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> (u32, Field) {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    )\n}\n"
     },
-    "185": {
+    "189": {
       "function_locations": [
         {
           "name": "store",
@@ -1032,7 +1098,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\n// TODO(F-498): review naming consistency\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T, scope: AztecAddress)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    set_capsule_oracle(contract_address, slot, serialized, scope);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns\n/// Option::none() if nothing was stored at the given slot.\n// TODO(F-498): review naming consistency\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field, scope: AztecAddress) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = get_capsule_oracle(contract_address, slot, <T as Deserialize>::N, scope);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field, scope: AztecAddress) {\n    delete_oracle(contract_address, slot, scope);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`. Supports overlapping source and\n/// destination regions (which will result in the overlapped source values being overwritten). All copied slots must\n/// exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n    scope: AztecAddress,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries, scope);\n}\n\n#[oracle(aztec_utl_setCapsule)]\nunconstrained fn set_capsule_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n    scope: AztecAddress,\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the\n/// expected shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(aztec_utl_getCapsule)]\nunconstrained fn get_capsule_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n    scope: AztecAddress,\n) -> Option<[Field; N]> {}\n\n#[oracle(aztec_utl_deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field, scope: AztecAddress) {}\n\n#[oracle(aztec_utl_copyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n    scope: AztecAddress,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::MockStruct},\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n\n            assert_eq(load(contract_address, SLOT, scope).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value, scope);\n\n            assert_eq(load(contract_address, SLOT, scope).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value, scope);\n            delete(contract_address, SLOT, scope);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT, scope);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT, scope);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src, scope).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1, scope).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2, scope).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0], scope);\n            store(contract_address, src + 1, values[1], scope);\n            store(contract_address, src + 2, values[2], scope);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3, scope);\n\n            assert_eq(load(contract_address, dst, scope).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1, scope).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2, scope).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src, scope).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1, scope).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2, scope).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0, scope);\n        });\n    }\n}\n"
     },
-    "186": {
+    "190": {
       "function_locations": [
         {
           "name": "set_contract_sync_cache_invalid_oracle",
@@ -1046,7 +1112,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/contract_sync.nr",
       "source": "use crate::protocol::address::AztecAddress;\n\n#[oracle(aztec_utl_setContractSyncCacheInvalid)]\nunconstrained fn set_contract_sync_cache_invalid_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    scopes: BoundedVec<AztecAddress, N>,\n) {}\n\n/// Forces the PXE to re-sync the given contract for a set of scopes on the next query.\n///\n/// Call this after writing data (e.g. offchain messages) that the contract's `sync_state` function needs to discover.\n/// Without invalidation, the sync cache would skip re-running `sync_state` until the next block.\npub unconstrained fn set_contract_sync_cache_invalid<let N: u32>(\n    contract_address: AztecAddress,\n    scopes: BoundedVec<AztecAddress, N>,\n) {\n    set_contract_sync_cache_invalid_oracle(contract_address, scopes);\n}\n"
     },
-    "188": {
+    "192": {
       "function_locations": [
         {
           "name": "get_utility_context_oracle",
@@ -1060,7 +1126,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use crate::context::UtilityContext;\n\n#[oracle(aztec_utl_getUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContext {}\n\n/// Returns a utility context built from the global variables of anchor block and the contract address of the function\n/// being executed.\npub unconstrained fn get_utility_context() -> UtilityContext {\n    get_utility_context_oracle()\n}\n"
     },
-    "189": {
+    "193": {
       "function_locations": [
         {
           "name": "store",
@@ -1086,7 +1152,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\n// TODO(F-498): review naming consistency\npub fn store<let N: u32>(values: [Field; N], hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { set_hash_preimage_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn set_hash_preimage_oracle_wrapper<let N: u32>(values: [Field; N], hash: Field) {\n    set_hash_preimage_oracle(values, hash);\n}\n\n// TODO(F-498): review naming consistency\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    get_hash_preimage_oracle(hash)\n}\n\n#[oracle(aztec_prv_setHashPreimage)]\nunconstrained fn set_hash_preimage_oracle<let N: u32>(_values: [Field; N], _hash: Field) {}\n\n#[oracle(aztec_prv_getHashPreimage)]\nunconstrained fn get_hash_preimage_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "190": {
+    "195": {
       "function_locations": [
         {
           "name": "get_contract_instance_oracle",
@@ -1098,61 +1164,61 @@
         },
         {
           "name": "get_contract_instance",
-          "start": 614
+          "start": 619
         },
         {
           "name": "get_contract_instance_deployer_oracle_avm",
-          "start": 1296
+          "start": 1301
         },
         {
-          "name": "get_contract_instance_class_id_oracle_avm",
-          "start": 1464
+          "name": "get_contract_instance_current_class_id_oracle_avm",
+          "start": 1484
         },
         {
           "name": "get_contract_instance_initialization_hash_oracle_avm",
-          "start": 1661
+          "start": 1681
         },
         {
           "name": "get_contract_instance_immutables_hash_oracle_avm",
-          "start": 1850
+          "start": 1870
         },
         {
           "name": "get_contract_instance_deployer_internal_avm",
-          "start": 1972
+          "start": 1992
         },
         {
-          "name": "get_contract_instance_class_id_internal_avm",
-          "start": 2149
+          "name": "get_contract_instance_current_class_id_internal_avm",
+          "start": 2184
         },
         {
           "name": "get_contract_instance_initialization_hash_internal_avm",
-          "start": 2344
+          "start": 2387
         },
         {
           "name": "get_contract_instance_immutables_hash_internal_avm",
-          "start": 2546
+          "start": 2589
         },
         {
           "name": "get_contract_instance_deployer_avm",
-          "start": 2702
+          "start": 2745
         },
         {
-          "name": "get_contract_instance_class_id_avm",
-          "start": 3103
+          "name": "get_contract_instance_current_class_id_avm",
+          "start": 3563
         },
         {
           "name": "get_contract_instance_initialization_hash_avm",
-          "start": 3508
+          "start": 3976
         },
         {
           "name": "get_contract_instance_immutables_hash_avm",
-          "start": 3891
+          "start": 4359
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr",
-      "source": "use crate::protocol::{\n    address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance, traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(aztec_utl_getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n    get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n    // Safety: The to_address function combines all values in the instance object to produce an address, so by checking\n    // that we get the expected address we validate the entire struct.\n    let instance = unsafe { get_contract_instance_internal(address) };\n    assert_eq(instance.to_address(), address);\n\n    instance\n}\n\nstruct GetContractInstanceResult {\n    exists: bool,\n    member: Field,\n}\n\n// These oracles each return a ContractInstance member plus a boolean indicating whether the instance was found.\n#[oracle(aztec_avm_getContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(_address: AztecAddress) -> [GetContractInstanceResult; 1] {}\n#[oracle(aztec_avm_getContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(_address: AztecAddress) -> [GetContractInstanceResult; 1] {}\n#[oracle(aztec_avm_getContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n    _address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {}\n#[oracle(aztec_avm_getContractInstanceImmutablesHash)]\nunconstrained fn get_contract_instance_immutables_hash_oracle_avm(\n    _address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {}\n\nunconstrained fn get_contract_instance_deployer_internal_avm(address: AztecAddress) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_deployer_oracle_avm(address)\n}\nunconstrained fn get_contract_instance_class_id_internal_avm(address: AztecAddress) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_class_id_oracle_avm(address)\n}\nunconstrained fn get_contract_instance_initialization_hash_internal_avm(\n    address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_initialization_hash_oracle_avm(address)\n}\nunconstrained fn get_contract_instance_immutables_hash_internal_avm(\n    address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_immutables_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option<AztecAddress> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_deployer_internal_avm(address)[0] };\n    if exists {\n        Option::some(AztecAddress::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option<ContractClassId> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_class_id_internal_avm(address)[0] };\n    if exists {\n        Option::some(ContractClassId::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option<Field> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_initialization_hash_internal_avm(address)[0] };\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_immutables_hash_avm(address: AztecAddress) -> Option<Field> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_immutables_hash_internal_avm(address)[0] };\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
+      "source": "use crate::protocol::{\n    address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance, traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(aztec_utl_getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n    get_contract_instance_oracle(address)\n}\n\n/// Returns `address`'s [`ContractInstance`].\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n    // Safety: The to_address function combines all values in the instance object to produce an address, so by checking\n    // that we get the expected address we validate the entire struct.\n    let instance = unsafe { get_contract_instance_internal(address) };\n    assert_eq(instance.to_address(), address);\n\n    instance\n}\n\nstruct GetContractInstanceResult {\n    exists: bool,\n    member: Field,\n}\n\n// These oracles each return a ContractInstance member plus a boolean indicating whether the instance was found.\n#[oracle(aztec_avm_getContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(_address: AztecAddress) -> [GetContractInstanceResult; 1] {}\n#[oracle(aztec_avm_getContractInstanceClassId)]\nunconstrained fn get_contract_instance_current_class_id_oracle_avm(\n    _address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {}\n#[oracle(aztec_avm_getContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n    _address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {}\n#[oracle(aztec_avm_getContractInstanceImmutablesHash)]\nunconstrained fn get_contract_instance_immutables_hash_oracle_avm(\n    _address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {}\n\nunconstrained fn get_contract_instance_deployer_internal_avm(address: AztecAddress) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_deployer_oracle_avm(address)\n}\nunconstrained fn get_contract_instance_current_class_id_internal_avm(\n    address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_current_class_id_oracle_avm(address)\n}\nunconstrained fn get_contract_instance_initialization_hash_internal_avm(\n    address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_initialization_hash_oracle_avm(address)\n}\nunconstrained fn get_contract_instance_immutables_hash_internal_avm(\n    address: AztecAddress,\n) -> [GetContractInstanceResult; 1] {\n    get_contract_instance_immutables_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option<AztecAddress> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_deployer_internal_avm(address)[0] };\n    if exists {\n        Option::some(AztecAddress::from_field(member))\n    } else {\n        Option::none()\n    }\n}\n/// Returns `address` current contract class, or `Option::none` if unpublished.\n///\n/// The current contract class is the one that would be used to determine the code of the contract's functions if it\n/// were to be executed in this transaction. This is not necessarily the contract's original class if it has been\n/// upgraded via the `ContractInstanceRegistry`, and it could similarly change in the future.\npub fn get_contract_instance_current_class_id_avm(address: AztecAddress) -> Option<ContractClassId> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_current_class_id_internal_avm(address)[0] };\n    if exists {\n        Option::some(ContractClassId::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option<Field> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_initialization_hash_internal_avm(address)[0] };\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_immutables_hash_avm(address: AztecAddress) -> Option<Field> {\n    // Safety: AVM opcodes are constrained by the AVM itself\n    let GetContractInstanceResult { exists, member } =\n        unsafe { get_contract_instance_immutables_hash_internal_avm(address)[0] };\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
     },
-    "193": {
+    "198": {
       "function_locations": [
         {
           "name": "get_low_nullifier_membership_witness_oracle",
@@ -1174,7 +1240,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_nullifier_membership_witness.nr",
       "source": "use crate::protocol::{\n    abis::{block_header::BlockHeader, nullifier_leaf_preimage::NullifierLeafPreimage},\n    constants::NULLIFIER_TREE_HEIGHT,\n    merkle_tree::MembershipWitness,\n    traits::Hash,\n};\n\n#[oracle(aztec_utl_getLowNullifierMembershipWitness)]\nunconstrained fn get_low_nullifier_membership_witness_oracle(\n    _block_hash: Field,\n    _nullifier: Field,\n) -> (NullifierLeafPreimage, MembershipWitness<NULLIFIER_TREE_HEIGHT>) {}\n\n/// Returns a leaf preimage and membership witness for the low nullifier of `nullifier` in the nullifier tree whose\n/// root is defined in `block_header`.\n///\n/// The low nullifier is the leaf with the largest value that is still smaller than `nullifier`. This is used to prove\n/// non-inclusion: if the low nullifier's `next_value` is greater than `nullifier`, then `nullifier` is not in the\n/// tree.\npub unconstrained fn get_low_nullifier_membership_witness(\n    block_header: BlockHeader,\n    nullifier: Field,\n) -> (NullifierLeafPreimage, MembershipWitness<NULLIFIER_TREE_HEIGHT>) {\n    let block_hash = block_header.hash();\n    get_low_nullifier_membership_witness_oracle(block_hash, nullifier)\n}\n\n#[oracle(aztec_utl_getNullifierMembershipWitness)]\nunconstrained fn get_nullifier_membership_witness_oracle(\n    _block_hash: Field,\n    _nullifier: Field,\n) -> (NullifierLeafPreimage, MembershipWitness<NULLIFIER_TREE_HEIGHT>) {}\n\n/// Returns a leaf preimage and membership witness for `nullifier` in the nullifier tree whose root is defined in\n/// `block_header`.\n///\n/// This is used to prove that a nullifier exists in the tree (inclusion proof).\npub unconstrained fn get_nullifier_membership_witness(\n    block_header: BlockHeader,\n    nullifier: Field,\n) -> (NullifierLeafPreimage, MembershipWitness<NULLIFIER_TREE_HEIGHT>) {\n    let block_hash = block_header.hash();\n    get_nullifier_membership_witness_oracle(block_hash, nullifier)\n}\n"
     },
-    "201": {
+    "206": {
       "function_locations": [
         {
           "name": "notify_created_nullifier",
@@ -1204,7 +1270,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/nullifiers.nr",
       "source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns `true` if the nullifier has been emitted in the same transaction, i.e. if [`notify_created_nullifier`] has\n/// been\n/// called for this inner nullifier from the contract with the specified address.\n///\n/// Note that despite sharing pending transaction information with the app, this is not a privacy leak: anyone in the\n/// network can always determine in which transaction a inner nullifier was emitted by a given contract by simply\n/// inspecting transaction effects. What _would_ constitute a leak would be to share the list of inner pending\n/// nullifiers, as that would reveal their preimages.\npub unconstrained fn is_nullifier_pending(inner_nullifier: Field, contract_address: AztecAddress) -> bool {\n    is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(_inner_nullifier: Field, _contract_address: AztecAddress) -> bool {}\n\n/// Returns `true` if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before\n/// the current transaction is included in a block. While this might seem of little use at first, certain design\n/// patterns benefit from this abstraction (see e.g. `PrivateMutable`).\n// TODO(F-498): review naming consistency\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    does_nullifier_exist_oracle(inner_nullifier)\n}\n\n#[oracle(aztec_utl_doesNullifierExist)]\nunconstrained fn does_nullifier_exist_oracle(_inner_nullifier: Field) -> bool {}\n"
     },
-    "203": {
+    "208": {
       "function_locations": [
         {
           "name": "assert_valid_public_call_data",
@@ -1222,7 +1288,21 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/public_call.nr",
       "source": "/// Validates public calldata by checking that the preimage exists and the cumulative size is within limits.\n///\n/// The check is unconstrained and the only purpose of it is to fail early in case of calldata overflow or a bug in\n/// calldata hashing.\npub(crate) fn assert_valid_public_call_data(calldata_hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects (validating the calldata).\n    // It is therefore always safe to call.\n    unsafe {\n        assert_valid_public_call_data_oracle_wrapper(calldata_hash)\n    }\n}\n\nunconstrained fn assert_valid_public_call_data_oracle_wrapper(calldata_hash: Field) {\n    assert_valid_public_call_data_oracle(calldata_hash)\n}\n\n#[oracle(aztec_prv_assertValidPublicCalldata)]\nunconstrained fn assert_valid_public_call_data_oracle(_calldata_hash: Field) {}\n"
     },
-    "208": {
+    "209": {
+      "function_locations": [
+        {
+          "name": "random",
+          "start": 468
+        },
+        {
+          "name": "rand_oracle",
+          "start": 568
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
+      "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values. In some applications this\n/// behavior might not be acceptable and other techniques might be more suitable, such as producing pseudo-random\n/// values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n    rand_oracle()\n}\n\n#[oracle(aztec_misc_getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
+    },
+    "214": {
       "function_locations": [
         {
           "name": "notify_revertible_phase_start",
@@ -1248,7 +1328,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/tx_phase.nr",
       "source": "/// Notifies PXE of the side effect counter at which the revertible phase begins.\n///\n/// PXE uses it to classify notes and nullifiers as revertible or non-revertible in its note cache. This information is\n/// then fed to kernels as hints.\npub(crate) fn notify_revertible_phase_start(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_revertible_phase_start_oracle_wrapper(counter) };\n}\n\n/// Returns whether a side effect counter falls in the revertible phase of the transaction.\npub(crate) unconstrained fn is_execution_in_revertible_phase(current_counter: u32) -> bool {\n    is_execution_in_revertible_phase_oracle(current_counter)\n}\n\nunconstrained fn notify_revertible_phase_start_oracle_wrapper(counter: u32) {\n    notify_revertible_phase_start_oracle(counter);\n}\n\n#[oracle(aztec_prv_notifyRevertiblePhaseStart)]\nunconstrained fn notify_revertible_phase_start_oracle(_counter: u32) {}\n\n#[oracle(aztec_prv_isExecutionInRevertiblePhase)]\nunconstrained fn is_execution_in_revertible_phase_oracle(current_counter: u32) -> bool {}\n"
     },
-    "209": {
+    "216": {
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
@@ -1272,91 +1352,119 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
-      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 29;\npub global ORACLE_VERSION_MINOR: Field = 1;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
+      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 30;\npub global ORACLE_VERSION_MINOR: Field = 1;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
     },
-    "283": {
+    "269": {
       "function_locations": [
         {
-          "name": "Poseidon2::hash",
-          "start": 333
+          "name": "UnconstrainedArray<T, Oracle>::at",
+          "start": 3001
         },
         {
-          "name": "Poseidon2::new",
-          "start": 442
+          "name": "UnconstrainedArray<T, Oracle>::empty_at",
+          "start": 3363
         },
         {
-          "name": "Poseidon2::perform_duplex",
-          "start": 649
+          "name": "UnconstrainedArray<T, Oracle>::empty",
+          "start": 3834
         },
         {
-          "name": "Poseidon2::absorb",
-          "start": 923
+          "name": "UnconstrainedArray<T, Oracle>::len",
+          "start": 3972
         },
         {
-          "name": "Poseidon2::squeeze",
-          "start": 1453
+          "name": "UnconstrainedArray<T, Oracle>::push",
+          "start": 4149
         },
         {
-          "name": "Poseidon2::hash_internal",
-          "start": 1814
+          "name": "UnconstrainedArray<T, Oracle>::pop",
+          "start": 4444
         },
         {
-          "name": "<impl Hasher for Poseidon2Hasher>::finish",
-          "start": 4105
+          "name": "UnconstrainedArray<T, Oracle>::get",
+          "start": 4757
         },
         {
-          "name": "<impl Hasher for Poseidon2Hasher>::write",
-          "start": 4426
+          "name": "UnconstrainedArray<T, Oracle>::set",
+          "start": 5081
         },
         {
-          "name": "<impl Default for Poseidon2Hasher>::default",
-          "start": 4549
+          "name": "UnconstrainedArray<T, Oracle>::remove",
+          "start": 5395
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::clear",
+          "start": 5573
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::for_each",
+          "start": 6201
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::map",
+          "start": 6555
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::filter",
+          "start": 6975
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::any",
+          "start": 7435
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::all",
+          "start": 7720
+        },
+        {
+          "name": "UnconstrainedArray<T, Oracle>::find",
+          "start": 7995
         }
       ],
-      "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"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/unconstrained_array/mod.nr",
+      "source": "pub(crate) mod test_helpers;\npub(crate) mod test_suite;\n\nuse crate::oracle::random::random;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\n/// Oracle backend for an [`UnconstrainedArray`]: the set of PXE-side operations that implement its storage.\n///\n/// Each implementor routes these operations to a distinct family of oracles, and the oracle family determines the\n/// array's lifetime and visibility (e.g. [`EphemeralArray`](crate::ephemeral::EphemeralArray) arrays live for one\n/// contract call frame, while [`TransientArray`](crate::transient::TransientArray) arrays are shared across all frames\n/// of the same contract within one top-level PXE call).\npub(crate) trait ArrayOracles {\n    /// Returns the number of elements in the array at `slot`.\n    unconstrained fn len_oracle(slot: Field) -> u32;\n\n    /// Appends a serialized element to the array at `slot` and returns the new length.\n    unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32;\n\n    /// Removes and returns the last serialized element of the array at `slot`. Implementors must panic if the\n    /// array is empty.\n    unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N];\n\n    /// Returns the serialized element at the given index of the array at `slot`. Implementors must panic if `index`\n    /// is out of bounds.\n    unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N];\n\n    /// Overwrites the serialized element at the given index of the array at `slot`. Implementors must panic if\n    /// `index` is out of bounds.\n    unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]);\n\n    /// Removes the element at the given index of the array at `slot`, shifting subsequent elements backward.\n    /// Implementors must panic if `index` is out of bounds.\n    unconstrained fn remove_oracle(slot: Field, index: u32);\n\n    /// Removes all elements from the array at `slot`.\n    unconstrained fn clear_oracle(slot: Field);\n}\n\n/// A dynamically sized array backed by PXE-side in-memory storage via an [`ArrayOracles`] backend.\n///\n/// Arrays are identified by a slot, and each logical operation (push, pop, get, etc.) is a single oracle call. The\n/// `Oracle` backend determines the array's lifetime and visibility; contracts should not use this type directly but\n/// rather one of its aliases: [`EphemeralArray`](crate::ephemeral::EphemeralArray) (scoped to a single contract call\n/// frame) or [`TransientArray`](crate::transient::TransientArray) (shared across all frames of the same contract\n/// within one top-level PXE call).\npub struct UnconstrainedArray<T, Oracle> {\n    pub(crate) slot: Field,\n}\n\nimpl<T, Oracle> UnconstrainedArray<T, Oracle>\nwhere\n    Oracle: ArrayOracles,\n{\n    /// Returns a handle to the array at the given slot, which may already contain data (e.g. populated by an oracle\n    /// or by an earlier frame, depending on the backend's visibility).\n    pub unconstrained fn at(slot: Field) -> Self {\n        Self { slot }\n    }\n\n    /// Returns an empty array at the given slot, clearing any pre-existing data.\n    ///\n    /// For backends whose arrays are visible beyond a single call frame (e.g. transient arrays), this wipes data\n    /// other frames of the same contract may have written at the slot.\n    pub unconstrained fn empty_at(slot: Field) -> Self {\n        Self::at(slot).clear()\n    }\n\n    /// Returns an empty array at a fresh, randomly allocated slot.\n    ///\n    /// Use this when the caller does not need a specific slot: the random slot is isolated from every other array of\n    /// the same backend with overwhelming probability. Prefer [`UnconstrainedArray::empty_at`] when the slot must be a\n    /// known value (e.g. one shared with an oracle or another call frame).\n    pub unconstrained fn empty() -> Self {\n        Self::at(random())\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        Oracle::len_oracle(self.slot)\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        let _ = Oracle::push_oracle(self.slot, serialized);\n    }\n\n    /// Removes and returns the last element. Implementors are required to panic if the array is empty.\n    pub unconstrained fn pop(self) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::pop_oracle(self.slot);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Retrieves the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::get_oracle(self.slot, index);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Overwrites the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn set(self, index: u32, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        Oracle::set_oracle(self.slot, index, serialized);\n    }\n\n    /// Removes the element at `index`, shifting subsequent elements backward. Implementors are required to panic if\n    /// the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        Oracle::remove_oracle(self.slot, index);\n    }\n\n    /// Removes all elements from the array and returns self for chaining.\n    pub unconstrained fn clear(self) -> Self {\n        Oracle::clear_oracle(self.slot);\n        self\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index, in order (from the first\n    /// element to the last).\n    ///\n    /// Structurally mutating the array from inside the callback (e.g. via `push`, `pop`, `remove` or `clear`) is\n    /// **not** supported: it can cause elements to be skipped, visited more than once, or read out of bounds.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        for i in 0..n {\n            f(i, self.get(i));\n        }\n    }\n\n    /// Applies `f` to every element and collects the results into a fresh array.\n    pub unconstrained fn map<U, Env>(self, f: unconstrained fn[Env](T) -> U) -> UnconstrainedArray<U, Oracle>\n    where\n        T: Deserialize,\n        U: Serialize,\n    {\n        let dest: UnconstrainedArray<U, Oracle> = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            dest.push(f(self.get(i)));\n        }\n        dest\n    }\n\n    /// Collects every element satisfying the predicate `f` into a fresh array.\n    pub unconstrained fn filter<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Self\n    where\n        T: Serialize + Deserialize,\n    {\n        let dest: Self = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            let value = self.get(i);\n            if f(value) {\n                dest.push(value);\n            }\n        }\n        dest\n    }\n\n    /// Returns `true` if at least one element satisfies the predicate `f`.\n    pub unconstrained fn any<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() != 0\n    }\n\n    /// Returns `true` if every element satisfies the predicate `f` (vacuously `true` for an empty array).\n    pub unconstrained fn all<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() == self.len()\n    }\n\n    /// Returns the first element satisfying the predicate `f`, or `Option::none` if none do.\n    pub unconstrained fn find<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Option<T>\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        let mut result: Option<T> = Option::none();\n        let mut i = 0;\n        while (i < n) & result.is_none() {\n            let value = self.get(i);\n            if f(value) {\n                result = Option::some(value);\n            }\n            i += 1;\n        }\n        result\n    }\n}\n"
     },
-    "294": {
+    "293": {
       "function_locations": [
         {
-          "name": "BlockHeader::chain_id",
-          "start": 1262
+          "name": "Poseidon2::hash",
+          "start": 333
         },
         {
-          "name": "BlockHeader::version",
-          "start": 1344
+          "name": "Poseidon2::new",
+          "start": 442
         },
         {
-          "name": "BlockHeader::block_number",
-          "start": 1428
+          "name": "Poseidon2::perform_duplex",
+          "start": 649
         },
         {
-          "name": "BlockHeader::timestamp",
-          "start": 1514
+          "name": "Poseidon2::absorb",
+          "start": 923
         },
         {
-          "name": "<impl Empty for BlockHeader>::empty",
-          "start": 1617
+          "name": "Poseidon2::squeeze",
+          "start": 1453
         },
         {
-          "name": "<impl Hash for BlockHeader>::hash",
-          "start": 1959
+          "name": "Poseidon2::hash_internal",
+          "start": 1814
         },
         {
-          "name": "serialization_of_empty",
-          "start": 2090
+          "name": "<impl Hasher for Poseidon2Hasher>::finish",
+          "start": 4105
         },
         {
-          "name": "hash_of_genesis_block_header",
-          "start": 2490
+          "name": "<impl Hasher for Poseidon2Hasher>::write",
+          "start": 4426
         },
         {
-          "name": "hash_of_empty_block_header_match_typescript",
-          "start": 3427
+          "name": "<impl Default for Poseidon2Hasher>::default",
+          "start": 4549
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_header.nr",
-      "source": "use crate::{\n    abis::{\n        append_only_tree_snapshot::AppendOnlyTreeSnapshot, global_variables::GlobalVariables,\n        state_reference::StateReference,\n    },\n    constants::{BLOCK_HEADER_LENGTH, DOM_SEP__BLOCK_HEADER_HASH, GENESIS_BLOCK_HEADER_HASH},\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Empty, Hash, Serialize},\n};\nuse std::meta::derive;\n\n// docs:start:block-header\n#[derive(Deserialize, Eq, Serialize)]\npub struct BlockHeader {\n    pub last_archive: AppendOnlyTreeSnapshot,\n    pub state: StateReference,\n\n    // The hash of the sponge blob for this block, which commits to the tx effects added in this block.\n    // Note: it may also include tx effects from previous blocks within the same checkpoint.\n    // When proving tx effects from this block only, we must refer to the `sponge_blob_hash` in the previous block\n    // header to show that the effect was added after the previous block.\n    // The previous block header can be validated using a membership proof of the last leaf in `last_archive`.\n    pub sponge_blob_hash: Field,\n\n    pub global_variables: GlobalVariables,\n    pub total_fees: Field,\n    pub total_mana_used: Field,\n}\n// docs:end:block-header\n\nimpl BlockHeader {\n    pub fn chain_id(self) -> Field {\n        self.global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.global_variables.version\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.global_variables.block_number\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.global_variables.timestamp\n    }\n}\n\nimpl Empty for BlockHeader {\n    fn empty() -> Self {\n        Self {\n            last_archive: AppendOnlyTreeSnapshot::empty(),\n            state: StateReference::empty(),\n            sponge_blob_hash: 0,\n            global_variables: GlobalVariables::empty(),\n            total_fees: 0,\n            total_mana_used: 0,\n        }\n    }\n}\n\nimpl Hash for BlockHeader {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), DOM_SEP__BLOCK_HEADER_HASH)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let header = BlockHeader::empty();\n    // We use the BLOCK_HEADER_LENGTH constant to ensure that there is a match\n    // between the derived trait implementation and the constant.\n    let serialized: [Field; BLOCK_HEADER_LENGTH] = header.serialize();\n    let deserialized = BlockHeader::deserialize(serialized);\n    assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_of_genesis_block_header() {\n    let mut header = BlockHeader::empty();\n    // The following values are taken from world_state.test.cpp > WorldStateTest.GetInitialTreeInfoForAllTrees.\n    header.state.l1_to_l2_message_tree.root =\n        0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a;\n    header.state.partial.note_hash_tree.root =\n        0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6;\n    header.state.partial.nullifier_tree.root =\n        0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454;\n    header.state.partial.nullifier_tree.next_available_leaf_index = 128;\n    header.state.partial.public_data_tree.root =\n        0x1bef38b621017d3c7416663d0cd81369424560710526a3fbaaec13e356b9d084;\n    header.state.partial.public_data_tree.next_available_leaf_index = 128;\n\n    let hash = header.hash();\n    assert_eq(hash, GENESIS_BLOCK_HEADER_HASH);\n}\n\n#[test]\nfn hash_of_empty_block_header_match_typescript() {\n    let header = BlockHeader::empty();\n    let hash = header.hash();\n\n    // Value from block_header.test.ts \"computes empty hash\" test\n    let test_data_empty_hash = 0x0bdc537052dea0f80db9698585dff9f32063b86b6d4934ac17c30c81e8e416d3;\n    assert_eq(hash, test_data_empty_hash);\n}\n"
+      "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"
     },
     "3": {
       "function_locations": [
@@ -1536,7 +1644,49 @@
       "path": "std/array/mod.nr",
       "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a vector.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let vector = array.as_vector();\n    /// assert_eq(vector, [1, 2].as_vector());\n    /// ```\n    #[builtin(as_vector)]\n    pub fn as_vector(self) -> [T] {}\n\n    /// Returns this array as a vector.\n    /// This method is deprecated in favor of `as_vector`.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let vector = array.as_slice();\n    /// assert_eq(vector, [1, 2].as_vector());\n    /// ```\n    #[builtin(as_vector)]\n    #[deprecated(\"This method has been renamed to `as_vector`\")]\n    pub fn as_slice(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(&self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array along with its index,\n    /// returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.mapi(|i, a| i + a * 2);\n    /// assert_eq(b, [2, 5, 8]);\n    /// ```\n    pub fn mapi<U, Env>(&self, f: fn[Env](u32, T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(i, self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// let mut i = 0;\n    /// a.for_each(|x| {\n    ///     b[i] = x;\n    ///     i += 1;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_each<Env>(&self, f: fn[Env](T) -> ()) {\n        for i in 0..self.len() {\n            f(self[i]);\n        }\n    }\n\n    /// Applies a function to each element of this array along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// a.for_eachi(|i, x| {\n    ///     b[i] = x;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_eachi<Env>(&self, f: fn[Env](u32, T) -> ()) {\n        for i in 0..self.len() {\n            f(i, self[i]);\n        }\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(&self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(&self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(&self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(&self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n\n    /// Concatenates this array with another array.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr1 = [1, 2, 3, 4];\n    ///     let arr2 = [6, 7, 8, 9, 10, 11];\n    ///     let concatenated_arr = arr1.concat(arr2);\n    ///     assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    /// }\n    /// ```\n    pub fn concat<let M: u32>(&self, array2: [T; M]) -> [T; N + M] {\n        let mut result = [crate::mem::zeroed(); N + M];\n        for i in 0..N {\n            result[i] = self[i];\n        }\n        for i in 0..M {\n            result[i + N] = array2[i];\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the [`Self::sort_via`] function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(&self) -> Self {\n        self.sort_via(|a, b| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(&self, ordering: fn[Env](T, T) -> bool) -> Self {\n        if N != 0 {\n            // Safety: `sorted` array is checked to be:\n            // a. a permutation of `input`'s elements\n            // b. satisfying the predicate `ordering`\n            let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n            if !is_unconstrained() {\n                for i in 0..N - 1 {\n                    assert(\n                        ordering(sorted[i], sorted[i + 1]),\n                        \"Array has not been sorted correctly according to `ordering`.\",\n                    );\n                }\n                check_shuffle::check_shuffle(self, &sorted);\n            }\n            sorted\n        } else {\n            *self\n        }\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n\n    global arr_with_100_values: [u32; 100] = [\n        42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n        89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n        53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n        21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n        125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n    ];\n    global expected_with_100_values: [u32; 100] = [\n        0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n        32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n        62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n        86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n        119, 120, 121, 123, 123, 123, 125, 126, 127,\n    ];\n    fn sort_u32(a: u32, b: u32) -> bool {\n        a <= b\n    }\n\n    #[test]\n    fn test_sort() {\n        let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_empty() {\n        let arr: [u32; 0] = [];\n        let sorted = arr.sort();\n        assert(sorted == arr);\n    }\n\n    #[test]\n    fn test_sort_via_empty() {\n        let arr: [u32; 0] = [];\n        let sorted = arr.sort_via(sort_u32);\n        assert(sorted == arr);\n    }\n\n    #[test]\n    fn test_sort_100_values() {\n        let arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values_comptime() {\n        let sorted = arr_with_100_values.sort();\n        assert(sorted == expected_with_100_values);\n    }\n\n    #[test]\n    fn test_sort_via() {\n        let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_via_100_values() {\n        let arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn mapi_empty() {\n        assert_eq([].mapi(|i, x| i * x + 1), []);\n    }\n\n    #[test]\n    fn for_each_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_each(|_x| assert(false));\n    }\n\n    #[test]\n    fn for_eachi_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_eachi(|_i, _x| assert(false));\n    }\n\n    #[test]\n    fn map_example() {\n        let a = [1, 2, 3];\n        let b = a.map(|a| a * 2);\n        assert_eq(b, [2, 4, 6]);\n    }\n\n    #[test]\n    fn mapi_example() {\n        let a = [1, 2, 3];\n        let b = a.mapi(|i, a| i + a * 2);\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn for_each_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        let mut i = 0;\n        let i_ref = &mut i;\n        a.for_each(|x| {\n            b_ref[*i_ref] = x * 2;\n            *i_ref += 1;\n        });\n        assert_eq(b, [2, 4, 6]);\n        assert_eq(i, 3);\n    }\n\n    #[test]\n    fn for_eachi_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn concat() {\n        let arr1 = [1, 2, 3, 4];\n        let arr2 = [6, 7, 8, 9, 10, 11];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    }\n\n    #[test]\n    fn concat_zero_length_with_something() {\n        let arr1 = [];\n        let arr2 = [1];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_something_with_zero_length() {\n        let arr1 = [1];\n        let arr2 = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_zero_lengths() {\n        let arr1: [Field; 0] = [];\n        let arr2: [Field; 0] = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, []);\n    }\n\n    #[test]\n    fn test_fold() {\n        let array = [1, 2, 3];\n        let sum_plus_10 = array.fold(10, |x, y| x + y);\n        assert_eq(sum_plus_10, 16);\n    }\n\n    #[test]\n    fn test_reduce() {\n        let array = [1, 2, 3];\n        let sum = array.reduce(|x, y| x + y);\n        assert_eq(sum, 6);\n    }\n\n    #[test(should_fail_with = \"Index out of bounds\")]\n    fn test_reduce_failure_on_empty_array() {\n        let array: [Field; 0] = [];\n        let sum = array.reduce(|x, y| x + y);\n        assert_eq(sum, 6);\n    }\n\n    #[test]\n    fn test_all() {\n        let array = [1, 2, 3];\n        assert(array.all(|x| x >= 1));\n        assert(!array.all(|x| x >= 2));\n    }\n\n    #[test]\n    fn test_any() {\n        let array = [1, 2, 3];\n        assert(array.any(|x| x >= 3));\n        assert(!array.any(|x| x >= 4));\n    }\n\n    #[test]\n    fn test_to_string() {\n        let str = [78_u8, 111, 105, 114].as_str_unchecked();\n        assert_eq(str, \"Noir\");\n    }\n\n    #[test]\n    fn test_bytes_from_string() {\n        let bytes: [u8; 4] = crate::convert::From::from(\"Noir\");\n        assert_eq(bytes, [78_u8, 111, 105, 114]);\n    }\n}\n"
     },
-    "341": {
+    "304": {
+      "function_locations": [
+        {
+          "name": "BlockHeader::chain_id",
+          "start": 1262
+        },
+        {
+          "name": "BlockHeader::version",
+          "start": 1344
+        },
+        {
+          "name": "BlockHeader::block_number",
+          "start": 1428
+        },
+        {
+          "name": "BlockHeader::timestamp",
+          "start": 1514
+        },
+        {
+          "name": "<impl Empty for BlockHeader>::empty",
+          "start": 1617
+        },
+        {
+          "name": "<impl Hash for BlockHeader>::hash",
+          "start": 1959
+        },
+        {
+          "name": "serialization_of_empty",
+          "start": 2090
+        },
+        {
+          "name": "hash_of_genesis_block_header",
+          "start": 2490
+        },
+        {
+          "name": "hash_of_empty_block_header_match_typescript",
+          "start": 3427
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_header.nr",
+      "source": "use crate::{\n    abis::{\n        append_only_tree_snapshot::AppendOnlyTreeSnapshot, global_variables::GlobalVariables,\n        state_reference::StateReference,\n    },\n    constants::{BLOCK_HEADER_LENGTH, DOM_SEP__BLOCK_HEADER_HASH, GENESIS_BLOCK_HEADER_HASH},\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Empty, Hash, Serialize},\n};\nuse std::meta::derive;\n\n// docs:start:block-header\n#[derive(Deserialize, Eq, Serialize)]\npub struct BlockHeader {\n    pub last_archive: AppendOnlyTreeSnapshot,\n    pub state: StateReference,\n\n    // The hash of the sponge blob for this block, which commits to the tx effects added in this block.\n    // Note: it may also include tx effects from previous blocks within the same checkpoint.\n    // When proving tx effects from this block only, we must refer to the `sponge_blob_hash` in the previous block\n    // header to show that the effect was added after the previous block.\n    // The previous block header can be validated using a membership proof of the last leaf in `last_archive`.\n    pub sponge_blob_hash: Field,\n\n    pub global_variables: GlobalVariables,\n    pub total_fees: Field,\n    pub total_mana_used: Field,\n}\n// docs:end:block-header\n\nimpl BlockHeader {\n    pub fn chain_id(self) -> Field {\n        self.global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.global_variables.version\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.global_variables.block_number\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.global_variables.timestamp\n    }\n}\n\nimpl Empty for BlockHeader {\n    fn empty() -> Self {\n        Self {\n            last_archive: AppendOnlyTreeSnapshot::empty(),\n            state: StateReference::empty(),\n            sponge_blob_hash: 0,\n            global_variables: GlobalVariables::empty(),\n            total_fees: 0,\n            total_mana_used: 0,\n        }\n    }\n}\n\nimpl Hash for BlockHeader {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), DOM_SEP__BLOCK_HEADER_HASH)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let header = BlockHeader::empty();\n    // We use the BLOCK_HEADER_LENGTH constant to ensure that there is a match\n    // between the derived trait implementation and the constant.\n    let serialized: [Field; BLOCK_HEADER_LENGTH] = header.serialize();\n    let deserialized = BlockHeader::deserialize(serialized);\n    assert(header.eq(deserialized));\n}\n\n#[test]\nfn hash_of_genesis_block_header() {\n    let mut header = BlockHeader::empty();\n    // The following values are taken from world_state.test.cpp > WorldStateTest.GetInitialTreeInfoForAllTrees.\n    header.state.l1_to_l2_message_tree.root =\n        0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a;\n    header.state.partial.note_hash_tree.root =\n        0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6;\n    header.state.partial.nullifier_tree.root =\n        0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454;\n    header.state.partial.nullifier_tree.next_available_leaf_index = 128;\n    header.state.partial.public_data_tree.root =\n        0x1bef38b621017d3c7416663d0cd81369424560710526a3fbaaec13e356b9d084;\n    header.state.partial.public_data_tree.next_available_leaf_index = 128;\n\n    let hash = header.hash();\n    assert_eq(hash, GENESIS_BLOCK_HEADER_HASH);\n}\n\n#[test]\nfn hash_of_empty_block_header_match_typescript() {\n    let header = BlockHeader::empty();\n    let hash = header.hash();\n\n    // Value from block_header.test.ts \"computes empty hash\" test\n    let test_data_empty_hash = 0x0bdc537052dea0f80db9698585dff9f32063b86b6d4934ac17c30c81e8e416d3;\n    assert_eq(hash, test_data_empty_hash);\n}\n"
+    },
+    "351": {
       "function_locations": [
         {
           "name": "<impl Empty for AztecAddress>::empty",
@@ -1626,7 +1776,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V2, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            DOM_SEP__CONTRACT_ADDRESS_V2,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x303ffc8bd456d132463b1fc3a633aeb718a7883c268f3956c05e6fe09b5a5424;\n    assert_eq(address, expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V2);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x0fa1c698858df1a99170cd39d5f4bfad6d0d60f1f8afa3dc92281ee60b36f3bb;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
     },
-    "344": {
+    "354": {
       "function_locations": [
         {
           "name": "<impl ToField for PartialAddress>::to_field",
@@ -1668,7 +1818,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::DOM_SEP__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Empty, Serialize, ToField},\n};\nuse std::meta::derive;\n\n// Partial address\n#[derive(Deserialize, Eq, Serialize)]\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Empty for PartialAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n        immutables_hash: Field,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer, immutables_hash),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            DOM_SEP__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\nmod test {\n    use crate::{address::partial_address::PartialAddress, traits::{Deserialize, Serialize}};\n\n    #[test]\n    fn serialization_of_partial_address() {\n        let item = PartialAddress::from_field(1);\n        let serialized: [Field; 1] = item.serialize();\n        let deserialized = PartialAddress::deserialize(serialized);\n        assert_eq(item, deserialized);\n    }\n}\n"
     },
-    "346": {
+    "356": {
       "function_locations": [
         {
           "name": "<impl ToField for SaltedInitializationHash>::to_field",
@@ -1690,25 +1840,25 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::DOM_SEP__SALTED_INITIALIZATION_HASH,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n        immutables_hash: Field,\n    ) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field(), immutables_hash],\n            DOM_SEP__SALTED_INITIALIZATION_HASH,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "356": {
+    "366": {
       "function_locations": [
         {
           "name": "<impl Hash for ContractInstance>::hash",
-          "start": 568
+          "start": 1030
         },
         {
           "name": "ContractInstance::to_address",
-          "start": 684
+          "start": 1146
         },
         {
           "name": "test::serde",
-          "start": 1310
+          "start": 1781
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/contract_instance.nr",
-      "source": "use crate::{\n    address::{aztec_address::AztecAddress, partial_address::PartialAddress},\n    contract_class_id::ContractClassId,\n    public_keys::PublicKeys,\n    traits::{Deserialize, Hash, Serialize, ToField},\n};\nuse std::meta::derive;\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct ContractInstance {\n    pub salt: Field,\n    pub deployer: AztecAddress,\n    pub contract_class_id: ContractClassId,\n    pub initialization_hash: Field,\n    pub immutables_hash: Field,\n    pub public_keys: PublicKeys,\n}\n\nimpl Hash for ContractInstance {\n    fn hash(self) -> Field {\n        self.to_address().to_field()\n    }\n}\n\nimpl ContractInstance {\n    pub fn to_address(self) -> AztecAddress {\n        AztecAddress::compute(\n            self.public_keys,\n            PartialAddress::compute(\n                self.contract_class_id,\n                self.salt,\n                self.initialization_hash,\n                self.deployer,\n                self.immutables_hash,\n            ),\n        )\n    }\n}\n\nmod test {\n    use crate::{\n        address::AztecAddress,\n        constants::CONTRACT_INSTANCE_LENGTH,\n        contract_class_id::ContractClassId,\n        contract_instance::ContractInstance,\n        public_keys::PublicKeys,\n        traits::{Deserialize, FromField, Serialize},\n    };\n\n    #[test]\n    fn serde() {\n        let instance = ContractInstance {\n            salt: 6,\n            deployer: AztecAddress::from_field(12),\n            contract_class_id: ContractClassId::from_field(13),\n            initialization_hash: 156,\n            immutables_hash: 789,\n            public_keys: PublicKeys::default(),\n        };\n\n        // We use the CONTRACT_INSTANCE_LENGTH constant to ensure that there is a match between the derived trait\n        // implementation and the constant.\n        let serialized: [Field; CONTRACT_INSTANCE_LENGTH] = instance.serialize();\n\n        let deserialized = ContractInstance::deserialize(serialized);\n\n        assert(instance.eq(deserialized));\n    }\n\n}\n"
+      "source": "use crate::{\n    address::{aztec_address::AztecAddress, partial_address::PartialAddress},\n    contract_class_id::ContractClassId,\n    public_keys::PublicKeys,\n    traits::{Deserialize, Hash, Serialize, ToField},\n};\nuse std::meta::derive;\n\n/// The complete preimage of an [`AztecAddress`].\n///\n/// All of these values are hashed into the contract's `AztecAddress` (see [`Self::to_address`]), so they are fixed\n/// at deployment time and never change.\n///\n/// In particular, `original_contract_class_id` is the class the contract was *deployed* with. For upgradeable contracts\n/// which utilize the `ContractInstanceRegistry` this is NOT the class currently executing i.e. the 'current' class.\n#[derive(Deserialize, Eq, Serialize)]\npub struct ContractInstance {\n    pub salt: Field,\n    pub deployer: AztecAddress,\n    pub original_contract_class_id: ContractClassId,\n    pub initialization_hash: Field,\n    pub immutables_hash: Field,\n    pub public_keys: PublicKeys,\n}\n\nimpl Hash for ContractInstance {\n    fn hash(self) -> Field {\n        self.to_address().to_field()\n    }\n}\n\nimpl ContractInstance {\n    pub fn to_address(self) -> AztecAddress {\n        AztecAddress::compute(\n            self.public_keys,\n            PartialAddress::compute(\n                self.original_contract_class_id,\n                self.salt,\n                self.initialization_hash,\n                self.deployer,\n                self.immutables_hash,\n            ),\n        )\n    }\n}\n\nmod test {\n    use crate::{\n        address::AztecAddress,\n        constants::CONTRACT_INSTANCE_LENGTH,\n        contract_class_id::ContractClassId,\n        contract_instance::ContractInstance,\n        public_keys::PublicKeys,\n        traits::{Deserialize, FromField, Serialize},\n    };\n\n    #[test]\n    fn serde() {\n        let instance = ContractInstance {\n            salt: 6,\n            deployer: AztecAddress::from_field(12),\n            original_contract_class_id: ContractClassId::from_field(13),\n            initialization_hash: 156,\n            immutables_hash: 789,\n            public_keys: PublicKeys::default(),\n        };\n\n        // We use the CONTRACT_INSTANCE_LENGTH constant to ensure that there is a match between the derived trait\n        // implementation and the constant.\n        let serialized: [Field; CONTRACT_INSTANCE_LENGTH] = instance.serialize();\n\n        let deserialized = ContractInstance::deserialize(serialized);\n\n        assert(instance.eq(deserialized));\n    }\n\n}\n"
     },
-    "372": {
+    "382": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -1830,7 +1980,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
-    "374": {
+    "384": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -1904,7 +2054,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
       "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_misc_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
-    "400": {
+    "410": {
       "function_locations": [
         {
           "name": "hash_public_key",
@@ -2152,7 +2302,21 @@
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nmod tests {\n    use crate::cmp::Ord;\n    use crate::cmp::Ordering;\n    use crate::default::Default as _;\n    use super::Option;\n\n    #[test]\n    fn some_and_none() {\n        assert(Option::<u8>::none().is_none());\n        assert(!Option::<u8>::none().is_some());\n        assert(Option::some(1).is_some());\n        assert(!Option::some(1).is_none());\n    }\n\n    #[test]\n    fn unwrap_succeeds() {\n        assert_eq(Option::some(1).unwrap(), 1);\n    }\n\n    #[test(should_fail)]\n    fn unwrap_fails() {\n        let _ = Option::<u8>::none().unwrap();\n    }\n\n    #[test]\n    fn unwrap_or() {\n        assert_eq(Option::some(1).unwrap_or(2), 1);\n        assert_eq(Option::none().unwrap_or(2), 2);\n    }\n\n    #[test]\n    fn unwrap_or_else() {\n        assert_eq(Option::some(1).unwrap_or_else(|| 2), 1);\n        assert_eq(Option::none().unwrap_or_else(|| 2), 2);\n    }\n\n    #[test]\n    fn expect_succeeds() {\n        assert_eq(Option::some(1).expect(f\"Should be there\"), 1);\n    }\n\n    #[test(should_fail_with = \"Should be there\")]\n    fn expect_fails() {\n        let _ = Option::<u8>::none().expect(f\"Should be there\");\n    }\n\n    #[test]\n    fn map() {\n        assert(Option::<u8>::none().map(|x| x + 1).is_none());\n        assert_eq(Option::some(1).map(|x| x + 1), Option::some(2));\n    }\n\n    #[test]\n    fn map_or() {\n        assert_eq(Option::<u8>::none().map_or(0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or(0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn map_or_else() {\n        assert_eq(Option::<u8>::none().map_or_else(|| 0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or_else(|| 0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn and() {\n        assert_eq(Option::<u8>::none().and(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().and(Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and(Option::some(2)), Option::some(2));\n        assert_eq(Option::some(1).and(Option::none()), Option::none());\n    }\n\n    #[test]\n    fn and_then() {\n        assert_eq(Option::<u8>::none().and_then(|_| Option::<u8>::none()), Option::none());\n        assert_eq(Option::<u8>::none().and_then(|_| Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and_then(|x| Option::some(x + 1)), Option::some(2));\n        assert_eq(Option::some(1).and_then(|_| Option::<u8>::none()), Option::none());\n    }\n\n    #[test]\n    fn or() {\n        assert_eq(Option::<u8>::none().or(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn or_else() {\n        assert_eq(Option::<u8>::none().or_else(|| Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or_else(|| Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn xor() {\n        assert_eq(Option::<u8>::none().xor(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().xor(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).xor(Option::some(2)), Option::none());\n        assert_eq(Option::some(1).xor(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn filter() {\n        assert_eq(Option::<u8>::none().filter(|_| true), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 1), Option::some(1));\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n    }\n\n    #[test]\n    fn flatten() {\n        assert_eq(Option::<Option<u8>>::none().flatten(), Option::none());\n        assert_eq(Option::some(Option::<u8>::none()).flatten(), Option::none());\n        assert_eq(Option::some(Option::some(1)).flatten(), Option::some(1));\n    }\n\n    #[test]\n    fn default() {\n        assert_eq(Option::<u8>::default(), Option::none());\n    }\n\n    #[test]\n    fn eq() {\n        assert(Option::<u8>::none() == Option::none());\n        assert(Option::<u8>::some(1) != Option::none());\n        assert(Option::<u8>::none() != Option::some(1));\n        assert(Option::<u8>::some(1) == Option::some(1));\n        assert(Option::<u8>::some(1) != Option::some(2));\n    }\n\n    #[test]\n    fn cmp() {\n        let none = Option::<u8>::none();\n        let one = Option::<u8>::some(1);\n        let two = Option::<u8>::some(2);\n        assert_eq(none.cmp(none), Ordering::equal());\n        assert_eq(none.cmp(one), Ordering::less());\n        assert_eq(one.cmp(none), Ordering::greater());\n        assert_eq(one.cmp(one), Ordering::equal());\n        assert_eq(one.cmp(two), Ordering::less());\n        assert_eq(two.cmp(one), Ordering::greater());\n    }\n}\n"
     },
-    "426": {
+    "43": {
+      "function_locations": [
+        {
+          "name": "panic",
+          "start": 196
+        },
+        {
+          "name": "tests::panics",
+          "start": 469
+        }
+      ],
+      "path": "std/panic.nr",
+      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
+    },
+    "436": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -2202,7 +2366,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_u64(&mut self) -> u64 {\n        self.read() as u64\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() != 0\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn peek_offset(&mut self, offset: u32) -> Field {\n        self.data[self.offset + offset]\n    }\n\n    pub fn advance_offset(&mut self, offset: u32) {\n        self.offset += offset;\n    }\n\n    pub fn finish(self) {\n        assert_eq(self.offset, self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "427": {
+    "437": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -2228,7 +2392,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
       "source": "use crate::{reader::Reader, writer::Writer};\n\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n///     let N: u32 = N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         let bytes = self.as_bytes();\n///         for i in 0..bytes.len() {\n///             writer.write(bytes[i] as Field);\n///         }\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n    let N: u32;\n\n    fn serialize(self) -> [Field; Self::N];\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n///     fields: [Field; N],\n///     length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n///     let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     #[inline_always]\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         Serialize::stream_serialize(self.fields, writer);\n///         Serialize::stream_serialize(self.length, writer);\n///     }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n\n    // We care only about the name and type so we drop the last item of the tuple\n    let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Serialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_serialize_clause = get_where_trait_clause(s, quote { Serialize });\n\n    let params_len_quote = get_params_len_quote(params);\n\n    let function_body = params\n        .map(|(name, _typ): (Quoted, Type)| {\n            quote {\n                $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n            }\n        })\n        .join(quote {});\n\n    quote {\n        impl$generics_declarations $crate::serialization::Serialize for $typ\n            $where_serialize_clause\n        {\n            let N: u32 = $params_len_quote;\n\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n                writer.finish()\n            }\n\n\n            #[inline_always]\n             fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n///     let N: u32 = M;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let mut bytes = [0 as u8; M];\n///         for i in 0..M {\n///             bytes[i] = reader.read() as u8;\n///         }\n///         str::<M>::from(bytes)\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n    let N: u32;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self;\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n///     let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     #[inline_always]\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n///         let y = <Field as Deserialize>::stream_deserialize(reader);\n///         Self { x, y }\n///     }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Deserialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_deserialize_clause = get_where_trait_clause(s, quote { Deserialize });\n\n    // The following will give us:\n    // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n    // (or 0 if the struct has no members)\n    let right_hand_side_of_definition_of_n = if params.len() > 0 {\n        params\n            .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n            <$param_type as $crate::serialization::Deserialize>::N\n        }\n            })\n            .join(quote {+})\n    } else {\n        quote { 0 }\n    };\n\n    // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let function_body = if params.len() > 1 {\n        // This generates deserialization code for each struct member and concatenates them together.\n        let deserialization_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            $deserialization_of_struct_members\n\n            Self { $struct_members }\n        }\n    } else if params.len() == 1 {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n        }\n    } else {\n        quote {\n            Self {}\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::serialization::Deserialize for $typ\n            $where_deserialize_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_n;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n\n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n///              to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n                    <$param_type as $crate::serialization::Serialize>::N\n                }\n            })\n            .join(quote {+});\n        quote { ($params_quote_without_parentheses) }\n    }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n    let generics = s.generics();\n\n    if generics.len() > 0 {\n        let generics_declarations_items = generics\n            .map(|(name, maybe_integer_typ)| {\n                // The second item in the generics tuple is an Option of an integer type that is Some only if\n                // the generic is numeric.\n                if maybe_integer_typ.is_some() {\n                    // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n                    let integer_type = maybe_integer_typ.unwrap();\n                    quote {let $name: $integer_type}\n                } else {\n                    // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n                    quote { $name }\n                }\n            })\n            .join(quote {,});\n        quote {<$generics_declarations_items>}\n    } else {\n        // The struct doesn't have any generics defined, so we just return an empty quote.\n        quote {}\n    }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n    let generics = s.generics();\n\n    // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n    // numeric.\n    let non_numeric_generics =\n        generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations =\n            non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n        quote {where $non_numeric_generics_declarations}\n    } else {\n        // There are no non-numeric generics, so we return an empty quote.\n        quote {}\n    }\n}\n"
     },
-    "429": {
+    "439": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -2542,21 +2706,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
       "source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n        reader.read() != 0\n    }\n}\n\nimpl Serialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u8\n    }\n}\n\nimpl Serialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u16\n    }\n}\n\nimpl Serialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u32\n    }\n}\n\nimpl Serialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u64\n    }\n}\n\nimpl Serialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u128\n    }\n}\n\nimpl Serialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self);\n    }\n}\n\nimpl Deserialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read()\n    }\n}\n\nimpl Serialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u8 as Field);\n    }\n}\n\nimpl Deserialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u8 as i8\n    }\n}\n\nimpl Serialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u16 as Field);\n    }\n}\n\nimpl Deserialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u16 as i16\n    }\n}\n\nimpl Serialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u32 as Field);\n    }\n}\n\nimpl Deserialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u32 as i32\n    }\n}\n\nimpl Serialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u64 as Field);\n    }\n}\n\nimpl Deserialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        for i in 0..M {\n            self[i].stream_serialize(writer);\n        }\n    }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut result: [T; M] = std::mem::zeroed();\n        for i in 0..M {\n            result[i] = T::stream_deserialize(reader);\n        }\n        result\n    }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N + 1;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write_bool(self.is_some());\n        if self.is_some() {\n            self.unwrap_unchecked().stream_serialize(writer);\n        } else {\n            writer.advance_offset(<T as Serialize>::N);\n        }\n    }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N + 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        if reader.read_bool() {\n            Option::some(<T as Deserialize>::stream_deserialize(reader))\n        } else {\n            reader.advance_offset(<T as Deserialize>::N);\n            Option::none()\n        }\n    }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n    let N: u32 = SCALAR_SIZE;\n\n    fn serialize(self) -> [Field; SCALAR_SIZE] {\n        [self.lo, self.hi]\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.lo);\n        writer.write(self.hi);\n    }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n    let N: u32 = SCALAR_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { lo: fields[0], hi: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { lo: reader.read(), hi: reader.read() }\n    }\n}\n\nglobal POINT_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.x, self.y]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.x);\n        writer.write(self.y);\n    }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { x: fields[0], y: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { x: reader.read(), y: reader.read() }\n    }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n    let N: u32 = M;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n        str::<Self::N>::from(u8_arr)\n    }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n    let N: u32 = M;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.as_bytes().stream_serialize(writer);\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M + 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n        let payload_len = Self::N - 1;\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        let len = reader.peek_offset(payload_len) as u32;\n\n        for i in 0..M {\n            if i < len {\n                new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n            }\n        }\n\n        // +1 for the length of the BoundedVec\n        reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n        new_bounded_vec\n    }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n    let N: u32 = 0;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n        ()\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.storage().stream_serialize(writer);\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        writer.write_u32(self.len() as u32);\n    }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n    let mut slice = @[];\n    for i in 0..length {\n        slice = slice.push_back(f(i));\n    }\n    slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n    // `T0`, `T1`, `T2`\n    let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n    // `result0`, `result1`, `result2`\n    let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n    // `T0, T1, T2`\n    let field_generics = type_names.join(quote [,]);\n\n    // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n    let full_size_serialize = type_names\n        .map(|type_name| quote {\n            <$type_name as Serialize>::N\n        })\n        .join(quote [+]);\n\n    // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n    let full_size_deserialize = type_names\n        .map(|type_name| quote {\n            <$type_name as Deserialize>::N\n        })\n        .join(quote [+]);\n\n    // `T0: Serialize, T1: Serialize, T2: Serialize,`\n    let serialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Serialize,\n    })\n        .join(quote []);\n\n    // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n    let deserialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Deserialize,\n    })\n        .join(quote []);\n\n    // Statements to serialize each field\n    let serialized_fields = type_names\n        .mapi(|i, _type_name| quote {\n            $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n        })\n        .join(quote []);\n\n    // Statements to deserialize each field\n    let deserialized_fields = type_names\n        .mapi(|i, type_name| {\n            let result_name = result_names[i];\n            quote {\n            let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n        }\n        })\n        .join(quote []);\n    let deserialize_results = result_names.join(quote [,]);\n\n    quote {\n        impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n            let N: u32 = $full_size_serialize;\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                self.stream_serialize(&mut writer);\n                writer.finish()\n            }\n\n            #[inline_always]\n            fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n                $serialized_fields\n            }\n        }\n\n        impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n            let N: u32 = $full_size_deserialize;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n    \n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $deserialized_fields\n                ($deserialize_results)\n            }\n        }\n    }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n    T1: Serialize,\n{\n    let N: u32 = <T1 as Serialize>::N;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.0.stream_serialize(writer);\n    }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n    T1: Deserialize,\n{\n    let N: u32 = <T1 as Deserialize>::N;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::reader::Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        (<T1 as Deserialize>::stream_deserialize(reader),)\n    }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n    use crate::serialization::{Deserialize, Serialize};\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n    // Test empty BoundedVec\n    let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n    let serialized = empty_vec.serialize();\n    let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n    assert_eq(empty_vec, deserialized);\n    assert_eq(deserialized.len(), 0);\n\n    // Test partially filled BoundedVec\n    let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n    let serialized = partial_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(partial_vec, deserialized);\n    assert_eq(deserialized.len(), 1);\n    assert_eq(deserialized.get(0), [1, 2]);\n\n    // Test full BoundedVec\n    let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n    let serialized = full_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(full_vec, deserialized);\n    assert_eq(deserialized.len(), 3);\n    assert_eq(deserialized.get(0), [1, 2]);\n    assert_eq(deserialized.get(1), [3, 4]);\n    assert_eq(deserialized.get(2), [5, 6]);\n}\n"
     },
-    "43": {
-      "function_locations": [
-        {
-          "name": "panic",
-          "start": 196
-        },
-        {
-          "name": "tests::panics",
-          "start": 469
-        }
-      ],
-      "path": "std/panic.nr",
-      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
-    },
-    "430": {
+    "440": {
       "function_locations": [
         {
           "name": "Writer<N>::new",
@@ -2602,7 +2752,7 @@
       "path": "/home/aztec-dev/aztec-packages/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"
     },
-    "440": {
+    "450": {
       "function_locations": [
         {
           "name": "verify_signature",
@@ -3456,88 +3606,6 @@
       "path": "std/collections/bounded_vec.nr",
       "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a built-in vector except that it\n/// is bounded with a maximum possible length. `BoundedVec` is also not\n/// subject to the same restrictions vectors are (notably, nested vectors are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over vectors when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should generally be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(&self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(&self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(&self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: &BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given vector to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_vector([2, 4].as_vector());\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_vector(&mut self, vector: [T]) {\n        let new_len = self.len + vector.len();\n        assert(new_len <= MaxLen, \"extend_from_vector out of bounds\");\n        for i in 0..vector.len() {\n            self.storage[self.len + i] = vector[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\n            // The source vector can be longer than the destination, or vice versa;\n            // regardless we will only ever be able to read or write whichever is\n            // the shorter max length of the two. We asserted that the actual content fits,\n            // but the capacity of the source vector could be higher.\n            let max = crate::cmp::min(Len, MaxLen);\n\n            // Save the last item in case we have to do a fixup on an already full array.\n            let last = if MaxLen > 0 {\n                self.storage[MaxLen - 1]\n            } else {\n                crate::mem::zeroed()\n            };\n\n            for src in 0..max {\n                // Since we are iterating to the static capacity of the arrays,\n                // the destination could be out of bounds. If that's the case,\n                // overwrite the last item, which we'll fixup in the end.\n                // NB using cmp::min resulted in more opcodes here.\n                let mut dst = self.len + src;\n                if dst >= MaxLen { dst = MaxLen - 1; };\n                // Assigning the source or zeroed to avoid having to merge arrays in SSA.\n                self.storage[dst] = if src < append_len {\n                    vec.get_unchecked(src)\n                } else {\n                    last\n                }\n            }\n\n            // Fixup the last item if we have to.\n            if MaxLen > 0 {\n                self.storage[MaxLen - 1] = if (self.len + append_len == MaxLen) & (append_len > 0) {\n                    vec.get_unchecked(append_len - 1)\n                } else {\n                    last\n                }\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        static_assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0, \"cannot pop from an empty vector\");\n        self.len -= 1;\n        self.storage[self.len]\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\n            let mut exceeded_len = false;\n            for i in 0..MaxLen {\n                exceeded_len |= i == self.len;\n                if !exceeded_len {\n                    ret |= predicate(self.storage[i]);\n                }\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(&self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                ret.storage[i] = if i < self.len() {\n                    f(self.get_unchecked(i))\n                } else {\n                    crate::mem::zeroed()\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element\n    /// in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.mapi(|i, value| i + value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn mapi<U, Env>(&self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                ret.storage[i] = if i < self.len() {\n                    f(i, self.get_unchecked(i))\n                } else {\n                    crate::mem::zeroed()\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Calls a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_each(|value| result.push(value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_each<Env>(&self, f: fn[Env](T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Calls a closure on each element in this vector, along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let mut result = BoundedVec::<u32, 4>::new();\n    /// vec.for_eachi(|i, value| result.push(i + value * 2));\n    ///\n    /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn for_eachi<Env>(&self, f: fn[Env](u32, T) -> ()) {\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                f(i, self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    f(i, self.get_unchecked(i));\n                }\n            }\n        }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    #[deprecated(\"`BoundedVec::from_parts` no longer requires an extra loop, `BoundedVec::from_parts_unchecked` is no longer required\")]\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        if self.len == other.len {\n            if is_unconstrained() {\n                // safety: we are already in an unconstrained context\n                unsafe {\n                    unconstrained_eq(self, other)\n                }\n            } else {\n                let mut eq = true;\n                for i in 0..MaxLen {\n                    if i < self.len {\n                        eq &= self.storage[i] == other.storage[i];\n                    }\n                }\n                eq\n            }\n        } else {\n            false\n        }\n    }\n}\n\n/// Returns true if both BoundedVecs are equal.\n/// Note: This assumes the lengths of both Vecs are already equal!\n/// This function is broken out of `impl Eq for BoundedVec` to make use of `break` in unconstrained code.\nunconstrained fn unconstrained_eq<T, let MaxLen: u32>(\n    a: BoundedVec<T, MaxLen>,\n    b: BoundedVec<T, MaxLen>,\n) -> bool\nwhere\n    T: Eq,\n{\n    let mut eq = true;\n    for i in 0..a.len {\n        if a.storage[i] != b.storage[i] {\n            eq = false;\n            break;\n        }\n    }\n    eq\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            let _ = vec.get(0);\n        }\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_beyond_length() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            let _ = vec.get(3);\n        }\n\n        #[test]\n        fn get_works_within_bounds() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(2), 3);\n            assert_eq(vec.get(4), 5);\n        }\n\n        #[test]\n        fn get_unchecked_works() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            assert_eq(vec.get_unchecked(0), 1);\n            assert_eq(vec.get_unchecked(2), 3);\n        }\n\n        #[test]\n        fn get_unchecked_works_past_len() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            assert_eq(vec.get_unchecked(4), 0);\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_setting_beyond_length() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n            vec.set(3, 4);\n        }\n\n        #[test]\n        fn set_unchecked_operations() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n\n            vec.set_unchecked(0, 10);\n            assert_eq(vec.get(0), 10);\n        }\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn set_unchecked_operations_past_len() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n\n            vec.set_unchecked(3, 40);\n            assert_eq(vec.get(3), 40);\n        }\n\n        #[test]\n        fn set_preserves_other_elements() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n            vec.set(2, 30);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 30);\n            assert_eq(vec.get(3), 4);\n            assert_eq(vec.get(4), 5);\n        }\n    }\n\n    mod any {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        #[test]\n        #[test_unconstrained]\n        fn returns_false_if_predicate_not_satisfied() {\n            let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, false, false]);\n            let result = vec.any(|value| value);\n\n            assert(!result);\n        }\n\n        #[test]\n        #[test_unconstrained]\n        fn returns_true_if_predicate_satisfied() {\n            let vec: BoundedVec<bool, 4> = BoundedVec::from_array([false, false, true, true]);\n            let result = vec.any(|value| value);\n\n            assert(result);\n        }\n\n        #[test]\n        fn returns_false_on_empty_boundedvec() {\n            let vec: BoundedVec<bool, 0> = BoundedVec::new();\n            let result = vec.any(|value| value);\n\n            assert(!result);\n        }\n\n        #[test]\n        #[test_unconstrained]\n        fn any_with_complex_predicates() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n\n            assert(vec.any(|x| x > 3));\n            assert(!vec.any(|x| x > 10));\n            assert(vec.any(|x| x % 2 == 0)); // has a even number\n            assert(vec.any(|x| x == 3)); // has a specific value\n        }\n\n        #[test]\n        fn any_with_partial_vector() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n\n            assert(vec.any(|x| x == 1));\n            assert(vec.any(|x| x == 2));\n            assert(!vec.any(|x| x == 3));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        #[test]\n        #[test_unconstrained]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn map_with_conditional_logic() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n            let result = vec.map(|x| if x % 2 == 0 { x * 2 } else { x });\n            let expected = BoundedVec::from_array([1, 4, 3, 8]);\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn map_preserves_length() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|x| x * 2);\n\n            assert_eq(result.len(), vec.len());\n            assert_eq(result.max_len(), vec.max_len());\n        }\n\n        #[test]\n        fn map_on_empty_vector() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let result = vec.map(|x| x * 2);\n            assert_eq(result, vec);\n            assert_eq(result.len(), 0);\n            assert_eq(result.max_len(), 5);\n        }\n    }\n\n    mod mapi {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        #[test]\n        #[test_unconstrained]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-mapi-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| i + value * 2);\n            // docs:end:bounded-vec-mapi-example\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.mapi(|i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn mapi_with_index_branching_logic() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n\n            let result = vec.mapi(|i, x| if i % 2 == 0 { x * 2 } else { x });\n            let expected = BoundedVec::from_array([2, 2, 6, 4]);\n            assert_eq(result, expected);\n        }\n    }\n\n    mod for_each {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        // map in terms of for_each\n        fn for_each_map<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_each(|x| output_ref.push(f(x)));\n            output\n        }\n\n        #[test]\n        #[test_unconstrained]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-each-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_each(|value| { *acc_ref += value; });\n            // docs:end:bounded-vec-for-each-example\n            assert_eq(acc, 6);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| value * 2);\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_each_map(vec, |value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn for_each_on_empty_vector() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let mut count = 0;\n            let count_ref = &mut count;\n            vec.for_each(|_| { *count_ref += 1; });\n            assert_eq(count, 0);\n        }\n\n        #[test]\n        fn for_each_with_side_effects() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            let mut seen = BoundedVec::<u32, 3>::new();\n            let seen_ref = &mut seen;\n            vec.for_each(|x| seen_ref.push(x));\n            assert_eq(seen, vec);\n        }\n    }\n\n    mod for_eachi {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        // mapi in terms of for_eachi\n        fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n            input: BoundedVec<T, MaxLen>,\n            f: fn[Env](u32, T) -> U,\n        ) -> BoundedVec<U, MaxLen> {\n            let mut output = BoundedVec::<U, MaxLen>::new();\n            let output_ref = &mut output;\n            input.for_eachi(|i, x| output_ref.push(f(i, x)));\n            output\n        }\n\n        #[test]\n        #[test_unconstrained]\n        fn smoke_test() {\n            let mut acc = 0;\n            let acc_ref = &mut acc;\n            // docs:start:bounded-vec-for-eachi-example\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            vec.for_eachi(|i, value| { *acc_ref += i * value; });\n            // docs:end:bounded-vec-for-eachi-example\n\n            // 0 * 1 + 1 * 2 + 2 * 3\n            assert_eq(acc, 8);\n        }\n\n        #[test]\n        fn applies_function_correctly() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n            let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n\n        #[test]\n        fn for_eachi_on_empty_vector() {\n            let vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let mut count = 0;\n            let count_ref = &mut count;\n            vec.for_eachi(|_, _| { *count_ref += 1; });\n            assert_eq(count, 0);\n        }\n\n        #[test]\n        fn for_eachi_with_index_tracking() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([10, 20, 30]);\n            let mut indices = BoundedVec::<u32, 3>::new();\n            let indices_ref = &mut indices;\n            vec.for_eachi(|i, _| indices_ref.push(i));\n\n            let expected = BoundedVec::from_array([0, 1, 2]);\n            assert_eq(indices, expected);\n        }\n\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n\n        #[test]\n        fn from_array_preserves_order() {\n            let array = [5, 3, 1, 4, 2];\n            let vec: BoundedVec<u32, 5> = BoundedVec::from_array(array);\n            for i in 0..array.len() {\n                assert_eq(vec.get(i), array[i]);\n            }\n        }\n\n        #[test]\n        fn from_array_with_different_types() {\n            let bool_array = [true, false, true];\n            let bool_vec: BoundedVec<bool, 3> = BoundedVec::from_array(bool_array);\n            assert_eq(bool_vec.len(), 3);\n            assert_eq(bool_vec.get(0), true);\n            assert_eq(bool_vec.get(1), false);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::convert::From;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            bounded_vec1.push(1);\n            bounded_vec2.push(1);\n            assert(bounded_vec1 == bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            bounded_vec1.push(1);\n            assert(bounded_vec1 != bounded_vec2);\n\n            bounded_vec2.push(2);\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        #[test]\n        #[test_unconstrained]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are ignored, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n    }\n\n    mod push_pop {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn push_and_pop_operations() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n            assert_eq(vec.len(), 0);\n\n            vec.push(1);\n            assert_eq(vec.len(), 1);\n            assert_eq(vec.get(0), 1);\n\n            vec.push(2);\n            assert_eq(vec.len(), 2);\n            assert_eq(vec.get(1), 2);\n\n            let popped = vec.pop();\n            assert_eq(popped, 2);\n            assert_eq(vec.len(), 1);\n\n            let popped2 = vec.pop();\n            assert_eq(popped2, 1);\n            assert_eq(vec.len(), 0);\n        }\n\n        #[test(should_fail_with = \"push out of bounds\")]\n        fn push_to_full_vector() {\n            let mut vec: BoundedVec<u32, 2> = BoundedVec::new();\n            vec.push(1);\n            vec.push(2);\n            vec.push(3); // should panic\n        }\n\n        #[test(should_fail_with = \"cannot pop from an empty vector\")]\n        fn pop_from_empty_vector() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let _ = vec.pop(); // should panic\n        }\n\n        #[test]\n        fn push_pop_cycle() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n\n            // push to full\n            vec.push(1);\n            vec.push(2);\n            vec.push(3);\n            assert_eq(vec.len(), 3);\n\n            // pop all\n            assert_eq(vec.pop(), 3);\n            assert_eq(vec.pop(), 2);\n            assert_eq(vec.pop(), 1);\n            assert_eq(vec.len(), 0);\n\n            // push again\n            vec.push(4);\n            assert_eq(vec.len(), 1);\n            assert_eq(vec.get(0), 4);\n        }\n    }\n\n    mod extend {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::internal::test_unconstrained;\n\n        #[test]\n        fn extend_from_array() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_array([2, 3]);\n\n            assert_eq(vec.len(), 3);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 3);\n        }\n\n        #[test]\n        fn extend_from_vector() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_vector([2, 3].as_vector());\n\n            assert_eq(vec.len(), 3);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 3);\n        }\n\n        #[test]\n        #[test_unconstrained]\n        fn extend_from_bounded_vec() {\n            // The source deliberately has a higher capacity,\n            // to make sure we are not trying to assign out-of-bounds.\n            let mut vec1: BoundedVec<u32, 5> = BoundedVec::new();\n            let mut vec2: BoundedVec<u32, 9> = BoundedVec::new();\n\n            vec1.push(1);\n            vec2.push(2);\n            vec2.push(3);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 3);\n            assert_eq(vec1.get(0), 1);\n            assert_eq(vec1.get(1), 2);\n            assert_eq(vec1.get(2), 3);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec_limit() {\n            // Capacity and contents chosen so the last item must be assigned to.\n            let mut vec1: BoundedVec<u32, 2> = BoundedVec::new();\n            let mut vec2: BoundedVec<u32, 5> = BoundedVec::new();\n\n            vec1.push(1);\n            vec2.push(2);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 2);\n            assert_eq(vec1.get(0), 1);\n            assert_eq(vec1.get(1), 2);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec_full_and_empty() {\n            // Capacity and contents chosen so the last item must be assigned to.\n            let mut vec1: BoundedVec<u32, 2> = BoundedVec::new();\n            let vec2: BoundedVec<u32, 5> = BoundedVec::new();\n\n            vec1.push(1);\n            vec1.push(2);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 2);\n            assert_eq(vec1.get(0), 1);\n            assert_eq(vec1.get(1), 2);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec_zero_len() {\n            let mut vec1: BoundedVec<u32, 0> = BoundedVec::new();\n            let vec2: BoundedVec<u32, 0> = BoundedVec::new();\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 0);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec_last_zeroed() {\n            let mut vec1: BoundedVec<u32, 4> = BoundedVec::new();\n            let mut vec2: BoundedVec<u32, 4> = BoundedVec::new();\n\n            vec1.push(1);\n            vec1.push(2);\n            vec2.push(3);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 3);\n            assert_eq(vec1.get_unchecked(3), 0);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec_empty_self() {\n            // self.len == 0 with Len > MaxLen: the loop doesn't reach\n            // the last storage slot, so the fixup must write it.\n            let mut vec1: BoundedVec<u32, 3> = BoundedVec::new();\n            let vec2: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3]);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 3);\n            assert_eq(vec1.get(0), 1);\n            assert_eq(vec1.get(1), 2);\n            assert_eq(vec1.get(2), 3);\n        }\n\n        #[test]\n        fn extend_from_bounded_vec_equal_capacity() {\n            // Len == MaxLen, fills to capacity.\n            let mut vec1: BoundedVec<u32, 4> = BoundedVec::new();\n            vec1.push(1);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_array([2, 3, 4]);\n\n            vec1.extend_from_bounded_vec(vec2);\n\n            assert_eq(vec1.len(), 4);\n            assert_eq(vec1.get(0), 1);\n            assert_eq(vec1.get(1), 2);\n            assert_eq(vec1.get(2), 3);\n            assert_eq(vec1.get(3), 4);\n        }\n\n        #[test(should_fail_with = \"extend_from_array out of bounds\")]\n        fn extend_array_beyond_max_len() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_array([2, 3, 4]); // should panic\n        }\n\n        #[test(should_fail_with = \"extend_from_vector out of bounds\")]\n        fn extend_vector_beyond_max_len() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n            vec.push(1);\n            vec.extend_from_vector([2, 3, 4].as_vector()); // S]should panic\n        }\n\n        #[test(should_fail_with = \"extend_from_bounded_vec out of bounds\")]\n        fn extend_bounded_vec_beyond_max_len() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::new();\n            let other: BoundedVec<u32, 5> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n            vec.extend_from_bounded_vec(other); // should panic\n        }\n\n        #[test]\n        fn extend_with_empty_collections() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n            let original_len = vec.len();\n\n            vec.extend_from_array([]);\n            assert_eq(vec.len(), original_len);\n\n            vec.extend_from_vector([].as_vector());\n            assert_eq(vec.len(), original_len);\n\n            let empty: BoundedVec<u32, 3> = BoundedVec::new();\n            vec.extend_from_bounded_vec(empty);\n            assert_eq(vec.len(), original_len);\n        }\n    }\n\n    mod storage {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn storage_consistency() {\n            let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n\n            // test initial storage state\n            assert_eq(vec.storage(), [0, 0, 0, 0, 0]);\n\n            vec.push(1);\n            vec.push(2);\n\n            // test storage after modifications\n            assert_eq(vec.storage(), [1, 2, 0, 0, 0]);\n\n            // storage doesn't change length\n            assert_eq(vec.len(), 2);\n            assert_eq(vec.max_len(), 5);\n        }\n\n        #[test]\n        fn storage_after_pop() {\n            let mut vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n\n            let _ = vec.pop();\n            // after pop, the last element should be unmodified\n            assert_eq(vec.storage(), [1, 2, 3]);\n            assert_eq(vec.len(), 2);\n        }\n\n        #[test]\n        fn vector_immutable() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n            let storage = vec.storage();\n\n            assert_eq(storage, [1, 2, 3]);\n\n            // Verify that the original vector is unchanged\n            assert_eq(vec.len(), 3);\n            assert_eq(vec.get(0), 1);\n            assert_eq(vec.get(1), 2);\n            assert_eq(vec.get(2), 3);\n        }\n    }\n}\n"
     },
-    "60": {
-      "function_locations": [
-        {
-          "name": "CapsuleArray<T>::at",
-          "start": 1478
-        },
-        {
-          "name": "CapsuleArray<T>::len",
-          "start": 1641
-        },
-        {
-          "name": "CapsuleArray<T>::push",
-          "start": 1935
-        },
-        {
-          "name": "CapsuleArray<T>::get",
-          "start": 2748
-        },
-        {
-          "name": "CapsuleArray<T>::remove",
-          "start": 3083
-        },
-        {
-          "name": "CapsuleArray<T>::for_each",
-          "start": 5345
-        },
-        {
-          "name": "CapsuleArray<T>::slot_at",
-          "start": 6413
-        },
-        {
-          "name": "test::empty_array",
-          "start": 6789
-        },
-        {
-          "name": "test::empty_array_read",
-          "start": 7263
-        },
-        {
-          "name": "test::array_push",
-          "start": 7638
-        },
-        {
-          "name": "test::read_past_len",
-          "start": 8156
-        },
-        {
-          "name": "test::array_remove_last",
-          "start": 8559
-        },
-        {
-          "name": "test::array_remove_some",
-          "start": 8997
-        },
-        {
-          "name": "test::array_remove_all",
-          "start": 9729
-        },
-        {
-          "name": "test::for_each_called_with_all_elements",
-          "start": 10296
-        },
-        {
-          "name": "test::for_each_remove_some",
-          "start": 11389
-        },
-        {
-          "name": "test::for_each_remove_all",
-          "start": 12081
-        },
-        {
-          "name": "test::for_each_remove_all_no_copy",
-          "start": 12619
-        },
-        {
-          "name": "test::different_scopes_are_isolated",
-          "start": 13383
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
-      "source": "use crate::oracle::capsules;\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n    /// Scope for capsule isolation. Capsule operations are scoped to the given address, allowing multiple independent\n    /// namespaces within the same contract.\n    scope: AztecAddress,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray scoped to a specific address.\n    ///\n    /// Array elements are stored in contiguous slots\n    /// following the base slot, so there should be sufficient space between array base slots to accommodate elements.\n    /// A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field, scope: AztecAddress) -> Self {\n        Self { contract_address, base_slot, scope }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot, self.scope).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(\n            self.contract_address,\n            self.slot_at(current_length),\n            value,\n            self.scope,\n        );\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            new_length,\n            self.scope,\n        );\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index), self.scope).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n                self.scope,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(\n            self.contract_address,\n            self.slot_at(current_length - 1),\n            self.scope,\n        );\n        capsules::store(\n            self.contract_address,\n            self.base_slot,\n            current_length - 1,\n            self.scope,\n        );\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index. The order in which values\n    /// are processed is arbitrary.\n    ///\n    /// ## Array Mutation\n    ///\n    /// It is safe to delete the current element (and only the current element) from inside the callback via `remove`:\n    /// ```noir\n    /// array.for_each(|index, value| {\n    ///   if some_condition(value) {\n    ///     array.remove(index); // safe only for this index\n    ///   }\n    /// }\n    /// ```\n    ///\n    /// If all elements in the array need to iterated over and then removed, then using `for_each` results in optimal\n    /// efficiency.\n    ///\n    /// It is **not** safe to push new elements into the array from inside the callback.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        // Iterating over all elements is simple, but we want to do it in such a way that a) deleting the current\n        // element is safe to do, and b) deleting *all* elements is optimally efficient. This is because CapsuleArrays\n        // are typically used to hold pending tasks, so iterating them while clearing completed tasks (sometimes\n        // unconditionally, resulting in a full clear) is a very common access pattern.\n        //\n        // The way we achieve this is by iterating backwards: each element can always be deleted since it won't change\n        // any preceding (lower) indices, and if every element is deleted then every element will (in turn) be the last\n        // element. This results in an optimal full clear since `remove` will be able to skip the `capsules::copy` call\n        // to shift any elements past the deleted one (because there will be none).\n        let mut i = self.len();\n        while i > 0 {\n            i -= 1;\n            f(i, self.get(i));\n        }\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n\n    global SLOT: Field = 1230;\n\n    #[test]\n    unconstrained fn empty_array() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT, scope);\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            let _: Field = array.get(0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            assert_eq(array.len(), 1);\n            assert_eq(array.get(0), 5);\n        });\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n            array.push(5);\n\n            let _ = array.get(1);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(5);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            assert_eq(array.len(), 3);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 8);\n            assert_eq(array.get(2), 9);\n\n            array.remove(1);\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 7);\n            assert_eq(array.get(1), 9);\n        });\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(7);\n            array.push(8);\n            array.push(9);\n\n            array.remove(1);\n            array.remove(1);\n            array.remove(0);\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_called_with_all_elements() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We store all values that we were called with and check that all (value, index) tuples are present. Note\n            // that we do not care about the order in which each tuple was passed to the closure.\n            let called_with = &mut BoundedVec::<(u32, Field), 3>::new();\n            array.for_each(|index, value| { called_with.push((index, value)); });\n\n            assert_eq(called_with.len(), 3);\n            assert(called_with.any(|(index, value)| (index == 0) & (value == 4)));\n            assert(called_with.any(|(index, value)| (index == 1) & (value == 5)));\n            assert(called_with.any(|(index, value)| (index == 2) & (value == 6)));\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_some() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| {\n                if index == 1 {\n                    array.remove(index);\n                }\n            });\n\n            assert_eq(array.len(), 2);\n            assert_eq(array.get(0), 4);\n            assert_eq(array.get(1), 6);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(array.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn for_each_remove_all_no_copy() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let array = CapsuleArray::at(contract_address, SLOT, scope);\n\n            array.push(4);\n            array.push(5);\n            array.push(6);\n\n            // We test that the aztec_utl_copyCapsule was never called, which is the expensive operation we want to\n            // avoid.\n            let mock = std::test::OracleMock::mock(\"aztec_utl_copyCapsule\");\n\n            array.for_each(|index, _| { array.remove(index); });\n\n            assert_eq(mock.times_called(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn different_scopes_are_isolated() {\n        let mut env = TestEnvironment::new();\n        let scope_a = env.create_light_account();\n        let scope_b = env.create_light_account();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let array_a = CapsuleArray::at(contract_address, SLOT, scope_a);\n            let array_b = CapsuleArray::at(contract_address, SLOT, scope_b);\n\n            array_a.push(10);\n            array_a.push(20);\n            array_b.push(99);\n\n            assert_eq(array_a.len(), 2);\n            assert_eq(array_a.get(0), 10);\n            assert_eq(array_a.get(1), 20);\n\n            assert_eq(array_b.len(), 1);\n            assert_eq(array_b.get(0), 99);\n        });\n    }\n}\n"
-    },
     "68": {
       "function_locations": [
         {
@@ -3720,49 +3788,181 @@
       "function_locations": [
         {
           "name": "UtilityContext::new",
-          "start": 416
+          "start": 502
         },
         {
           "name": "UtilityContext::at",
-          "start": 523
+          "start": 609
         },
         {
           "name": "UtilityContext::block_header",
-          "start": 855
+          "start": 981
         },
         {
           "name": "UtilityContext::block_number",
-          "start": 927
+          "start": 1053
         },
         {
           "name": "UtilityContext::timestamp",
-          "start": 1011
+          "start": 1137
         },
         {
           "name": "UtilityContext::this_address",
-          "start": 1104
+          "start": 1230
+        },
+        {
+          "name": "UtilityContext::maybe_msg_sender",
+          "start": 2019
         },
         {
           "name": "UtilityContext::version",
-          "start": 1177
+          "start": 2223
         },
         {
           "name": "UtilityContext::chain_id",
-          "start": 1257
+          "start": 2303
         },
         {
           "name": "UtilityContext::raw_storage_read",
-          "start": 1404
+          "start": 2450
         },
         {
           "name": "UtilityContext::storage_read",
-          "start": 1596
+          "start": 2642
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
-      "source": "use crate::oracle::{execution::get_utility_context, storage::storage_read};\nuse crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress, traits::Packable};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n    block_header: BlockHeader,\n    contract_address: AztecAddress,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        get_utility_context()\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        // We get a context with default contract address, and then we construct the final context with the provided\n        // contract address.\n        let default_context = get_utility_context();\n\n        Self { block_header: default_context.block_header, contract_address }\n    }\n\n    pub fn block_header(self) -> BlockHeader {\n        self.block_header\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_header.block_number()\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.block_header.timestamp()\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.block_header.version()\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.block_header.chain_id()\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        storage_read(self.block_header, self.this_address(), storage_slot)\n    }\n\n    pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
+      "source": "use crate::oracle::{execution::get_utility_context, storage::storage_read};\nuse crate::protocol::{\n    abis::block_header::BlockHeader, address::AztecAddress, constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    traits::Packable,\n};\n\n// If you'll modify this struct don't forget to update utility_context.ts as well.\npub struct UtilityContext {\n    block_header: BlockHeader,\n    contract_address: AztecAddress,\n    msg_sender: AztecAddress,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        get_utility_context()\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        // We get a context with default contract address, and then we construct the final context with the provided\n        // contract address.\n        let default_context = get_utility_context();\n\n        Self { block_header: default_context.block_header, contract_address, msg_sender: default_context.msg_sender }\n    }\n\n    pub fn block_header(self) -> BlockHeader {\n        self.block_header\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_header.block_number()\n    }\n\n    pub fn timestamp(self) -> u64 {\n        self.block_header.timestamp()\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    /// Returns the address that initiated this utility call.\n    ///\n    /// This is similar to `msg.sender` in Solidity (hence the name). A utility function called by another contract\n    /// (via a nested utility call) sees that contract's address. A utility function invoked directly (e.g. by a wallet\n    /// or dApp) has no caller and sees `Option::none`.\n    ///\n    /// Important Note: utility functions are simulated client-side and never proven, so this value is whatever the\n    /// simulator (PXE) set it to: nothing about it is verified onchain. It exists to assist simulation in a\n    /// cooperative environment and must not be relied on as a security guarantee.\n    pub unconstrained fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        if self.msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(self.msg_sender)\n        }\n    }\n\n    pub fn version(self) -> Field {\n        self.block_header.version()\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.block_header.chain_id()\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        storage_read(self.block_header, self.this_address(), storage_slot)\n    }\n\n    pub unconstrained fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
+    },
+    "76": {
+      "function_locations": [
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::len_oracle",
+          "start": 1625
+        },
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::push_oracle",
+          "start": 1763
+        },
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::pop_oracle",
+          "start": 1896
+        },
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::get_oracle",
+          "start": 2032
+        },
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::set_oracle",
+          "start": 2181
+        },
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::remove_oracle",
+          "start": 2309
+        },
+        {
+          "name": "<impl ArrayOracles for EphemeralOracles>::clear_oracle",
+          "start": 2419
+        },
+        {
+          "name": "<impl Serialize for UnconstrainedArray<T, EphemeralOracles>>::serialize",
+          "start": 2754
+        },
+        {
+          "name": "<impl Serialize for UnconstrainedArray<T, EphemeralOracles>>::stream_serialize",
+          "start": 2849
+        },
+        {
+          "name": "<impl Deserialize for UnconstrainedArray<T, EphemeralOracles>>::deserialize",
+          "start": 3147
+        },
+        {
+          "name": "<impl Deserialize for UnconstrainedArray<T, EphemeralOracles>>::stream_deserialize",
+          "start": 3259
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/ephemeral/mod.nr",
+      "source": "use crate::oracle::ephemeral_oracles;\nuse crate::protocol::traits::{Deserialize, Serialize};\nuse crate::protocol::utils::{reader::Reader, writer::Writer};\nuse crate::unconstrained_array::{ArrayOracles, UnconstrainedArray};\n\n/// A dynamically sized array that exists only during a single contract call frame.\n///\n/// Ephemeral arrays are backed by in-memory storage on the PXE side rather than a persistent database. Each contract\n/// call frame gets its own isolated slot space of ephemeral arrays. Child simulations cannot see the parent's\n/// ephemeral arrays, and vice versa.\n///\n/// Each logical array operation (push, pop, get, etc.) is a single oracle call, making ephemeral arrays significantly\n/// cheaper than capsule arrays.\n///\n/// ## Use Cases\n///\n/// Ephemeral arrays are designed for passing data between PXE (TypeScript) and contracts (Noir) during simulation,\n/// for example, note validation requests or event validation responses. This data type is appropriate for data that\n/// is not supposed to be persisted.\n///\n/// For data that needs to persist across simulations, contract calls, etc, use\n/// [`CapsuleArray`](crate::capsules::CapsuleArray) instead.\n///\n/// For data that must be shared across all frames of the same contract (private and utility) within one top-level PXE\n/// call (transaction simulation or utility call) but not persisted, use\n/// [`TransientArray`](crate::transient::TransientArray).\npub type EphemeralArray<T> = UnconstrainedArray<T, EphemeralOracles>;\n\npub struct EphemeralOracles {}\n\nimpl ArrayOracles for EphemeralOracles {\n    unconstrained fn len_oracle(slot: Field) -> u32 {\n        ephemeral_oracles::len_oracle(slot)\n    }\n\n    unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32 {\n        ephemeral_oracles::push_oracle(slot, values)\n    }\n\n    unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N] {\n        ephemeral_oracles::pop_oracle(slot)\n    }\n\n    unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N] {\n        ephemeral_oracles::get_oracle(slot, index)\n    }\n\n    unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]) {\n        ephemeral_oracles::set_oracle(slot, index, values)\n    }\n\n    unconstrained fn remove_oracle(slot: Field, index: u32) {\n        ephemeral_oracles::remove_oracle(slot, index)\n    }\n\n    unconstrained fn clear_oracle(slot: Field) {\n        ephemeral_oracles::clear_oracle(slot)\n    }\n}\n\n/// Serializes an `EphemeralArray` as its slot, allowing oracle function signatures to use ephemeral array types\n/// instead of opaque `Field` slots.\nimpl<T> Serialize for UnconstrainedArray<T, EphemeralOracles> {\n    let N: u32 = 1;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.slot]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.slot);\n    }\n}\n\n/// Deserializes a single Field into an `EphemeralArray` handle, treating the field value as the slot identifier.\nimpl<T> Deserialize for UnconstrainedArray<T, EphemeralOracles> {\n    let N: u32 = 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { slot: fields[0] }\n    }\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { slot: reader.read() }\n    }\n}\n\n#[crate::unconstrained_array::test_suite::unconstrained_array_tests(quote { crate::ephemeral::EphemeralOracles })]\nmod test {}\n"
     },
     "82": {
+      "function_locations": [
+        {
+          "name": "record_retractable_fact",
+          "start": 2468
+        },
+        {
+          "name": "record_non_retractable_fact",
+          "start": 3104
+        },
+        {
+          "name": "delete_fact_collection",
+          "start": 3741
+        },
+        {
+          "name": "get_fact_collection",
+          "start": 4119
+        },
+        {
+          "name": "get_fact_collections_by_type",
+          "start": 4512
+        },
+        {
+          "name": "test::setup",
+          "start": 5239
+        },
+        {
+          "name": "test::make_payload",
+          "start": 5454
+        },
+        {
+          "name": "test::assert_payload",
+          "start": 5688
+        },
+        {
+          "name": "test::record_fact",
+          "start": 5929
+        },
+        {
+          "name": "test::records_and_reads_a_fact",
+          "start": 6204
+        },
+        {
+          "name": "test::reads_collections_by_type",
+          "start": 7081
+        },
+        {
+          "name": "test::records_a_retractable_fact",
+          "start": 7805
+        },
+        {
+          "name": "test::deletes_a_fact_collection",
+          "start": 8798
+        },
+        {
+          "name": "test::reading_unknown_collection_returns_none",
+          "start": 9304
+        },
+        {
+          "name": "test::cannot_record_for_other_contract",
+          "start": 9713
+        },
+        {
+          "name": "test::re_recording_an_identical_fact_is_a_no_op",
+          "start": 10015
+        },
+        {
+          "name": "test::deleting_a_non_existing_collection_is_a_no_op",
+          "start": 10511
+        },
+        {
+          "name": "test::recording_a_fact_after_delete_recreates_the_collection",
+          "start": 10943
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/facts/mod.nr",
+      "source": "//! Storage of immutable facts grouped into collections.\n//!\n//! A fact is a contract-defined, typed, immutable datum. Facts are grouped into collections identified by a\n//! `(collection type, collection id)` tuple.\n//!\n//! They are stored in PXE's FactStore, which automatically deals with reorgs by removing any facts\n//! associated with blocks that have been pruned.\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::fact_store::{\n    delete_fact_collection_oracle, get_fact_collection_oracle, get_fact_collections_by_type_oracle, record_fact_oracle,\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// The block a retractable fact originates from.\n#[derive(Deserialize, Eq, Serialize)]\npub struct OriginBlock {\n    pub block_number: u32,\n    pub block_hash: Field,\n}\n\n/// A single immutable fact in a collection.\n#[derive(Deserialize, Serialize)]\npub struct Fact {\n    /// A user-defined identifier for fact kinds. Typically used to determine how to deserialize `payload`.\n    pub fact_type_id: Field,\n    pub payload: EphemeralArray<Field>,\n    /// The block the fact is associated to, if any. A fact with an origin block is said to be a 'retractable' fact,\n    /// and will be automatically deleted if its origin block gets pruned in a reorg. Typically used by facts\n    /// associated with a transaction (e.g. 'processed entry X using data from tx Y in block Z').\n    pub origin_block: Option<OriginBlock>,\n}\n\n/// A fact collection as returned by the store.\n#[derive(Deserialize, Serialize)]\npub struct FactCollection {\n    pub contract_address: AztecAddress,\n    pub scope: AztecAddress,\n    /// The collection's type. A single contract may have facts in collections of different types (e.g. one for the\n    /// processing offchain messages, another for partial notes, etc.).\n    pub fact_collection_type_id: Field,\n    /// The collection's unique identifier among the other collections of this type in this contract and scope.\n    pub fact_collection_id: Field,\n    pub facts: EphemeralArray<Fact>,\n}\n\n/// Records a retractable fact into a collection: PXE prunes it if `origin_block` is reorg'd away. Re-recording an\n/// identical fact is a no-op.\npub unconstrained fn record_retractable_fact(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n    origin_block: OriginBlock,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::some(origin_block),\n    );\n}\n\n/// Records a non-retractable fact into a collection: it survives reorgs and will persist until the fact collection\n/// itself is deleted. Re-recording an identical fact is a no-op.\npub unconstrained fn record_non_retractable_fact(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::none(),\n    );\n}\n\n/// Deletes a fact collection, removing all its facts from PXE storage.\n///\n/// Collections must be eventually deleted to reclaim storage and to stop reprocessing past the lifespan of the\n/// workflows they enable.\n///\n/// A no-op if no such collection exists.\npub unconstrained fn delete_fact_collection(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) {\n    delete_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    );\n}\n\n/// Fetches a fact collection.\npub unconstrained fn get_fact_collection(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) -> Option<FactCollection> {\n    get_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    )\n}\n\n/// Returns every fact collection of `fact_collection_type_id`.\npub unconstrained fn get_fact_collections_by_type(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n) -> EphemeralArray<FactCollection> {\n    get_fact_collections_by_type_oracle(contract_address, scope, fact_collection_type_id)\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::facts::{\n        delete_fact_collection, get_fact_collection, get_fact_collections_by_type, OriginBlock,\n        record_non_retractable_fact, record_retractable_fact,\n    };\n    use crate::protocol::address::AztecAddress;\n    use crate::protocol::traits::{FromField, ToField};\n    use crate::test::helpers::test_environment::TestEnvironment;\n\n    global TYPE_ID: Field = 42;\n    global COLLECTION_ID: Field = 7;\n    global FACT_TYPE_ID: Field = 99;\n    global PAYLOAD: [Field; 3] = [123, 456, 789];\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    unconstrained fn make_payload<let N: u32>(values: [Field; N]) -> EphemeralArray<Field> {\n        let payload: EphemeralArray<Field> = EphemeralArray::empty();\n        for i in 0..N {\n            payload.push(values[i]);\n        }\n        payload\n    }\n\n    unconstrained fn assert_payload(payload: EphemeralArray<Field>) {\n        assert_eq(payload.len(), PAYLOAD.len());\n        for i in 0..PAYLOAD.len() {\n            assert_eq(payload.get(i), PAYLOAD[i]);\n        }\n    }\n\n    unconstrained fn record_fact(contract_address: AztecAddress, scope: AztecAddress) {\n        record_non_retractable_fact(\n            contract_address,\n            scope,\n            TYPE_ID,\n            COLLECTION_ID,\n            FACT_TYPE_ID,\n            make_payload(PAYLOAD),\n        );\n    }\n\n    #[test]\n    unconstrained fn records_and_reads_a_fact() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.contract_address, contract_address);\n            assert_eq(collection.scope, scope);\n            assert_eq(collection.fact_collection_type_id, TYPE_ID);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n            assert(fact.origin_block.is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn reads_collections_by_type() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 1);\n\n            let collection = collections.get(0);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n        });\n    }\n\n    #[test]\n    unconstrained fn records_a_retractable_fact() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_retractable_fact(\n                contract_address,\n                scope,\n                TYPE_ID,\n                COLLECTION_ID,\n                FACT_TYPE_ID,\n                make_payload(PAYLOAD),\n                OriginBlock { block_number: 5, block_hash: 0xabc },\n            );\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n\n            let origin_block = fact.origin_block.unwrap();\n            assert_eq(origin_block.block_number, 5);\n            assert_eq(origin_block.block_hash, 0xabc);\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_a_fact_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn reading_unknown_collection_returns_none() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(collection.is_none());\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_record_for_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let other = AztecAddress::from_field(context.this_address().to_field() + 1);\n            record_fact(other, scope);\n        });\n    }\n\n    #[test]\n    unconstrained fn re_recording_an_identical_fact_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn deleting_a_non_existing_collection_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn recording_a_fact_after_delete_recreates_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            record_fact(contract_address, scope);\n            let collection_before_delete =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_before_delete.facts.len(), 1);\n\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n\n            record_fact(contract_address, scope);\n            let collection_after_recreate =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_after_recreate.facts.len(), 1);\n        });\n    }\n}\n"
+    },
+    "83": {
       "function_locations": [
         {
           "name": "compute_secret_hash",
@@ -3808,7 +4008,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE, DOM_SEP__PUBLIC_CALLDATA,\n        DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the prepended field.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n\n#[test]\nunconstrained fn secret_hash_matches_typescript() {\n    let secret = 8;\n    let hash = compute_secret_hash(secret);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let secret_hash_from_ts = 0x1848b066724ab0ffb50ecb0ee3398eb839f162823d262bad959721a9c13d1e96;\n\n    assert_eq(hash, secret_hash_from_ts);\n}\n\n#[test]\nunconstrained fn var_args_hash_matches_typescript() {\n    let mut input = [0; 100];\n    for i in 0..100 {\n        input[i] = i as Field;\n    }\n    let hash = hash_args(input);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let var_args_hash_from_ts = 0x262e5e121a8efc0382566ab42f0ae2a78bd85db88484f83018fe07fc2552ba0c;\n\n    assert_eq(hash, var_args_hash_from_ts);\n}\n\n#[test]\nunconstrained fn compute_calldata_hash() {\n    let mut input = [0; 100];\n    for i in 0..input.len() {\n        input[i] = i as Field;\n    }\n    let hash = hash_calldata_array(input);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let calldata_hash_from_ts = 0x14a1539bdb1d26e03097cf4d40c87e02ca03f0bb50a3e617ace5a7bfd3943944;\n\n    // Used in cpp vm2 tests:\n    assert_eq(hash, calldata_hash_from_ts);\n}\n\n#[test]\nunconstrained fn public_bytecode_commitment() {\n    let mut input = [0; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS];\n    let len = 99;\n    for i in 1..len + 1 {\n        input[i] = i as Field;\n    }\n    input[0] = (len as Field) * 31;\n    let hash = compute_public_bytecode_commitment(input);\n    // Used in cpp vm2 tests:\n    assert_eq(hash, 0x09348974e76c3602893d7a4b4bb52c2ec746f1ade5004ac471d0fbb4587a81a6);\n}\n"
     },
-    "98": {
+    "99": {
       "function_locations": [
         {
           "name": "log_prefix",
@@ -3906,11 +4106,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": "constructor"
     },
@@ -5786,11 +5986,11 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "entrypoint",
       "verification_key": "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"
@@ -5843,11 +6043,11 @@
           "visibility": "public"
         }
       },
-      "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": "lookup_validity"
     },
@@ -7634,12 +7834,12 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private",
         "abi_view"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "verify_private_authwit",
       "verification_key": "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"
@@ -7647,10 +7847,6 @@
     {
       "abi": {
         "error_types": {
-          "12913276134398371456": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
           "14990209321349310352": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
@@ -7662,10 +7858,6 @@
           "9530675838293881722": {
             "error_kind": "string",
             "string": "Writer did not write all data"
-          },
-          "992401946138144806": {
-            "error_kind": "string",
-            "string": "Attempted to read past end of BoundedVec"
           }
         },
         "parameters": [
@@ -7774,11 +7966,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/+2dd3xUxRbHk9300El200hBwV6QYi8QQEEQJURUVFyTJayEJCQbJCDCClhRkwD2CiSgiA072LucsXdBRezYsWJ7E2R3J/femd27+fH8vPcZ/jrJ7HzPuXNmzsyZvZw4m5uuuLN60qSyyR5f1cRab5nXN93bFFg1pNZXWemrKPZUVi6Oaw60DK6t9TRsiD9qUWNT81OFcep/8XERPxIXHSgeBXKgQE4UKAEFSkSBklCgZBQoBQVKRYHSUKB0FKgTCtQZBeqCAnVFgbqhQN1RoB4oUE8UKAMFykSBXCiQGwXKQoGyUaAcFCgXBcpDgXqhQPkoUAEKVIgCFaFAvVGgXVCgXVGgPihQXxRoNxRodxRoDxRoTxRoLxRobxRoHxRoXxRoPxRofxSoHwp0AArUHwUagAINRIEGoUAHokAHoUAHo0CHoECHokCHoUCHo0BHoEBHokBHoUCDUaAhKFAxCjQUBRqGAg1HgY5GgY5BgUagQCNRoGNRoFEo0GgU6DgUaAwKdDwKdAIKNBYFKkGBxqFApSjQiSjQeBToJBToZBToFBRoAgp0Kgp0Ggp0Ogo0EQU6AwXyoEBnokBlKFA5CuRFgSahQBUo0GQUyIcCnYUCTUGBKlGgqShQFQpUjQLVoEDTUKBaFKgOBfKjQPUo0HQU6GwUaAYK1IACzUSBZqFA56BAs1Ggc1GgOSgQzYWRAjDSeTDSPBhpPoy0AEY6H0a6AEa6EEa6CEa6GEa6BEZaCCNdCiNdBiNdDiM1wkhNMFIzjLQIRloMIy2Bka6Aka6Eka6Cka6Gka6Bka6Fka6Dka6HkW6AkW6EkW6CkW6GkZbCSMtgpOUwUguM1AojrYCRVsJIt8BIt8JIq2Ck22Ck1TDS7TDSHTDSnTDSXTDS3TDSGhjpHhjpXhjpPhjpfhjpARjpQRjpIRhpLYy0DkZ6GEZ6BEZ6FEZ6DEZ6HEZ6AkZ6EkZ6CkZ6GkZ6BkZ6FkZ6DkZ6HkZ6AUZaDyMRjMRgpBdhpJdgpJdhpFdgpFdhpNdgpNdhpDdgpDdhpLdgpLdhpHdgpHdhpPdgpA0w0kYY6X0Y6QMY6UMYaROM9BGMtBlG+hhG+gRG+hRG+gxG+hxG+gJG+hJG2gIjfQUjfQ0jfQMjfQsjfQcjfQ8j/QAjbYWRfoSRfoKRfoaRfoGRfoWRfoORtsFIv8NIf8BIf8JIf8FIf6NIDFeBieFqMDFcFSaGq8PEcJWYGK4WE8NVY2K4ekwMV5GJ4WoyMVxVJoary8RwlZkYrjYTw1VnYrj6TAxXoYnhajQxXJUmhqvTxHCVmhiuVhPDVWtiuHpNDFexieFqNjFc1SaGq9vEcJWbGK52E8NVb2K4+k0MV8GJ4Wo4MVwVJ4ar48RwlZwYrpYTw1VzYrh6TgxX0YnhajoxXFUnhqvrxHCVnRiuthPDVXdiuPpODFfhieFqPDFclSeGq/PEcJWeGK7WE8NVe2K4ek8MV/GJ4Wo+MVzVJ4ar+8RwlZ8YrvYTw1V/YtHUfwq0lviqKiq90SKjqATVuKgx8n+nid8QPzgu3uFMSExKTklNS+/UuUvXbt179MzIdLmzsnNy83rlFxQW9d5l1z59d9t9jz332nuffffbv98B/QcMHHTgQQcfcuhhhx9x5FGDhxQPHTb86GNGjDx21Ojjxhx/wtiScaUnjj/p5FMmnHra6RPP8JxZVu6dVDHZd9aUyqlV1TXTauv89dPPntEwc9Y5s8+dQ3MpQOfRPJpPC+h8uoAupIvoYrqEFtKldBldTo3URM20iBbTErqCrqSr6Gq6hq6l6+h6uoFupJvoZlpKy2g5tVArraCVdAvdSqvoNlpNt9MddCfdRXfTGrqH7qX76H56gB6kh2gtraOH6RF6lB6jx+kJepKeoqfpGXqWnqPn6QVaT0SMXqSX6GV6hV6l1+h1eoPepLfobXqH3qX3aANtpPfpA/qQNtFHtJk+pk/oU/qMPqcv6EvaQl/R1/QNfUvf0ff0A22lH+kn+pl+oV/pN9pGv9Mf9Cf9RX/zW0l+m8hvAfntHb9147dl/JaL307xWyV+G8RvcfjtC7814bcd/JaC3y7wWwGezfMsnGfPPOvl2SrPMnl2yLM6no3xLIpnPzxr4dkGzxL46Z6fyvlpmp+C+emVnzr5aZGf8vjpjJ+q+GmIn2L46YOfGvhuz3dpvrvyXZHvZnwX4rsHj/o8WvMoy6Mjj2o8GvEowlc/X7V8tfFVwmc3n42NjXzemurlb3CeH2gprq6q8y8KtA718d/6HYEVI6r83gpv7bLS/pG3uXhj/3hb/QMLjP3jbPWPXxBY3lbqv4k5KkKklWO9lR4/f7wEe6zBZkKivdGIC9zWZk25x+8prq5pCD3UUNEmAc5tFx69JCyIWg2fKg0LwU8tLe1n+ND4sBBGDRpg+FRFWFAo9IUFucIpYUGhcFZYUCicHRbkCueEBYVCulyQFCqpSZDkSkmUVGqXCZJKbYsgKdSuECSV2vsFSaX2QUFSqF0rSCq16wVJpZYJkkLtS4KkUvuBIKnUbhIkhdrNgqRSu1WQVGp/EiSF2l8ESaGWbzeiqFDMtyRRlKvmu5YoKpXniqJSeS9RVCkvEEWl8v1EUam8nyiqlPcXRaXyYlFUKh8miirlR4uiUvl4UVQqP1kUVconiKJS+RRRVCqfKooq5dWiqFQ+RxSVygOiqFI+TxSVyueLYjvlphOCzfPS0A6fMc4ILBtdPb1ZPFGEjl4mdpI9tiewaoivylPbwDuNqVkSAi8bXF6+/fFDmgQNq0dUlW//bceOX/wo2V55WEVIvfmZHcbRSBFdY2hLFc02jVW6PXO7GulpCj90ssfuZt8PneR+SAP5oZPZD2lGP+z40Sk6pF1Lgmhyu5ZE0RXBU70v0FLir671WnsxDeBFycOmmB82RdQi6ZZq7pYaHqPlo6o95cKjJItw1YMm2zIzpE8bqY38vzBSB2sdrHWw1kZqI3Ww1sFaB2u9erWR2kgdrHWw1sFahxhtpA7WOljrYK2DtTZSG6mDtQ7WOljr1auN1EbqYK2DtQ7WOsRoI3Ww1sFaB2sdrLWR2kgdrHWw1sFar15tpDZSB2sdrHWw1kZqI3Ww1sFaB2u9erWR2kgdrHWw1sFar15tpA7WOljrYK2DtTZSG6mDtQ7WOljr1auN1EbqYK2DtQ7WOsRoI3Ww1sFaB2sdrLWR2sh/0UhDqHWExQRjmzPYq628eTCM+Dta2zx+gZngtPv3U5bz0axpsn4Op/FvxRS3DPd5K8s5dmPZ/tUXLPH+tnLCCY0zFk5mo24tSfrqtYHbWiZvfn7duh9ax3r99bVV1ltGsnHLcIbDbbvomxL+QLvfp4YD9/KR9VNr+GBOC86ZHS1JYUZwvhg7J1lbl2K0TjpPgkBjh9QIHdJWjvLW1Y2b7KmyVJMcaG17qBGTQianMcfU0IgO5w/jq6hqm0RL1npm+r1lE+v9lRMrvP5Sv6/S52/gLvN7Z/g3xLkDq0d7p1bXNnD7arlGcZnIWlKkLanSljRpS7q0pZO0pbO0pYu0pau0pZu0pbu0pYe0pae0JUPakiltcUlb5J7LkrZkS1typC250pY8aUuvtonVWuKbWlPp/Scc/K/91P4PTET6yKABtpjLS/sdcJD6t5EtbWw0R/bkUOyNFNINm0+iIgdIsbdddLefA6TIc4BEUA5gsbcnKnKq1I7lPerTwUpjiiFESaEtuG0FzKeZtChOM2nKrEfSKb39tmOlMDW89YS7McecDk+cOJUblpb2i8L5LR1MIbt1OC9L6nAObfEUne0RLOZzF3sEp5nQ1R4hwUzoZo+QaCZ0j/JoudXctYfd9NpE6GmP0NP8F4Hk6z7Jat03yxZphmSRJrRLJkyLNIM5rgrBl8jgDmWgbHeyfKdP+GhZ520L3f5aT5m/pKGqrNhTNtk7omq6p9LHN6pF8oNC4JZjvJ6awbW1ngYxv5AfyZIWGTbFln86N7X/dTfLjTx4QLYcnGuCWZezvAMjn2YNvz4Er5DCl42ur5RypTc3brPDHBHjvMvcyS0eVI3JtUsUozckQ4yCkm7ZsdifZe6ULT6K0f4sUYzJ/s6ybjmx2G/x0Dkq+7NFMSb7u8i65cZiv8VD56rszxHFmOyXXnjmxWK/xUPnqezPFcWY7O8GtT/Dpv0ZqsXtjm1xu4Xzs/GA6mr3MVNAzGGOdaGt6CHjbpgpnm6Dn3rcGvOoeaN2277eGlfrabveMicmboVpuYJpxhHNi2JE86xcGNWI5hmtyldkbwV2z462s7cCefaWD8reCsxjlS85lNzT7rqr2FNTV1/Jx1F+h2F5ACmIbzYdINr+eqX1YSN+seKAY2gJ3pLGcOuVvbijNxd2hlcwyDi9C0Rxx5/ptOqZt0Pt6n/Ubv9hTM1icQ3wI49lVzO3QHSa1d8etcTssMD4kTzZHJXbun2Qwj92FwmG9ZijWI82l0SG/fWYL1+POaD1mG91fJHfphTaTZ0kagvNagsVbigS24LBeqM5tBaJ+41EdZFZdVHEXbq3JF0oEu03b2u9meM905rLj2JLyVeGSdWWkv9f12fwlXAGMWXHuWJb0I+fS42SDLqgoYfFoOcz53Eh+BZTwBBsz1IHU7dEv/AUPS30u5njWyFHlL2VkGP8ui3BbjwJ6jjL7ILQN2zRZ13uiIvAYpJkiaNimibRzDyXMv+Q5ppZtwd9M2xavaeyTkpwWXgoizm2hUZvtlSFxP0utfs5/M8o3O/eee7Piuj+HCtPxpBp5YijYnK/4AU7qa4rCvfnKN0fMWdxpkR2vyty9LFyv4s506Nwf9bOc78rFve7Ouh+t9L9mTJopvL2KsbV7xYVWy1Qp0twv3F/EG/P1PuD7A4xUz1DMpgzJ4oZ4tp5MyQjlv0hI5arpCxxVEwzpN38iX5/yIxihriVMyRTvT+4mbNP5ACR2Roh9lg5P5M5dw+h59pYFhmRs+S6UJbc2Ggjjw21FFhn0Jk9Y81jrXPsntGlsuqLManjM5WOz2s3oFbe2VcRGjLNoUG2sizyRddOv79xyfPFDFC+6FLOTHkqYHE8cMe2P+y8hRC60LFeBvHYZRAf5TKQbDLCF43WX1Q5Dw3N5HnSTSaxg5tM945sMpmxbDLq/SBJmatm27AkKYpY41LGmiT1MYQfFIdHcQo1W5bQ4e0vIeL2N1KwTP7tt8v88pHgSfk345mRvxkvjOWImq+8VXKrbkbypYbEdglQyJzj/t1LgMKI66/Iargi3oRZXZ8Jo2Jaf72jGOT82C4BiqK9BMi38FARc06MvP6KIiQo8h2vyHyXLAyz/GIsX7gYM27noS1ffGFRPkk6P/3AmE2/1vQ1fy8W9HLwNYoOKvo45fhhjnsXFkRWJHlv2yl5d1w8Yhv7OExvTicz5yzj/+gJWRLtaSq0EKN7/dsZ7tBOc5rkbfb0sGk7/Ow82zAqKWGG4W329PBHrN81N1qXFuHl9HRjh/QIHTpZvs2eJrwMb/BJJ+ask00v26+EBkfsHImXnaD5/HLylh/XP1PRuNMXzvziJ/f56LM1M3e6ojUD9z6k80l950ZU9B8WrsVu+fcAAA==",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "tZnRbhs5DEX/xc95ECWKEvMrQVG4qbswYDiBmyywKPLvS2Z05UkWErx2+xKdJJ4zFIeUZPvX5vvu2+tfX/fHH08/N/cPvzbfTvvDYf/X18PT4/Zl/3S0v/7aBP8hsW7u052NurkXG1NoI7UxtjG1kduY2yhtLG2sbWw+bj5uPm6+bK8rNor9XX2MbTQ/kUMG2B3IQ5QCqABtUAKAABGQAAzIAJgLzAXmAnOFucJcYa4wV5grzBXmCnOFucKsMCvMCrPCrDBrM5fgV2UHAkSAv0YcBFAAdvcYHLQBBQABIiAB7O7RL6cMEEABuLk4aIMYAG5WBzMnDz4mAAMyQAAFUAHawGtzAQLAnGBOMHuBJk+LV+gCBeBmj9CL9B28Shfwyz1mthczOdiL2YWsDXIAWBjMDhGQAAzIAAEUgJs9nqwNJAAI4GYPTBKAAW6uDgIogArQBt4gCxDAzT5Tb5AFGJABZs6eBG+QBSrAzDkaeIMsQIAISAAGZICbPYfeIAtUgDbwBsmeKG+Q7MXmDbJAArjZs+ENsoAACqACdIHqTbSAm6tDBCQAA3ylCw4CKABf7MhBG3hbSXQgQAQkgC+h4uBmv4W31QIFUAHawNtqAQK4WR0SwMzFw/C2Kn4vb6sFzFySQwVoA2+rBQgQAQngZnbIAAEUgJuzgzbwtlqAAH6Vz937a4EK8Kt8Ft5fCxDA4qmecO+vBRiQAQIogAowc/W0eH8tQIAI8JmWt7e7DTbJry+n3c73yNWuaXvp8/a0O75s7o+vh8Pd5u/t4fX9RT+ft8f38WV7sv/abXfH7zaa8Mf+sHN6uztfHcaXUuSQ2+XGHLuCAn2Q0FjCvji/K5hLF5SP18fx9SljBqnUcwC1/o9ZeCW2WeQsw1nwWJIlYBpZYjor5GM281gRk+9F74qYVqmQy2PQhBhs+xzGMFHY4QnZtPNRGSrqWFF6ImwpXz2Py6dRegy5rGvqUww0eaZRqedSax7kcm5QlHYKlEaGWWHa2gZDZb7iedqqjUTY8jhOxMShXaHxXBGW1Utj0IRESgjlqpoKdFbEscJfNexRFVQVaVnl8pNiUpdU/GEtCjslDBU6SSYhCK3rpSZfblBGDIHyUBEn62WMDEeMuY6eaZxUJoXYUxEyjcNIs+Lsjmzb1ioM/eiYVkbQc2WEsWO2ajKaLEpZGeS6wtBxYZTZM0nUnwmnkSJOopCcey6y8lVRkJw3EBpGkSarHue+GZdxXaTZdk6C8mTSuHoi5aNjVp+5P5B8ngancHkUkfBA7MY6joJn54KC7ZQS53EcE0cqTH0PoDCOQ/6sg4S451SopGGvpUmNau4HDF3X6H8c00jSeQ20z1rGXc+TOk1yPvTx8MlMDYx2S+vV67NhUqUcEpYeDlzG84izMx/mEXO8KopY+/pXZVyjZXp07Su5lcl4HvIbciE350JuzoXcnoscbs/FzHFZLqaGm3Nhwdc+D6Gruv3iXOQ/67gwn/nmfE73JMX2zGmyjmf9DXvSrD4LVr7MYXyKnR00UsUxwT4BuO6swtRPsXl1BP2kkHTrWUVmu3NQdHsiGu+JMqmLFKVvJLHGKx19KqarY0e5tcKn+byoLmbH+VjQI7Juks9v9MqkOIUrDjvCWgdvmueGwv0gHekaQ06xGzJfZaipG+oVb/3tSy3pn8PQ+D3z9LQm/d2VCsl1J761I407pPyG80Wpt+8BM8dlHTI1jPeAL/br9nF/+vDF5ZurTvvtt8Ou/frj9fi4+u/LP8/4D774fD49Pe6+v552bjp/+2k/HqoVdtX45W5jnwA/2Cn+zjrOfvMP8B+q6p0G+vLmsfwL",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "offchain_receive"
     },
@@ -7811,11 +8003,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/9WUy07CQBSGh4tXvN/d+QqiMW61hMQFGwhr0tCTZpKhJe2BWFfOG0xB3bniohF9Arc+hg8j3UDBHJq6MKG7znfON/+0M5Nq+U9vrmdVKy7qCL4cXDtcCG5quhAPzJf9ErdMAW3lt75O2OwnwSJLmGorFS3ymVLDGUPJnmVPsy0X27Kf4w5UMSlfbiwEE5xO+SwbrZzuT8Tqv89N97N484/7X4sgdORNSP11BSNDOp6Byffgtxo66ppd90ZL0cKZQvJOwW62xgPJcX038PiZ34mS//1VmOyW0K77EzlDskHedoCbVhD48VO/Q6hWGigqJmAZueDoDQMg3OI3O5QfBajZjndlGA64blhDkTRJFkiySJIlkiyTZIUkqyTJkGSNJOsk2SDJJkm2SLJNkh2S7JJkjyT7JDkgCb1DjkhyHGys4S1aqwvo5TkIY97eJg5kZMnFeSxnt3yavZw9Gp1UqX4RsOFYP/ZQob7PBgAA",
+      "bytecode": "H4sIAAAAAAAA/9XUy07CQBQG4OHiFe93XfkKojFutYTEBRsIa9LQk2aSoSXtgVhXzhtMQd254qIRfQK3PoYPI91AwRyaujCxu843558z7bSplv/46npWteKijuDLwZXDheCmpgtxz3zZL3HLFNBWfuvzmM2+EixyClNtpaKDfKbUcMVQZ0+yp9mWi23Zz3EHqpiUz9cWgglOp3yajY6crk/Eqr/LTdezeOuP61+KIHTkTUj9dgejhHS8BCbfgtdq6Khrdt0bbUUL9xQK7xTsZms8kBzP7wY5fuZnR8m/fipMdkto1/2JPkNhg7ztADetoOGHD/0WoVppoKiYgGXkgqM3bADhBr/YgXwvQM12vEvDcMB1wzGUpEmZI2WelAVSFklZImWZlAwpK6SskrJGyjopG6RskrJFyjYpO6TskrJHyj4p9Nk5JOUoOHLD/2utLqCX5yCM/3Y38alGTjk/i5XZLZ9kL2aPxu1bqX4RsOFY312tuID3BgAA",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "dZHLDoQgDEX/pWsX4GN8/MpkYlCrISFIECaZGP59wIiPhRvacntPoF1hwM5OLZfjvEDzXqHTXAg+tWLumeGz9LcrkHBQCk3mXAJRao1GDMql1xMU0ygNNNIKkcCXCbs1LYrJLRqmvUoSQDn46IEjFxgyl5xu8mylpC6K3e7zOj0QlNAbhD5D8vS1I/K8PADl3Z8++7Mi/iArq/MBVeXcx5es5/o2QxdQmrNO4F6OVvYX1fxUVOIOlJ57HKzGQNo0z/4D",
+      "debug_symbols": "dZFNDoQgDIXv0rULkBBHrzKZGNRqSAgahEkmhrtPMf4u3NCW1/el0AU6bMJQa9uPM1TvBRqnjdFDbcZWeT1aul2ApYNzqESMGexS7R1iUi69RJiUQ+uhssGYDL7KhLVpnpRdo1eOVJYB2o4iAXttMGUxO93s2cpZKeVmp7zMDwRn+Q3CnyGS5xtCCnEACn7z589+IfcXiOJ1DkDDxA+VqtXu9ocxoZxWjcGt7INtL6r/Tbuy72ByY4tdcJhIq0bsPw==",
       "is_unconstrained": true,
       "name": "sync_state"
     },
@@ -8212,5 +8404,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "5.0.0-rc.1"
+  "aztec_version": "5.0.0-rc.2"
 }