@aztec/protocol-contracts 0.0.1-commit.9badcec54 → 0.0.1-commit.9ebd450e8

package/artifacts/PublicChecks.json

@@ -22,35 +22,35 @@
       "function_locations": [
         {
           "name": "AztecConfig::new",
-          "start": 1648
+          "start": 1825
         },
         {
           "name": "AztecConfig::custom_message_handler",
-          "start": 2156
+          "start": 2333
         },
         {
           "name": "aztec",
-          "start": 3050
+          "start": 3227
         },
         {
           "name": "generate_contract_interface",
-          "start": 6527
+          "start": 6704
         },
         {
           "name": "generate_sync_state",
-          "start": 8389
+          "start": 8566
         },
         {
           "name": "generate_offchain_receive",
-          "start": 9443
+          "start": 9620
         },
         {
           "name": "check_each_fn_macroified",
-          "start": 11087
+          "start": 11209
         }
       ],
       "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        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,\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. These are advanced features that require careful understanding of\n/// 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}\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() }\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(_self: Self, handler: CustomMessageHandler<()>) -> Self {\n        Self { custom_message_handler: Option::some(handler) }\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) and `sync_state` functions 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    let sync_state_fn_and_abi_export = if !m.functions().any(|f| f.name() == quote { sync_state }) {\n        generate_sync_state(process_custom_message_option, offchain_inbox_sync_option)\n    } else {\n        quote {}\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(process_custom_message_option: Quoted, offchain_inbox_sync_option: Quoted) -> Quoted {\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            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\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    quote {\n        pub struct offchain_receive_parameters {\n            pub messages: BoundedVec<\n                aztec::messages::processing::offchain::OffchainMessage,\n                aztec::messages::processing::offchain::MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL,\n            >,\n        }\n\n        #[abi(functions)]\n        pub struct offchain_receive_abi {\n            parameters: offchain_receive_parameters,\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(\n            messages: BoundedVec<\n                aztec::messages::processing::offchain::OffchainMessage,\n                aztec::messages::processing::offchain::MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL,\n            >,\n        ) {\n            let address = aztec::context::UtilityContext::new().this_address();\n            aztec::messages::processing::offchain::receive(address, messages);\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"
+      "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,\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. These are advanced features that require careful understanding of\n/// 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}\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() }\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(_self: Self, handler: CustomMessageHandler<()>) -> Self {\n        Self { custom_message_handler: Option::some(handler) }\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) and `sync_state` functions 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    let sync_state_fn_and_abi_export = if !m.functions().any(|f| f.name() == quote { sync_state }) {\n        generate_sync_state(process_custom_message_option, offchain_inbox_sync_option)\n    } else {\n        quote {}\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(process_custom_message_option: Quoted, offchain_inbox_sync_option: Quoted) -> Quoted {\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            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\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"
     },
     "107": {
       "function_locations": [
@@ -76,7 +76,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/public.nr",
       "source": "use crate::macros::{\n    internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},\n    utils::{\n        fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self, is_fn_view,\n        module_has_initializer, module_has_storage,\n    },\n};\n\npub(crate) comptime fn generate_public_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    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n\n    let args_len_quote = if original_params.len() == 0 {\n        // If the function has no parameters, we set the args_len to 0.\n        quote { 0 }\n    } else {\n        // The following will give us <type_of_struct_member_1 as Serialize>::N + <type_of_struct_member_2 as\n        // Serialize>::N + ...\n        original_params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n            <$param_type as $crate::protocol::traits::Serialize>::N\n        }\n            })\n            .join(quote {+})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            let storage = Storage::init(context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelfPublic requires\n        // a storage struct in its constructor. Using an Option type would lead to worse developer experience and\n        // higher constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            let context = aztec::context::PublicContext::new(|| {\n            // We start from 1 because we skip the selector for the dispatch function.\n            let serialized_args : [Field; $args_len_quote] = aztec::oracle::avm::calldata_copy(1, $args_len_quote);\n            aztec::hash::hash_args(serialized_args)\n            });\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<aztec::context::PublicContext> = CallSelf { address: self_address, context };\n            let call_self_static: CallSelfStatic<aztec::context::PublicContext> = CallSelfStatic { address: self_address, context };\n            let internal: CallInternal<aztec::context::PublicContext> = CallInternal { context };\n            aztec::contract_self::ContractSelfPublic::new(context, storage, call_self, call_self_static, internal)\n        };\n    };\n\n    let original_function_name = f.name();\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_only_self(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called by the same contract\";\n        quote { assert(self.msg_sender() == self.address, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called statically\".as_quoted_str();\n        quote { assert(self.context.is_static_call(), $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (\n            quote { aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_public(self.context); },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_from_public_initializer(self.context); },\n        )\n    } else {\n        (quote {}, quote {})\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_public(self.context); }\n    } else {\n        quote {}\n    };\n\n    // Inject the authwit check if the function is marked with #[authorize_once].\n    let authorize_once_check = if fn_has_authorize_once(f) {\n        create_authorize_once_check(f, false)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $contract_self_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $authorize_once_check\n    };\n\n    // `mark_as_initialized` is placed after the user's function body. If it ran at the beginning, the contract\n    // would appear initialized while the initializer is still running, allowing contracts called by the initializer\n    // to re-enter into a half-initialized contract.\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n    let body = f.body();\n    let return_type = f.return_type();\n\n    // New function parameters are the same as the original function's ones.\n    let params = original_params.map(|(param_name, param_type)| quote { $param_name: $param_type }).join(quote {, });\n\n    // Preserve all attributes that are relevant to the function's ABI.\n    let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    quote {\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n        $abi_relevant_attributes\n        unconstrained fn $fn_name($params) -> pub $return_type {\n            $to_prepend\n            $body\n            $to_append\n        }\n    }\n}\n"
     },
-    "128": {
+    "129": {
       "function_locations": [
         {
           "name": "do_sync_state",
@@ -98,7 +98,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
       "source": "use crate::logging::{aztecnr_debug_log, aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::address::AztecAddress;\n\npub(crate) mod nonce_discovery;\npub(crate) mod partial_notes;\npub(crate) mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    messages::{\n        discovery::process_message::process_message_ciphertext,\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{\n            MessageContext, offchain::OffchainInboxSync, OffchainMessageWithContext,\n            pending_tagged_log::PendingTaggedLog, validate_and_store_enqueued_notes_and_events,\n        },\n    },\n    oracle::message_processing,\n    utils::array,\n};\n\npub struct NoteHashAndNullifier {\n    /// The result of [`crate::note::note_interface::NoteHash::compute_note_hash`].\n    pub note_hash: Field,\n    /// The result of [`crate::note::note_interface::NoteHash::compute_nullifier_unconstrained`].\n    ///\n    /// This value is unconstrained, as all of message discovery is unconstrained. It is `None` if the nullifier\n    /// cannot be computed (e.g. because the nullifier hiding key is not available).\n    pub inner_nullifier: Option<Field>,\n}\n\n/// A contract's way of computing note hashes.\n///\n/// Each contract in the network is free to compute their note's hash as they see fit - the hash function itself is not\n/// enshrined or standardized. Some aztec-nr functions however do need to know the details of this computation (e.g.\n/// when finding new notes), which is what this type represents.\n///\n/// This function takes a note's packed content, storage slot, note type ID, address of the emitting contract and\n/// randomness, and attempts to compute its inner note hash (not siloed by address nor uniqued by nonce).\n///\n/// ## Transient Notes\n///\n/// This function is meant to always be used on **settled** notes, i.e. those that have been inserted into the trees\n/// and for which the nonce is known. It is never invoked in the context of a transient note, as those are not involved\n/// in message processing.\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract by inspecting all note types in use and the storage layout. This injected function is a\n/// `#[contract_library_method]` called `_compute_note_hash`, and it looks something like this:\n///\n/// ```noir\n/// |packed_note, owner, storage_slot, note_type_id, _contract_address, randomness| {\n///     if note_type_id == MyNoteType::get_id() {\n///         if packed_note.len() != MY_NOTE_TYPE_SERIALIZATION_LENGTH {\n///             Option::none()\n///         } else {\n///             let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///             Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n///         }\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\npub type ComputeNoteHash = unconstrained fn(/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /*\n owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /*\nrandomness */ Field) -> Option<Field>;\n\n/// A contract's way of computing note nullifiers.\n///\n/// Like [`ComputeNoteHash`], each contract is free to derive nullifiers as they see fit. This function takes the\n/// unique note hash (used as the note hash for nullification for settled notes), plus the note's packed content and\n/// metadata, and attempts to compute the inner nullifier (not siloed by address).\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract called `_compute_note_nullifier`. It dispatches on `note_type_id` similarly to\n/// [`ComputeNoteHash`], then calls the note's\n/// [`compute_nullifier_unconstrained`](crate::note::note_interface::NoteHash::compute_nullifier_unconstrained) method.\npub type ComputeNoteNullifier = unconstrained fn(/* unique_note_hash */Field, /* packed_note */ BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/* randomness */ Field) -> Option<Field>;\n\n/// Deprecated: use [`ComputeNoteHash`] and [`ComputeNoteNullifier`] instead.\npub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/*randomness */ Field, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// A handler for custom messages.\n///\n/// Contracts that emit custom messages (i.e. any with a message type that is not in [`crate::messages::msg_type`])\n/// need to use [`crate::macros::AztecConfig::custom_message_handler`] with a function of this type in order to\n/// process them. They will otherwise be **silently ignored**.\npub type CustomMessageHandler<Env> = unconstrained fn[Env](\n/* contract_address */AztecAddress,\n/* msg_type_id */ u64,\n/* msg_metadata */ u64,\n/* msg_content */ BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n/* message_context */ MessageContext,\n/* scope */ AztecAddress);\n\n/// Synchronizes the contract's private state with the network.\n///\n/// As blocks are mined, it is possible for a contract's private state to change (e.g. with new notes being created),\n/// but because these changes are private they will be invisible to most actors. This is the function that processes\n/// new transactions in order to discover new notes, events, and other kinds of private state changes.\n///\n/// The private state will be synchronized up to the block that will be used for private transactions (i.e. the anchor\n/// block. This will typically be close to the tip of the chain.\npub unconstrained fn do_sync_state<CustomMessageHandlerEnv>(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler<CustomMessageHandlerEnv>>,\n    offchain_inbox_sync: Option<OffchainInboxSync<()>>,\n    scope: AztecAddress,\n) {\n    aztecnr_debug_log!(\"Performing state synchronization\");\n\n    // First we process all private logs, which can contain different kinds of messages e.g. private notes, partial\n    // notes, private events, etc.\n    let logs = message_processing::get_pending_tagged_logs(scope);\n    logs.for_each(|_i, pending_tagged_log: PendingTaggedLog| {\n        if pending_tagged_log.log.len() == 0 {\n            aztecnr_warn_log_format!(\"Skipping empty log from tx {0}\")([pending_tagged_log.context.tx_hash]);\n        } else {\n            aztecnr_debug_log_format!(\"Processing log with tag {0}\")([pending_tagged_log.log.get(0)]);\n\n            // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n            let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                message_ciphertext,\n                pending_tagged_log.context,\n                scope,\n            );\n        }\n    });\n\n    if offchain_inbox_sync.is_some() {\n        let msgs = offchain_inbox_sync.unwrap()(contract_address, scope);\n        msgs.for_each(|_i, msg: OffchainMessageWithContext| {\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                msg.message_ciphertext,\n                msg.message_context,\n                scope,\n            );\n        });\n    }\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::fetch_and_process_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        scope,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_and_store_enqueued_notes_and_events(scope);\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::{\n        discovery::{CustomMessageHandler, do_sync_state},\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{offchain::OffchainInboxSync, pending_tagged_log::PendingTaggedLog},\n    };\n    use crate::protocol::address::AztecAddress;\n    use crate::test::helpers::test_environment::TestEnvironment;\n\n    #[test]\n    unconstrained fn do_sync_state_does_not_panic_on_empty_logs() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            // Mock the oracle call to return a known base slot, then populate an ephemeral\n            // array at that slot so do_sync_state processes a non-empty log list.\n            let base_slot = 42;\n            let mock = std::test::OracleMock::mock(\"aztec_utl_getPendingTaggedLogs_v2\");\n            let _ = mock.returns(base_slot);\n\n            let logs: EphemeralArray<PendingTaggedLog> = EphemeralArray::at(base_slot);\n            logs.push(PendingTaggedLog { log: BoundedVec::new(), context: std::mem::zeroed() });\n            assert_eq(logs.len(), 1);\n\n            let no_handler: Option<CustomMessageHandler<()>> = Option::none();\n            let no_inbox_sync: Option<OffchainInboxSync<()>> = Option::none();\n            do_sync_state(\n                contract_address,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n                no_handler,\n                no_inbox_sync,\n                scope,\n            );\n        });\n    }\n\n    unconstrained fn dummy_compute_note_hash(\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n\n    unconstrained fn dummy_compute_note_nullifier(\n        _unique_note_hash: Field,\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n}\n"
     },
-    "129": {
+    "130": {
       "function_locations": [
         {
           "name": "attempt_note_nonce_discovery",
@@ -156,7 +156,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/nonce_discovery.nr",
       "source": "use crate::messages::{discovery::{ComputeNoteHash, ComputeNoteNullifier}, logs::note::MAX_NOTE_PACKED_LEN};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::MAX_NOTE_HASHES_PER_TX,\n    hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n    traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub(crate) struct DiscoveredNoteInfo {\n    pub(crate) note_nonce: Field,\n    pub(crate) note_hash: Field,\n    pub(crate) inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub(crate) unconstrained fn attempt_note_nonce_discovery(\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) -> BoundedVec<DiscoveredNoteInfo, MAX_NOTE_HASHES_PER_TX> {\n    let discovered_notes = &mut BoundedVec::new();\n\n    aztecnr_debug_log_format!(\n        \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n    )(\n        [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n    );\n\n    let maybe_note_hash = compute_note_hash(\n        packed_note,\n        owner,\n        storage_slot,\n        note_type_id,\n        contract_address,\n        randomness,\n    );\n\n    if maybe_note_hash.is_none() {\n        aztecnr_warn_log_format!(\n            \"Unable to compute note hash for note of id {0} with packed length {1}, skipping nonce discovery\",\n        )(\n            [note_type_id, packed_note.len() as Field],\n        );\n    } else {\n        let note_hash = maybe_note_hash.unwrap();\n        let siloed_note_hash = compute_siloed_note_hash(contract_address, note_hash);\n\n        // We need to find nonces (typically just one) that result in the siloed note hash that being uniqued into one\n        // of the transaction's effects.\n        // The nonce is meant to be derived from the index of the note hash in the transaction effects array. However,\n        // due to an issue in the kernels the nonce might actually use any of the possible note hash indices - not\n        // necessarily the one that corresponds to the note hash. Hence, we need to try them all.\n        for i in 0..MAX_NOTE_HASHES_PER_TX {\n            let nonce_for_i = compute_note_hash_nonce(first_nullifier_in_tx, i);\n            let unique_note_hash_for_i = compute_unique_note_hash(nonce_for_i, siloed_note_hash);\n\n            let matching_notes = bvec_filter(\n                unique_note_hashes_in_tx,\n                |unique_note_hash_in_tx| unique_note_hash_in_tx == unique_note_hash_for_i,\n            );\n            if matching_notes.len() > 1 {\n                let identical_note_hashes = matching_notes.len();\n                // Note that we don't actually check that the note hashes array contains unique values, only that the\n                // note we found is unique. We don't expect for this to ever happen (it'd indicate a malicious node or\n                // PXE, which are both assumed to be cooperative) so testing for it just in case is unnecessary, but we\n                // _do_ need to handle it if we find a duplicate.\n                panic(\n                    f\"Received {identical_note_hashes} identical note hashes for a transaction - these should all be unique\",\n                )\n            } else if matching_notes.len() == 1 {\n                let maybe_inner_nullifier_for_i = compute_note_nullifier(\n                    unique_note_hash_for_i,\n                    packed_note,\n                    owner,\n                    storage_slot,\n                    note_type_id,\n                    contract_address,\n                    randomness,\n                );\n\n                if maybe_inner_nullifier_for_i.is_none() {\n                    // TODO: down the line we want to be able to store notes for which we don't know their nullifier,\n                    // e.g. notes that belong to someone that is not us (and for which we therefore don't know their\n                    // associated app-siloed nullifer hiding secret key).\n                    // https://linear.app/aztec-labs/issue/F-265/store-external-notes\n                    aztecnr_warn_log_format!(\n                        \"Unable to compute nullifier of unique note {0} with note type id {1} and owner {2}, skipping PXE insertion\",\n                    )(\n                        [unique_note_hash_for_i, note_type_id, owner.to_field()],\n                    );\n                } else {\n                    // Note that while we did check that the note hash is the preimage of a unique note hash, we\n                    // perform no validations on the nullifier - we fundamentally cannot, since only the application\n                    // knows how to compute nullifiers. We simply trust it to have provided the correct one: if it\n                    // hasn't, then PXE may fail to realize that a given note has been nullified already, and calls to\n                    // the application could result in invalid transactions (with duplicate nullifiers). This is not a\n                    // concern because an application already has more direct means of making a call to it fail the\n                    // transaction.\n                    discovered_notes.push(\n                        DiscoveredNoteInfo {\n                            note_nonce: nonce_for_i,\n                            note_hash,\n                            inner_nullifier: maybe_inner_nullifier_for_i.unwrap(),\n                        },\n                    );\n                }\n                // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n                // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n                // notes containing random values in order to hide their contents.\n            }\n        }\n    }\n\n    *discovered_notes\n}\n\n// There is no BoundedVec::filter in the stdlib, so we use this until that is implemented.\nunconstrained fn bvec_filter<Env, T, let MAX_LEN: u32>(\n    bvec: BoundedVec<T, MAX_LEN>,\n    filter: fn[Env](T) -> bool,\n) -> BoundedVec<T, MAX_LEN> {\n    let filtered = &mut BoundedVec::new();\n\n    bvec.for_each(|value| {\n        if filter(value) {\n            filtered.push(value);\n        }\n    });\n\n    *filtered\n}\n\nmod test {\n    use crate::{\n        messages::logs::note::MAX_NOTE_PACKED_LEN,\n        note::{\n            note_interface::{NoteHash, NoteType},\n            note_metadata::SettledNoteMetadata,\n            utils::compute_note_hash_for_nullification,\n        },\n        oracle::random::random,\n        test::mocks::mock_note::MockNote,\n        utils::array,\n    };\n\n    use crate::protocol::{\n        address::AztecAddress,\n        hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n        traits::{FromField, Packable},\n    };\n\n    use super::attempt_note_nonce_discovery;\n\n    // This implementation could be simpler, but this serves as a nice example of the expected flow in a real\n    // implementation, and as a sanity check that the interface is sufficient.\n\n    unconstrained fn compute_note_hash(\n        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        owner: AztecAddress,\n        storage_slot: Field,\n        note_type_id: Field,\n        _contract_address: AztecAddress,\n        randomness: Field,\n    ) -> Option<Field> {\n        if (note_type_id == MockNote::get_id()) & (packed_note.len() == <MockNote as Packable>::N) {\n            let note = MockNote::unpack(array::subarray(packed_note.storage(), 0));\n            Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n        } else {\n            Option::none()\n        }\n    }\n\n    unconstrained fn compute_note_nullifier(\n        unique_note_hash: Field,\n        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        owner: AztecAddress,\n        _storage_slot: Field,\n        note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        if (note_type_id == MockNote::get_id()) & (packed_note.len() == <MockNote as Packable>::N) {\n            let note = MockNote::unpack(array::subarray(packed_note.storage(), 0));\n            note.compute_nullifier_unconstrained(owner, unique_note_hash)\n        } else {\n            Option::none()\n        }\n    }\n\n    global VALUE: Field = 7;\n    global FIRST_NULLIFIER_IN_TX: Field = 47;\n    global CONTRACT_ADDRESS: AztecAddress = AztecAddress::from_field(13);\n    global OWNER: AztecAddress = AztecAddress::from_field(14);\n    global STORAGE_SLOT: Field = 99;\n    global RANDOMNESS: Field = 99;\n\n    #[test]\n    unconstrained fn no_note_hashes() {\n        let unique_note_hashes_in_tx = BoundedVec::new();\n        let packed_note = BoundedVec::new();\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            packed_note,\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn failed_hash_computation_is_ignored() {\n        let unique_note_hashes_in_tx = BoundedVec::from_array([random()]);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            |_, _, _, _, _, _| Option::none(),\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::new(),\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn failed_nullifier_computation_is_ignored() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            |_, _, _, _, _, _, _| Option::none(),\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 0);\n    }\n\n    struct NoteAndData {\n        note: MockNote,\n        note_nonce: Field,\n        note_hash: Field,\n        unique_note_hash: Field,\n        inner_nullifier: Field,\n    }\n\n    unconstrained fn construct_note(value: Field, note_index_in_tx: u32) -> NoteAndData {\n        let note_nonce = compute_note_hash_nonce(FIRST_NULLIFIER_IN_TX, note_index_in_tx);\n\n        let hinted_note = MockNote::new(value)\n            .contract_address(CONTRACT_ADDRESS)\n            .owner(OWNER)\n            .randomness(RANDOMNESS)\n            .storage_slot(STORAGE_SLOT)\n            .note_metadata(SettledNoteMetadata::new(note_nonce).into())\n            .build_hinted_note();\n        let note = hinted_note.note;\n\n        let note_hash = note.compute_note_hash(OWNER, STORAGE_SLOT, RANDOMNESS);\n        let unique_note_hash = compute_unique_note_hash(\n            note_nonce,\n            compute_siloed_note_hash(CONTRACT_ADDRESS, note_hash),\n        );\n        let inner_nullifier = note\n            .compute_nullifier_unconstrained(OWNER, compute_note_hash_for_nullification(hinted_note))\n            .expect(f\"Could not compute nullifier for note owned by {OWNER}\");\n\n        NoteAndData { note, note_nonce, note_hash, unique_note_hash, inner_nullifier }\n    }\n\n    #[test]\n    unconstrained fn single_note() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test]\n    unconstrained fn multiple_notes_same_preimage() {\n        let first_note_index_in_tx = 3;\n        let first_note_and_data = construct_note(VALUE, first_note_index_in_tx);\n\n        let second_note_index_in_tx = 5;\n        let second_note_and_data = construct_note(VALUE, second_note_index_in_tx);\n\n        // Both notes have the same preimage (and therefore packed representation), so both should be found in the same\n        // call.\n        assert_eq(first_note_and_data.note, second_note_and_data.note);\n        let packed_note = first_note_and_data.note.pack();\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n        unique_note_hashes_in_tx.set(first_note_index_in_tx, first_note_and_data.unique_note_hash);\n        unique_note_hashes_in_tx.set(second_note_index_in_tx, second_note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(packed_note),\n        );\n\n        assert_eq(discovered_notes.len(), 2);\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == first_note_and_data.note_nonce)\n                & (discovered_note.note_hash == first_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == first_note_and_data.inner_nullifier)\n        }));\n\n        assert(discovered_notes.any(|discovered_note| {\n            (discovered_note.note_nonce == second_note_and_data.note_nonce)\n                & (discovered_note.note_hash == second_note_and_data.note_hash)\n                & (discovered_note.inner_nullifier == second_note_and_data.inner_nullifier)\n        }));\n    }\n\n    #[test]\n    unconstrained fn single_note_misaligned_nonce() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n\n        // The note is not at the correct index\n        unique_note_hashes_in_tx.set(note_index_in_tx + 1, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test]\n    unconstrained fn single_note_nonce_with_index_past_note_hashes_in_tx() {\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n\n        // The nonce is computed with an index that does not exist in the tx\n        let note_index_in_tx = unique_note_hashes_in_tx.len() + 5;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        // The note is inserted at an arbitrary index - its true index is out of the array's bounds\n        unique_note_hashes_in_tx.set(2, note_and_data.unique_note_hash);\n\n        let discovered_notes = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n\n        assert_eq(discovered_notes.len(), 1);\n        let discovered_note = discovered_notes.get(0);\n\n        assert_eq(discovered_note.note_nonce, note_and_data.note_nonce);\n        assert_eq(discovered_note.note_hash, note_and_data.note_hash);\n        assert_eq(discovered_note.inner_nullifier, note_and_data.inner_nullifier);\n    }\n\n    #[test(should_fail_with = \"identical note hashes for a transaction\")]\n    unconstrained fn duplicate_unique_note_hashes() {\n        let note_index_in_tx = 2;\n        let note_and_data = construct_note(VALUE, note_index_in_tx);\n\n        let mut unique_note_hashes_in_tx = BoundedVec::from_array([\n            random(), random(), random(), random(), random(), random(), random(),\n        ]);\n\n        // The same unique note hash is present in two indices in the array, which is not allowed. Note that we don't\n        // test all note hashes for uniqueness, only those that we actually find.\n        unique_note_hashes_in_tx.set(note_index_in_tx, note_and_data.unique_note_hash);\n        unique_note_hashes_in_tx.set(note_index_in_tx + 1, note_and_data.unique_note_hash);\n\n        let _ = attempt_note_nonce_discovery(\n            unique_note_hashes_in_tx,\n            FIRST_NULLIFIER_IN_TX,\n            compute_note_hash,\n            compute_note_nullifier,\n            CONTRACT_ADDRESS,\n            OWNER,\n            STORAGE_SLOT,\n            RANDOMNESS,\n            MockNote::get_id(),\n            BoundedVec::from_array(note_and_data.note.pack()),\n        );\n    }\n}\n"
     },
-    "130": {
+    "131": {
       "function_locations": [
         {
           "name": "process_partial_note_private_msg",
@@ -170,7 +170,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/partial_notes.nr",
       "source": "use crate::{\n    capsules::CapsuleArray,\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::partial_note::{decode_partial_note_private_message, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN},\n        processing::{\n            enqueue_note_for_validation,\n            get_pending_partial_notes_completion_logs,\n            log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN},\n        },\n    },\n    utils::array,\n};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, traits::{Deserialize, Serialize}};\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub(crate) global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) owner: AztecAddress,\n    pub(crate) randomness: Field,\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n}\n\npub(crate) unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n    scope: AztecAddress,\n) {\n    let decoded = decode_partial_note_private_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later\n        // search for the public log that will complete it.\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content) = decoded.unwrap();\n\n        let pending = DeliveredPendingPartialNote {\n            owner,\n            randomness,\n            note_completion_log_tag,\n            note_type_id,\n            packed_private_note_content,\n        };\n\n        CapsuleArray::at(\n            contract_address,\n            DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n            scope,\n        )\n            .push(pending);\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode partial note private message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Searches for logs that would result in the completion of pending partial notes, ultimately resulting in the notes\n/// being delivered to PXE if completed.\npub(crate) unconstrained fn fetch_and_process_partial_note_completion_logs(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    scope: AztecAddress,\n) {\n    let pending_partial_notes = CapsuleArray::at(\n        contract_address,\n        DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n        scope,\n    );\n\n    aztecnr_debug_log_format!(\"{} pending partial notes\")([pending_partial_notes.len() as Field]);\n\n    // Each of the pending partial notes might get completed by a log containing its public values. For performance\n    // reasons, we fetch all of these logs concurrently and then process them one by one, minimizing the amount of time\n    // waiting for the node roundtrip.\n    let maybe_completion_logs = get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n\n    // Each entry in the maybe completion logs array corresponds to the entry in the pending partial notes array at the\n    // same index. This means we can use the same index as we iterate through the responses to get both the partial\n    // note and the log that might complete it.\n    assert_eq(maybe_completion_logs.len(), pending_partial_notes.len());\n\n    maybe_completion_logs.for_each(|i, maybe_log: Option<LogRetrievalResponse>| {\n        let pending_partial_note = pending_partial_notes.get(i);\n\n        if maybe_log.is_none() {\n            aztecnr_debug_log_format!(\"Found no completion logs for partial note with tag {}\")(\n                [pending_partial_note.note_completion_log_tag],\n            );\n\n            // Note that we're not removing the pending partial note from the capsule array, so we will continue\n            // searching for this tagged log when performing message discovery in the future until we either find it or\n            // the entry is somehow removed from the array.\n        } else {\n            aztecnr_debug_log_format!(\"Completion log found for partial note with tag {}\")([\n                pending_partial_note.note_completion_log_tag,\n            ]);\n            let log = maybe_log.unwrap();\n\n            // The first field in the completion log payload is the storage slot, followed by the public note\n            // content fields.\n            let storage_slot = log.log_payload.get(0);\n            let public_note_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN - 1> = array::subbvec(log.log_payload, 1);\n\n            // Public fields are assumed to all be placed at the end of the packed representation, so we combine\n            // the private and public packed fields (i.e. the contents of the private message and public log\n            // plaintext) to get the complete packed content.\n            let complete_packed_note = array::append(\n                pending_partial_note.packed_private_note_content,\n                public_note_content,\n            );\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                contract_address,\n                pending_partial_note.owner,\n                storage_slot,\n                pending_partial_note.randomness,\n                pending_partial_note.note_type_id,\n                complete_packed_note,\n            );\n\n            // TODO(#11627): is there anything reasonable we can do if we get a log but it doesn't result in a note\n            // being found?\n            if discovered_notes.len() == 0 {\n                panic(\n                    f\"A partial note's completion log did not result in any notes being found - this should never happen\",\n                );\n            }\n\n            aztecnr_debug_log_format!(\"Discovered {0} notes for partial note with tag {1}\")([\n                discovered_notes.len() as Field,\n                pending_partial_note.note_completion_log_tag,\n            ]);\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    contract_address,\n                    pending_partial_note.owner,\n                    storage_slot,\n                    pending_partial_note.randomness,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                );\n            });\n\n            // Because there is only a single log for a given tag, once we've processed the tagged log then we simply\n            // delete the pending work entry, regardless of whether it was actually completed or not.\n            pending_partial_notes.remove(i);\n        }\n    });\n}\n"
     },
-    "131": {
+    "132": {
       "function_locations": [
         {
           "name": "process_private_event_msg",
@@ -180,7 +180,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_events.nr",
       "source": "use crate::{\n    event::event_interface::compute_private_serialized_event_commitment,\n    logging::aztecnr_warn_log_format,\n    messages::{\n        encoding::MAX_MESSAGE_CONTENT_LEN, logs::event::decode_private_event_message,\n        processing::enqueue_event_for_validation,\n    },\n};\nuse crate::protocol::{address::AztecAddress, traits::ToField};\n\npub(crate) unconstrained fn process_private_event_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    tx_hash: Field,\n) {\n    let decoded = decode_private_event_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (event_type_id, randomness, serialized_event) = decoded.unwrap();\n\n        let event_commitment =\n            compute_private_serialized_event_commitment(serialized_event, randomness, event_type_id.to_field());\n\n        enqueue_event_for_validation(\n            contract_address,\n            event_type_id,\n            randomness,\n            serialized_event,\n            event_commitment,\n            tx_hash,\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode private event message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n"
     },
-    "132": {
+    "133": {
       "function_locations": [
         {
           "name": "process_private_note_msg",
@@ -194,7 +194,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
       "source": "use crate::{\n    logging::{aztecnr_debug_log_format, aztecnr_warn_log_format},\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::{decode_private_note_message, MAX_NOTE_PACKED_LEN},\n        processing::enqueue_note_for_validation,\n    },\n    protocol::{address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, traits::ToField},\n};\n\npub(crate) unconstrained fn process_private_note_msg(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let decoded = decode_private_note_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (note_type_id, owner, storage_slot, randomness, packed_note) = decoded.unwrap();\n\n        attempt_note_discovery(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            compute_note_hash,\n            compute_note_nullifier,\n            owner,\n            storage_slot,\n            randomness,\n            note_type_id,\n            packed_note,\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode private note message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is suspected the\n/// note was created.\npub unconstrained fn attempt_note_discovery(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) {\n    let discovered_notes = attempt_note_nonce_discovery(\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        compute_note_hash,\n        compute_note_nullifier,\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_type_id,\n        packed_note,\n    );\n\n    if discovered_notes.len() == 0 {\n        // A private note message that results in no discovered notes means none of the computed note hashes matched\n        // any unique note hash in the transaction. This could indicate a malformed or malicious message (e.g. a sender\n        // providing bogus note content).\n        aztecnr_warn_log_format!(\n            \"Discarding private note message from tx {0} for contract {1}: no matching note hash found in the tx\",\n        )(\n            [tx_hash, contract_address.to_field()],\n        );\n    } else {\n        aztecnr_debug_log_format!(\n            \"Discovered {0} notes from a private message for contract {1}\",\n        )(\n            [discovered_notes.len() as Field, contract_address.to_field()],\n        );\n    }\n\n    discovered_notes.for_each(|discovered_note| {\n        enqueue_note_for_validation(\n            contract_address,\n            owner,\n            storage_slot,\n            randomness,\n            discovered_note.note_nonce,\n            packed_note,\n            discovered_note.note_hash,\n            discovered_note.inner_nullifier,\n            tx_hash,\n        );\n    });\n}\n"
     },
-    "133": {
+    "134": {
       "function_locations": [
         {
           "name": "process_message_ciphertext",
@@ -208,7 +208,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHash, ComputeNoteNullifier, CustomMessageHandler, partial_notes::process_partial_note_private_msg,\n        private_events::process_private_event_msg, private_notes::process_private_note_msg,\n    },\n    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN},\n    encryption::{aes128::AES128, message_encryption::MessageEncryption},\n    msg_type::{\n        MIN_CUSTOM_MSG_TYPE_ID, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    processing::MessageContext,\n};\n\nuse crate::logging::{aztecnr_debug_log, aztecnr_warn_log_format};\nuse crate::protocol::address::AztecAddress;\n\n/// Processes a message that can contain notes, partial notes, or events.\n///\n/// Notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash\n/// in which the notes would've been created (typically the same transaction in which the log was emitted), along with\n/// the list of unique note hashes in said transaction and the `compute_note_hash` and `compute_note_nullifier`\n/// functions. Once discovered, the notes are enqueued for validation.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved\n/// to search for the note's completion public log.\n///\n/// Events are processed by computing an event commitment from the serialized event data and its randomness field, then\n/// enqueueing the event data and commitment for validation.\npub unconstrained fn process_message_ciphertext<CustomMessageHandlerEnv>(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler<CustomMessageHandlerEnv>>,\n    message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    message_context: MessageContext,\n    recipient: AztecAddress,\n) {\n    let message_plaintext_option = AES128::decrypt(message_ciphertext, recipient, contract_address);\n\n    if message_plaintext_option.is_some() {\n        process_message_plaintext(\n            contract_address,\n            compute_note_hash,\n            compute_note_nullifier,\n            process_custom_message,\n            message_plaintext_option.unwrap(),\n            message_context,\n            recipient,\n        );\n    } else {\n        aztecnr_warn_log_format!(\"Could not decrypt message ciphertext from tx {0}, ignoring\")([message_context.tx_hash]);\n    }\n}\n\npub(crate) unconstrained fn process_message_plaintext<CustomMessageHandlerEnv>(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler<CustomMessageHandlerEnv>>,\n    message_plaintext: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n    message_context: MessageContext,\n    recipient: AztecAddress,\n) {\n    // The first thing to do after decrypting the message is to determine what type of message we're processing. We\n    // have 3 message types: private notes, partial notes and events.\n\n    // We decode the message to obtain the message type id, metadata and content.\n    let decoded = decode_message(message_plaintext);\n\n    if decoded.is_some() {\n        let (msg_type_id, msg_metadata, msg_content) = decoded.unwrap();\n\n        if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private note msg\");\n\n            process_private_note_msg(\n                contract_address,\n                message_context.tx_hash,\n                message_context.unique_note_hashes_in_tx,\n                message_context.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                msg_metadata,\n                msg_content,\n            );\n        } else if msg_type_id == PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing partial note private msg\");\n\n            process_partial_note_private_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                message_context.tx_hash,\n                recipient,\n            );\n        } else if msg_type_id == PRIVATE_EVENT_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private event msg\");\n\n            process_private_event_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                message_context.tx_hash,\n            );\n        } else if msg_type_id < MIN_CUSTOM_MSG_TYPE_ID {\n            // The message type ID falls in the range reserved for aztec.nr built-in types but wasn't matched above.\n            // This most likely means the message is malformed or a custom message was incorrectly assigned a reserved\n            // ID. Custom message types must use IDs allocated via `custom_msg_type_id`.\n            aztecnr_warn_log_format!(\n                \"Message type ID {0} is in the reserved range but is not recognized, ignoring. See https://docs.aztec.network/errors/3\",\n            )(\n                [msg_type_id as Field],\n            );\n        } else if process_custom_message.is_some() {\n            process_custom_message.unwrap()(\n                contract_address,\n                msg_type_id,\n                msg_metadata,\n                msg_content,\n                message_context,\n                recipient,\n            );\n        } else {\n            // A custom message was received but no handler is configured. This likely means the contract emits custom\n            // messages but forgot to register a handler via `AztecConfig::custom_message_handler`.\n            aztecnr_warn_log_format!(\n                \"Received custom message with type id {0} but no handler is configured, ignoring. See https://docs.aztec.network/errors/2\",\n            )(\n                [msg_type_id as Field],\n            );\n        }\n    } else {\n        aztecnr_warn_log_format!(\"Could not decode message plaintext from tx {0}, ignoring\")([message_context.tx_hash]);\n    }\n}\n"
     },
-    "134": {
+    "135": {
       "function_locations": [
         {
           "name": "encode_message",
@@ -270,7 +270,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encoding.nr",
       "source": "// TODO(#12750): don't make these values assume we're using AES.\nuse crate::protocol::constants::PRIVATE_LOG_CIPHERTEXT_LEN;\nuse crate::utils::array;\n\n// We reassign to the constant here to communicate the distinction between a log and a message. In Aztec.nr, unlike in\n// protocol circuits, we have a concept of a message that can be emitted either as a private log or as an offchain\n// message. Message is a piece of data that is to be eventually delivered to a contract via the `process_message(...)`\n// utility function function that is injected by the #[aztec] macro. Note: PRIVATE_LOG_CIPHERTEXT_LEN is an amount of\n// fields, so MESSAGE_CIPHERTEXT_LEN is the size of the message in fields.\npub global MESSAGE_CIPHERTEXT_LEN: u32 = PRIVATE_LOG_CIPHERTEXT_LEN;\n\n// TODO(#12750): The global variables below should not be here as they are AES128 specific.\n// The header plaintext is 2 bytes (ciphertext length), padded to the 16-byte AES block size by PKCS#7.\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 16;\n// AES PKCS#7 always adds at least one byte of padding. Since each plaintext field is 32 bytes (a multiple of the\n// 16-byte AES block size), a full 16-byte padding block is always appended.\npub(crate) global AES128_PKCS7_EXPANSION_IN_BYTES: u32 = 16;\n\npub global EPH_PK_X_SIZE_IN_FIELDS: u32 = 1;\n\n// (15 - 1) * 31 - 16 - 16 = 402. Note: We multiply by 31 because ciphertext bytes are stored in fields using\n// encode_bytes_as_fields, which packs 31 bytes per field (since a Field is ~254 bits and can safely store 31 whole\n// bytes).\npub(crate) global MESSAGE_PLAINTEXT_SIZE_IN_BYTES: u32 = (MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31\n    - HEADER_CIPHERTEXT_SIZE_IN_BYTES\n    - AES128_PKCS7_EXPANSION_IN_BYTES;\n// The plaintext bytes represent Field values that were originally serialized using encode_fields_as_bytes, which\n// converts each Field to 32 bytes. To convert the plaintext bytes back to fields, we divide by 32. 402 / 32 = 12\npub global MESSAGE_PLAINTEXT_LEN: u32 = MESSAGE_PLAINTEXT_SIZE_IN_BYTES / 32;\n\npub global MESSAGE_EXPANDED_METADATA_LEN: u32 = 1;\n\n// The standard message layout is composed of:\n//  - an initial field called the 'expanded metadata'\n//  - an arbitrary number of fields following that called the 'message content'\n//\n// ```\n// message: [ msg_expanded_metadata, ...msg_content ]\n// ```\n//\n// The expanded metadata itself is interpreted as a u128, of which:\n//  - the upper 64 bits are the message type id\n//  - the lower 64 bits are called the 'message metadata'\n//\n// ```\n// msg_expanded_metadata: [  msg_type_id    |  msg_metadata  ]\n//                        <---  64 bits --->|<--- 64 bits --->\n// ```\n//\n// The meaning of the message metadata and message content depend on the value of the message type id. Note that there\n// is nothing special about the message metadata, it _can_ be considered part of the content. It just has a different\n// name to make it distinct from the message content given that it is not a full field.\n\n/// The maximum length of a message's content, i.e. not including the expanded message metadata.\npub global MAX_MESSAGE_CONTENT_LEN: u32 = MESSAGE_PLAINTEXT_LEN - MESSAGE_EXPANDED_METADATA_LEN;\n\n/// Encodes a message following aztec-nr's standard message encoding. This message can later be decoded with\n/// `decode_message` to retrieve the original values.\n///\n/// - The `msg_type` is an identifier that groups types of messages that are all processed the same way, e.g. private\n/// notes or events. Possible values are defined in `aztec::messages::msg_type`.\n/// - The `msg_metadata` and `msg_content` are the values stored in the message, whose meaning depends on the\n/// `msg_type`. The only special thing about `msg_metadata` that separates it from `msg_content` is that it is a u64\n/// instead of a full Field (due to details of how messages are encoded), allowing applications that can fit values\n/// into this smaller variable to achieve higher data efficiency.\npub fn encode_message<let N: u32>(\n    msg_type: u64,\n    msg_metadata: u64,\n    msg_content: [Field; N],\n) -> [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] {\n    std::static_assert(\n        msg_content.len() <= MAX_MESSAGE_CONTENT_LEN,\n        \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\",\n    );\n\n    // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of the\n    // message encoding below must be updated as well.\n    std::static_assert(\n        MESSAGE_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n    );\n    let mut message: [Field; (N + MESSAGE_EXPANDED_METADATA_LEN)] = std::mem::zeroed();\n\n    message[0] = to_expanded_metadata(msg_type, msg_metadata);\n    for i in 0..msg_content.len() {\n        message[MESSAGE_EXPANDED_METADATA_LEN + i] = msg_content[i];\n    }\n\n    message\n}\n\n/// Decodes a standard aztec-nr message, i.e. one created via `encode_message`, returning the original encoded values.\n///\n/// Returns `None` if the message is empty or has invalid (>128 bit) expanded metadata.\n///\n/// Note that `encode_message` returns a fixed size array while this function takes a `BoundedVec`: this is because\n/// prior to decoding the message type is unknown, and consequentially not known at compile time. If working with\n/// fixed-size messages, consider using `BoundedVec::from_array` to convert them.\npub unconstrained fn decode_message(\n    message: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n) -> Option<(u64, u64, BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>)> {\n    Option::some(message)\n        .and_then(|message| {\n            // If MESSAGE_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring\n            // of the\n            // message encoding below must be updated as well.\n            std::static_assert(\n                MESSAGE_EXPANDED_METADATA_LEN == 1,\n                \"unexpected value for MESSAGE_EXPANDED_METADATA_LEN\",\n            );\n            if message.len() < MESSAGE_EXPANDED_METADATA_LEN {\n                Option::none()\n            } else {\n                Option::some(message.get(0))\n            }\n        })\n        .and_then(|msg_expanded_metadata| from_expanded_metadata(msg_expanded_metadata))\n        .map(|(msg_type_id, msg_metadata)| {\n            let msg_content = array::subbvec(message, MESSAGE_EXPANDED_METADATA_LEN);\n            (msg_type_id, msg_metadata, msg_content)\n        })\n}\n\nglobal U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\nfn to_expanded_metadata(msg_type: u64, msg_metadata: u64) -> Field {\n    // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n    // expensive in circuits.\n    let type_field: Field = (msg_type as Field) * U64_SHIFT_MULTIPLIER;\n    let msg_metadata_field = msg_metadata as Field;\n\n    type_field + msg_metadata_field\n}\n\nglobal TWO_POW_128: Field = 2.pow_32(128);\n\n/// Unpacks expanded metadata into (msg_type, msg_metadata). Returns `None` if `input >= 2^128`.\nfn from_expanded_metadata(input: Field) -> Option<(u64, u64)> {\n    if input.lt(TWO_POW_128) {\n        let msg_metadata = (input as u64);\n        let msg_type = ((input - (msg_metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n        // Use division instead of bit shift since bit shifts are expensive in circuits\n        Option::some((msg_type, msg_metadata))\n    } else {\n        Option::none()\n    }\n}\n\nmod tests {\n    use crate::utils::array::subarray::subarray;\n    use super::{\n        decode_message, encode_message, from_expanded_metadata, MAX_MESSAGE_CONTENT_LEN, to_expanded_metadata,\n        TWO_POW_128,\n    };\n\n    global U64_MAX: u64 = (2.pow_32(64) - 1) as u64;\n    global U128_MAX: Field = (2.pow_32(128) - 1);\n\n    #[test]\n    unconstrained fn encode_decode_empty_message(msg_type: u64, msg_metadata: u64) {\n        let encoded = encode_message(msg_type, msg_metadata, []);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_short_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN / 2],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_full_message(\n        msg_type: u64,\n        msg_metadata: u64,\n        msg_content: [Field; MAX_MESSAGE_CONTENT_LEN],\n    ) {\n        let encoded = encode_message(msg_type, msg_metadata, msg_content);\n        let (decoded_msg_type, decoded_msg_metadata, decoded_msg_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_msg_type, msg_type);\n        assert_eq(decoded_msg_metadata, msg_metadata);\n        assert_eq(decoded_msg_content.len(), msg_content.len());\n        assert_eq(subarray(decoded_msg_content.storage(), 0), msg_content);\n    }\n\n    #[test]\n    unconstrained fn to_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let packed = to_expanded_metadata(U64_MAX, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let packed = to_expanded_metadata(U64_MAX, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let packed = to_expanded_metadata(0, U64_MAX);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let packed = to_expanded_metadata(0, 0);\n        let (msg_type, msg_metadata) = from_expanded_metadata(packed).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn from_expanded_metadata_packing() {\n        // Test case 1: All bits set\n        let input = U128_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 2: Only log type bits set\n        let input = (U128_MAX - U64_MAX as Field);\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, U64_MAX);\n        assert_eq(msg_metadata, 0);\n\n        // Test case 3: Only msg_metadata bits set\n        let input = U64_MAX as Field;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, U64_MAX);\n\n        // Test case 4: No bits set\n        let input = 0;\n        let (msg_type, msg_metadata) = from_expanded_metadata(input).unwrap();\n        assert_eq(msg_type, 0);\n        assert_eq(msg_metadata, 0);\n    }\n\n    #[test]\n    unconstrained fn to_from_expanded_metadata(original_msg_type: u64, original_msg_metadata: u64) {\n        let packed = to_expanded_metadata(original_msg_type, original_msg_metadata);\n        let (unpacked_msg_type, unpacked_msg_metadata) = from_expanded_metadata(packed).unwrap();\n\n        assert_eq(original_msg_type, unpacked_msg_type);\n        assert_eq(original_msg_metadata, unpacked_msg_metadata);\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_message() {\n        let msg_type_id: u64 = 42;\n        let msg_metadata: u64 = 99;\n        let mut msg_content = [0; MAX_MESSAGE_CONTENT_LEN];\n        for i in 0..MAX_MESSAGE_CONTENT_LEN {\n            msg_content[i] = i as Field;\n        }\n\n        let encoded = encode_message(msg_type_id, msg_metadata, msg_content);\n        let (decoded_type_id, decoded_metadata, decoded_content) =\n            decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(decoded_type_id, msg_type_id);\n        assert_eq(decoded_metadata, msg_metadata);\n        assert_eq(decoded_content, BoundedVec::from_array(msg_content));\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_message_fails() {\n        let msg_content = [0; MAX_MESSAGE_CONTENT_LEN + 1];\n        let _ = encode_message(0, 0, msg_content);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_message_returns_none() {\n        assert(decode_message(BoundedVec::new()).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_message_with_oversized_metadata_returns_none() {\n        let message = BoundedVec::from_array([TWO_POW_128]);\n        assert(decode_message(message).is_none());\n    }\n}\n"
     },
-    "135": {
+    "136": {
       "function_locations": [
         {
           "name": "extract_many_close_to_uniformly_random_256_bits_using_poseidon2",
@@ -356,7 +356,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/encryption/aes128.nr",
       "source": "use crate::protocol::{address::AztecAddress, public_keys::AddressPoint, traits::ToField};\n\nuse crate::{\n    keys::{\n        ecdh_shared_secret::{\n            compute_app_siloed_shared_secret, derive_ecdh_shared_secret, derive_shared_secret_field_mask,\n            derive_shared_secret_subkey,\n        },\n        ephemeral::generate_positive_ephemeral_key_pair,\n    },\n    logging::aztecnr_warn_log_format,\n    messages::{\n        encoding::{\n            EPH_PK_X_SIZE_IN_FIELDS, HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN,\n            MESSAGE_PLAINTEXT_SIZE_IN_BYTES,\n        },\n        encryption::message_encryption::MessageEncryption,\n        logs::arithmetic_generics_utils::{\n            get_arr_of_size__message_bytes__from_PT, get_arr_of_size__message_bytes_padding__from_PT,\n        },\n    },\n    oracle::{aes128_decrypt::try_aes128_decrypt, random::random, shared_secret::get_shared_secret},\n    utils::{\n        array,\n        conversion::{\n            bytes_as_fields::{decode_bytes_from_fields, encode_bytes_as_fields},\n            fields_as_bytes::{encode_fields_as_bytes, try_decode_fields_from_bytes},\n        },\n        point::point_from_x_coord_and_sign,\n    },\n};\n\nuse std::aes128::aes128_encrypt;\n\n/// Computes N close-to-uniformly-random 256 bits from a given app-siloed shared secret.\n///\n/// NEVER re-use the same iv and sym_key. DO NOT call this function more than once with the same s_app.\n///\n/// This function is only known to be safe if s_app is derived from combining a random ephemeral key with an\n/// address point and a contract address. See big comment within the body of the function.\nfn extract_many_close_to_uniformly_random_256_bits_using_poseidon2<let N: u32>(s_app: Field) -> [[u8; 32]; N] {\n    /*\n     * Unsafe because of https://eprint.iacr.org/2010/264.pdf Page 13, Lemma 2 (and the two paragraphs below it).\n    *\n    * If you call this function, you need to be careful and aware of how the arg `s_app` has been derived.\n    *\n    * The paper says that the way you derive aes keys and IVs should be fine with poseidon2 (modelled as a RO),\n    * as long as you _don't_ use Poseidon2 as a PRG to generate the two exponents x & y which multiply to the\n    * shared secret S:\n    *\n    * S = [x*y]*G.\n    *\n    * (Otherwise, you would have to \"key\" poseidon2, i.e. generate a uniformly string K which can be public and\n    * compute Hash(x) as poseidon(K,x)).\n    * In that lemma, k would be 2*254=508, and m would be the number of points on the grumpkin curve (which is\n    * close to r according to the Hasse bound).\n    *\n    * Our shared secret S is [esk * address_sk] * G, and the question is: Can we compute hash(S) using poseidon2\n    * instead of sha256?\n    *\n    * Well, esk is random and not generated with poseidon2, so that's good.\n    * What about address_sk?\n    * Well, address_sk = poseidon2(stuff) + ivsk, so there was some discussion about whether address_sk is\n    * independent of poseidon2. Given that ivsk is random and independent of poseidon2, the address_sk is also\n    * independent of poseidon2.\n    *\n    * Tl;dr: we believe it's safe to hash S = [esk * address_sk] * G using poseidon2, in order to derive a\n    * symmetric key.\n    *\n    * If you're calling this function for a differently-derived `s_app`, be careful.\n    */\n    \n\n    /* The output of this function needs to be 32 random bytes.\n     * A single field won't give us 32 bytes of entropy. So we compute two \"random\" fields, by poseidon-hashing\n    * with two different indices. We then extract the last 16 (big endian) bytes of each \"random\" field.\n    * Note: we use to_be_bytes because it's slightly more efficient. But we have to be careful not to take bytes\n    * from the \"big end\", because the \"big\" byte is not uniformly random over the byte: it only has < 6 bits of\n    * randomness, because it's the big end of a 254-bit field element.\n    */\n\n    let mut all_bytes: [[u8; 32]; N] = std::mem::zeroed();\n    std::static_assert(N < 256, \"N too large\");\n    for k in 0..N {\n        let rand1: Field = derive_shared_secret_subkey(s_app, 2 * k);\n        let rand2: Field = derive_shared_secret_subkey(s_app, 2 * k + 1);\n\n        let rand1_bytes: [u8; 32] = rand1.to_be_bytes();\n        let rand2_bytes: [u8; 32] = rand2.to_be_bytes();\n\n        let mut bytes: [u8; 32] = [0; 32];\n        for i in 0..16 {\n            // We take bytes from the \"little end\" of the be-bytes arrays:\n            let j = 32 - i - 1;\n            bytes[i] = rand1_bytes[j];\n            bytes[16 + i] = rand2_bytes[j];\n        }\n\n        all_bytes[k] = bytes;\n    }\n\n    all_bytes\n}\n\nfn derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits<let N: u32>(\n    many_random_256_bits: [[u8; 32]; N],\n) -> [([u8; 16], [u8; 16]); N] {\n    // Many (sym_key, iv) pairs:\n    let mut many_pairs: [([u8; 16], [u8; 16]); N] = std::mem::zeroed();\n    for k in 0..N {\n        let random_256_bits = many_random_256_bits[k];\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n        for i in 0..16 {\n            sym_key[i] = random_256_bits[i];\n            iv[i] = random_256_bits[i + 16];\n        }\n        many_pairs[k] = (sym_key, iv);\n    }\n\n    many_pairs\n}\n\npub fn derive_aes_symmetric_key_and_iv_from_shared_secret<let N: u32>(s_app: Field) -> [([u8; 16], [u8; 16]); N] {\n    let many_random_256_bits: [[u8; 32]; N] = extract_many_close_to_uniformly_random_256_bits_using_poseidon2(s_app);\n\n    derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits(many_random_256_bits)\n}\n\npub struct AES128 {}\n\nimpl MessageEncryption for AES128 {\n\n    /// AES128-CBC encryption for Aztec protocol messages.\n    ///\n    /// ## Overview\n    ///\n    /// The plaintext is an array of up to `MESSAGE_PLAINTEXT_LEN` (12) fields. The output is always exactly\n    /// `MESSAGE_CIPHERTEXT_LEN` (15) fields, regardless of plaintext size. All output fields except the\n    /// ephemeral public key are uniformly random `Field` values to any observer without knowledge of the\n    /// shared secret, making all encrypted messages indistinguishable by size or content.\n    ///\n    /// ## PKCS#7 Padding\n    ///\n    /// AES operates on 16-byte blocks, so the plaintext must be padded to a multiple of 16. PKCS#7 padding always\n    /// adds at least 1 byte (so the receiver can always detect and strip it), which means:\n    /// - 1 B plaintext  -> 15 B padding -> 16 B total\n    /// - 15 B plaintext ->  1 B padding -> 16 B total\n    /// - 16 B plaintext -> 16 B padding -> 32 B total (full extra block)\n    ///\n    /// In general: if the plaintext is already a multiple of 16, a full 16-byte padding block is appended.\n    ///\n    /// ## Encryption Steps\n    ///\n    /// **1. Body encryption.** The plaintext fields are serialized to bytes (32 bytes per field) and AES-128-CBC\n    /// encrypted. Since 32 is a multiple of 16, PKCS#7 always adds a full 16-byte padding block (see above):\n    ///\n    /// ```text\n    /// +---------------------------------------------+\n    /// |                   body ct                    |\n    /// |            PlaintextLen*32 + 16 B            |\n    /// +-------------------------------+--------------+\n    /// | encrypted plaintext fields    | PKCS#7 (16B) |\n    /// | (serialized at 32 B each)     |              |\n    /// +-------------------------------+--------------+\n    /// ```\n    ///\n    /// **2. Header encryption.** The byte length of `body_ct` is stored as a 2-byte big-endian integer. This 2-byte\n    /// header plaintext is then AES-encrypted; PKCS#7 pads the remaining 14 bytes to fill one 16-byte AES block,\n    /// producing a 16-byte header ciphertext:\n    ///\n    /// ```text\n    /// +---------------------------+\n    /// |         header ct         |\n    /// |            16 B           |\n    /// +--------+------------------+\n    /// | body ct| PKCS#7 (14B)     |\n    /// | length |                  |\n    /// | (2 B)  |                  |\n    /// +--------+------------------+\n    /// ```\n    ///\n    /// ## Wire Format\n    ///\n    /// Messages are transmitted as fields, not bytes. A field is ~254 bits and can safely store 31 whole bytes, so\n    /// we need to pack our byte data into 31-byte chunks. This packing drives the wire format.\n    ///\n    /// **Step 1 -- Assemble bytes.** The ciphertexts are laid out in a byte array, padded with zero bytes to a\n    /// multiple of 31 so it divides evenly into fields:\n    ///\n    /// ```text\n    /// +------------+-------------------------+---------+\n    /// | header ct  |        body ct          | byte pad|\n    /// |   16 B     | PlaintextLen*32 + 16 B  | (zeros) |\n    /// +------------+-------------------------+---------+\n    /// |<-------- padded to a multiple of 31 B -------->|\n    /// ```\n    ///\n    /// **Step 2 -- Pack and mask.** The byte array is split into 31-byte chunks, each stored in one field. A\n    /// Poseidon2-derived mask (see `derive_shared_secret_field_mask`) is added to each so that the resulting\n    /// fields appear as uniformly random `Field` values to any observer without knowledge of the shared secret,\n    /// hiding the fact that the underlying ciphertext consists of 128-bit AES blocks.\n    ///\n    /// **Step 3 -- Assemble ciphertext.** The ephemeral public key x-coordinate is prepended and random field padding\n    /// is appended to fill to 15 fields:\n    ///\n    /// ```text\n    /// +----------+-------------------------+-------------------+\n    /// | eph_pk.x |  masked message fields   | random field pad  |\n    /// |          | (packed 31 B per field)  |  (fills to 15)    |\n    /// +----------+-------------------------+-------------------+\n    /// |<---------- MESSAGE_CIPHERTEXT_LEN = 15 fields -------->|\n    /// ```\n    ///\n    /// ## Key Derivation\n    ///\n    /// The raw ECDH shared secret point is first app-siloed into a scalar `s_app` by hashing with the contract\n    /// address (see\n    /// [`compute_app_siloed_shared_secret`](crate::keys::ecdh_shared_secret::compute_app_siloed_shared_secret)).\n    /// Two (key, IV) pairs are then derived from `s_app` via indexed Poseidon2 hashing: one pair for the body\n    /// ciphertext and one for the header ciphertext.\n    fn encrypt<let PlaintextLen: u32>(\n        plaintext: [Field; PlaintextLen],\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> [Field; MESSAGE_CIPHERTEXT_LEN] {\n        std::static_assert(\n            PlaintextLen <= MESSAGE_PLAINTEXT_LEN,\n            \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\",\n        );\n\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes. (This process is then\n        // reversed when processing the message in `process_message_ciphertext`)\n        let plaintext_bytes = encode_fields_as_bytes(plaintext);\n\n        // Derive ECDH shared secret with recipient using a fresh ephemeral keypair.\n        let (eph_sk, eph_pk) = generate_positive_ephemeral_key_pair();\n\n        let raw_shared_secret = derive_ecdh_shared_secret(\n            eph_sk,\n            recipient\n                .to_address_point()\n                .unwrap_or_else(|| {\n                    aztecnr_warn_log_format!(\n                        \"Attempted to encrypt message for an invalid recipient ({0})\",\n                    )(\n                        [recipient.to_field()],\n                    );\n\n                    // Safety: if the recipient is an invalid address, then it is not possible to encrypt a message for\n                    // them because we cannot establish a shared secret. This is never expected to occur during normal\n                    // operation. However, it is technically possible for us to receive an invalid address, and we must\n                    // therefore handle it. We could simply fail, but that'd introduce a potential security issue in\n                    // which an attacker forces a contract to encrypt a message for an invalid address, resulting in an\n                    // impossible transaction - this is sometimes called a 'king of the hill' attack. We choose instead\n                    // to not fail and encrypt the plaintext regardless using the shared secret that results from a\n                    // random valid address. The sender is free to choose this address and hence shared secret, but\n                    // this has no security implications as they already know not only the full plaintext but also the\n                    // ephemeral private key anyway.\n                    unsafe {\n                        random_address_point()\n                    }\n                })\n                .inner,\n        );\n\n        let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n        // It is safe to derive AES keys from `s_app` using Poseidon2 because `s_app` was derived from an ECDH shared\n        // secret using an AztecAddress (the recipient). See the block comment in\n        // `extract_many_close_to_uniformly_random_256_bits_using_poseidon2` for more info.\n        let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, body_iv, body_sym_key);\n\n        // Each plaintext field is 32 bytes (a multiple of the 16-byte AES block\n        // size), so PKCS#7 always appends a full 16-byte padding block:\n        //   |ciphertext| = PlaintextLen*32 + 16 = 16 * (1 + PlaintextLen*32 / 16)\n        std::static_assert(\n            ciphertext_bytes.len() == 16 * (1 + (PlaintextLen * 32) / 16),\n            \"unexpected ciphertext length\",\n        );\n\n        // Encrypt a 2-byte header containing the body ciphertext length.\n        let header_plaintext = encode_header(ciphertext_bytes.len());\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the input, according to pkcs#7; hence why\n        // the output `header_ciphertext_bytes` is 16 bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, header_iv, header_sym_key);\n        // Verify expected header ciphertext size at compile time.\n        std::static_assert(\n            header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n            \"unexpected ciphertext header length\",\n        );\n\n        // Assemble the message byte array:\n        //  [header_ct (16B)] [body_ct] [padding to mult of 31]\n        let message_bytes_padding_to_mult_31 = get_arr_of_size__message_bytes_padding__from_PT::<PlaintextLen * 32>();\n\n        let mut message_bytes = get_arr_of_size__message_bytes__from_PT::<PlaintextLen * 32>();\n\n        std::static_assert(\n            message_bytes.len() % 31 == 0,\n            \"Unexpected error: message_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        let mut offset = 0;\n        for i in 0..header_ciphertext_bytes.len() {\n            message_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            message_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..message_bytes_padding_to_mult_31.len() {\n            message_bytes[offset + i] = message_bytes_padding_to_mult_31[i];\n        }\n        offset += message_bytes_padding_to_mult_31.len();\n\n        // Ideally we would be able to have a static assert where we check that the offset would be such that we've\n        // written to the entire log_bytes array, but we cannot since Noir does not treat the offset as a comptime\n        // value (despite the values that it goes through being known at each stage). We instead check that the\n        // computation used to obtain the offset computes the expected value (which we _can_ do in a static check), and\n        // then add a cheap runtime check to also validate that the offset matches this.\n        std::static_assert(\n            header_ciphertext_bytes.len() + ciphertext_bytes.len() + message_bytes_padding_to_mult_31.len()\n                == message_bytes.len(),\n            \"unexpected message length\",\n        );\n        assert(offset == message_bytes.len(), \"unexpected encrypted message length\");\n\n        // Pack message bytes into fields (31 bytes per field) and prepend eph_pk.x.\n        let message_bytes_as_fields = encode_bytes_as_fields(message_bytes);\n\n        let mut ciphertext: [Field; MESSAGE_CIPHERTEXT_LEN] = [0; MESSAGE_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        // Mask each content field with a Poseidon2-derived value, so that they appear as uniformly random `Field`\n        // values\n        let mut offset = 1;\n        for i in 0..message_bytes_as_fields.len() {\n            let mask = derive_shared_secret_field_mask(s_app, i as u32);\n            ciphertext[offset + i] = message_bytes_as_fields[i] + mask;\n        }\n        offset += message_bytes_as_fields.len();\n\n        // Pad with random fields so that padding is indistinguishable from masked data fields.\n        for i in offset..MESSAGE_CIPHERTEXT_LEN {\n            // Safety: we assume that the sender wants for the message to be private - a malicious one could simply\n            // reveal its contents publicly. It is therefore fine to trust the sender to provide random padding.\n            ciphertext[i] = unsafe { random() };\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt(\n        ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> Option<BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>> {\n        // Extract the ephemeral public key x-coordinate and masked fields, returning None for empty ciphertext.\n        if ciphertext.len() > 0 {\n            let masked_fields: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS> =\n                array::subbvec(ciphertext, EPH_PK_X_SIZE_IN_FIELDS);\n            Option::some((ciphertext.get(0), masked_fields))\n        } else {\n            Option::none()\n        }\n            .and_then(|(eph_pk_x, masked_fields)| {\n                // With the x-coordinate of the ephemeral public key we can reconstruct the point as we know that the\n                // y-coordinate must be positive. This may fail however, as not all x-coordinates are on the curve. In\n                // that case, we simply return `Option::none`.\n                point_from_x_coord_and_sign(eph_pk_x, true).and_then(|eph_pk| {\n                    let s_app = get_shared_secret(recipient, eph_pk, contract_address);\n\n                    let unmasked_fields = masked_fields.mapi(|i, field| {\n                        let unmasked = unmask_field(s_app, i, field);\n                        // If we failed to unmask the field, we are dealing with the random padding. We'll ignore it\n                        // later, so we can simply set it to 0\n                        unmasked.unwrap_or(0)\n                    });\n                    let ciphertext_without_eph_pk_x = decode_bytes_from_fields(unmasked_fields);\n\n                    // Derive symmetric keys:\n                    let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n                    let (body_sym_key, body_iv) = pairs[0];\n                    let (header_sym_key, header_iv) = pairs[1];\n\n                    // Extract the header ciphertext\n                    let header_start = 0;\n                    let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n                        array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n                    // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's\n                    // designed to work with messages with unknown length at compile time. This would not be necessary\n                    // here as the header ciphertext length is fixed. But we do it anyway to not have to have duplicate\n                    // oracles.\n                    let header_ciphertext_bvec =\n                        BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n                    try_aes128_decrypt(header_ciphertext_bvec, header_iv, header_sym_key)\n                    // Extract ciphertext length from header (2 bytes, big-endian)\n                    .and_then(|header_plaintext| extract_ciphertext_length(header_plaintext))\n                        .filter(|ciphertext_length| ciphertext_length <= MESSAGE_PLAINTEXT_SIZE_IN_BYTES)\n                        .map(|ciphertext_length| {\n                            // Extract and decrypt main ciphertext\n                            let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n                            let ciphertext_with_padding: [u8; MESSAGE_PLAINTEXT_SIZE_IN_BYTES] =\n                                array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n                            BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length)\n                        })\n                        // Decrypt main ciphertext and return it\n                        .and_then(|ciphertext| try_aes128_decrypt(ciphertext, body_iv, body_sym_key))\n                        // Convert bytes back to fields (32 bytes per field). Returns None if the actual bytes are\n                        // not valid.\n                        .and_then(|plaintext_bytes| try_decode_fields_from_bytes(plaintext_bytes))\n                })\n            })\n    }\n}\n\n/// Encodes the body ciphertext length into a 2-byte big-endian header.\nfn encode_header(ciphertext_length: u32) -> [u8; 2] {\n    [(ciphertext_length >> 8) as u8, ciphertext_length as u8]\n}\n\n/// Extracts the body ciphertext length from a decrypted header as a 2-byte big-endian integer.\n///\n/// Returns `Option::none()` if the header has fewer than 2 bytes.\nunconstrained fn extract_ciphertext_length<let N: u32>(header: BoundedVec<u8, N>) -> Option<u32> {\n    if header.len() >= 2 {\n        Option::some(((header.get(0) as u32) << 8) | (header.get(1) as u32))\n    } else {\n        Option::none()\n    }\n}\n\n/// 2^248: upper bound for values that fit in 31 bytes\nglobal TWO_POW_248: Field = 2.pow_32(248);\n\n/// Removes the Poseidon2-derived mask from a ciphertext field. Returns the unmasked value if it fits in 31 bytes\n/// (a content field), or `None` if it doesn't (random padding). Unconstrained to prevent accidental use in\n/// constrained context.\nunconstrained fn unmask_field(s_app: Field, index: u32, masked: Field) -> Option<Field> {\n    let unmasked = masked - derive_shared_secret_field_mask(s_app, index);\n    if unmasked.lt(TWO_POW_248) {\n        Option::some(unmasked)\n    } else {\n        Option::none()\n    }\n}\n\n/// Produces a random valid address point, i.e. one that is on the curve. This is equivalent to calling\n/// [`AztecAddress::to_address_point`] on a random valid address.\nunconstrained fn random_address_point() -> AddressPoint {\n    let mut result = std::mem::zeroed();\n\n    loop {\n        // We simply produce random x coordinates until we find one that is on the curve. About half of the x\n        // coordinates fulfill this condition, so this should only take a few iterations at most.\n        let x_coord = random();\n        let point = point_from_x_coord_and_sign(x_coord, true);\n        if point.is_some() {\n            result = AddressPoint { inner: point.unwrap() };\n            break;\n        }\n    }\n\n    result\n}\n\nmod test {\n    use crate::{\n        keys::ecdh_shared_secret::{compute_app_siloed_shared_secret, derive_ecdh_shared_secret},\n        messages::{\n            encoding::{HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_PLAINTEXT_LEN, MESSAGE_PLAINTEXT_SIZE_IN_BYTES},\n            encryption::message_encryption::MessageEncryption,\n        },\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use super::{AES128, encode_header, random_address_point};\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt_deterministic() {\n        let env = TestEnvironment::new();\n\n        // Message decryption requires oracles that are only available during private execution\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n\n            let recipient = AztecAddress::from_field(\n                0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n            );\n\n            // Mock random values for deterministic test\n            let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n            let _ = OracleMock::mock(\"aztec_utl_getRandomField\").returns(eph_sk).times(1);\n\n            let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n            let _ = OracleMock::mock(\"aztec_utl_getRandomField\").returns(randomness).times(1000000);\n\n            let _ = OracleMock::mock(\"aztec_prv_getNextAppTagAsSender\").returns(42);\n\n            // Encrypt the message\n            let encrypted_message = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            // Compute the same app-siloed shared secret that the oracle would return\n            let raw_shared_secret = derive_ecdh_shared_secret(\n                EmbeddedCurveScalar::from_field(eph_sk),\n                recipient.to_address_point().unwrap().inner,\n            );\n            let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n            let _ = OracleMock::mock(\"aztec_utl_getSharedSecret\").returns(s_app);\n\n            // Decrypt the message\n            let decrypted = AES128::decrypt(encrypted_message, recipient, contract_address).unwrap();\n\n            // The decryption function spits out a BoundedVec because it's designed to work with messages with unknown\n            // length at compile time. For this reason we need to convert the original input to a BoundedVec.\n            let plaintext_bvec = BoundedVec::<Field, MESSAGE_PLAINTEXT_LEN>::from_array(plaintext);\n\n            // Verify decryption matches original plaintext\n            assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n            // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n            // static methods of the struct).\n            let _ = AES128 {};\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_random() {\n        // Same as `encrypt_decrypt_deterministic`, except we don't mock any of the oracles and rely on\n        // `TestEnvironment` instead.\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_to_invalid_address() {\n        // x = 3 is a non-residue for this curve, resulting in an invalid address\n        let invalid_address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n\n        let _ = AES128::encrypt([1, 2, 3, 4], invalid_address, contract_address);\n    }\n\n    // Documents the PKCS#7 padding behavior that `encrypt` relies on (see its static_assert).\n    #[test]\n    fn pkcs7_padding_always_adds_at_least_one_byte() {\n        let key = [0 as u8; 16];\n        let iv = [0 as u8; 16];\n\n        // 1 byte input + 15 bytes padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 1], iv, key).len(), 16);\n\n        // 15 bytes input + 1 byte padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 15], iv, key).len(), 16);\n\n        // 16 bytes input (block-aligned) + full 16-byte padding block = 32 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 16], iv, key).len(), 32);\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_max_size_plaintext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let mut plaintext = [0; MESSAGE_PLAINTEXT_LEN];\n            for i in 0..MESSAGE_PLAINTEXT_LEN {\n                plaintext[i] = i as Field;\n            }\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test(should_fail_with = \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\")]\n    unconstrained fn encrypt_oversized_plaintext() {\n        let address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n        let plaintext: [Field; MESSAGE_PLAINTEXT_LEN + 1] = [0; MESSAGE_PLAINTEXT_LEN + 1];\n        let _ = AES128::encrypt(plaintext, address, contract_address);\n    }\n\n    #[test]\n    unconstrained fn random_address_point_produces_valid_points() {\n        // About half of random addresses are invalid, so testing just a couple gives us high confidence that\n        // `random_address_point` is indeed producing valid addresses.\n        for _ in 0..10 {\n            let random_address = AztecAddress { inner: random_address_point().inner.x };\n            assert(random_address.to_address_point().is_some());\n        }\n    }\n\n    #[test]\n    unconstrained fn decrypt_invalid_ephemeral_public_key() {\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3, 4];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            // The first field of the ciphertext is the x-coordinate of the ephemeral public key. We set it to a known\n            // non-residue (3), causing `decrypt` to fail to produce a decryption shared secret.\n            let mut bad_ciphertext = BoundedVec::from_array(ciphertext);\n            bad_ciphertext.set(0, 3);\n\n            assert(AES128::decrypt(bad_ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_ciphertext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            assert(AES128::decrypt(BoundedVec::new(), recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header AES decrypt oracle to return an empty result. The TS oracle never throws on invalid\n    // input: it decrypts to garbage bytes or returns empty\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_header() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let empty_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::new();\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(empty_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header oracle to return a 2-byte header that decodes to a ciphertext_length one past the maximum\n    // allowed value, verifying the edge case is handled correctly.\n    #[test]\n    unconstrained fn decrypt_returns_none_on_oversized_ciphertext_length() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let bad_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(encode_header(\n                MESSAGE_PLAINTEXT_SIZE_IN_BYTES + 1,\n            ));\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(bad_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n}\n"
     },
-    "140": {
+    "141": {
       "function_locations": [
         {
           "name": "encode_private_event_message",
@@ -382,7 +382,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
       "source": "use crate::{\n    event::{event_interface::EventInterface, EventSelector},\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n    },\n    utils::array,\n};\nuse crate::protocol::traits::{FromField, Serialize, ToField};\n\n/// The number of fields in a private event message content that are not the event's serialized representation (1 field\n/// for randomness).\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 1;\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 0;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_event_message`].\npub fn encode_private_event_message<Event>(\n    event: Event,\n    randomness: Field,\n) -> [Field; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Event: EventInterface + Serialize,\n{\n    std::static_assert(\n        <Event as Serialize>::N <= MAX_EVENT_SERIALIZED_LEN,\n        \"event's serialized length exceeds the maximum allowed for private events\",\n    );\n\n    // We use `Serialize` because we want for events to be processable by off-chain actors, e.g. block explorers,\n    // wallets and apps, without having to rely on contract invocation. If we used `Packable` we'd need to call utility\n    // functions in order to unpack events, which would introduce a level of complexity we don't currently think is\n    // worth the savings in DA (for public events) and proving time (when encrypting private event messages).\n    let serialized_event = event.serialize();\n\n    // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_plaintext = [0; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N];\n    msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n\n    for i in 0..serialized_event.len() {\n        msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = serialized_event[i];\n    }\n\n    // The event type id is stored in the message metadata\n    encode_message(\n        PRIVATE_EVENT_MSG_TYPE_ID,\n        Event::get_event_type_id().to_field() as u64,\n        msg_plaintext,\n    )\n}\n\n/// Decodes the plaintext from a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_event_message`].\n///\n/// Note that while [`encode_private_event_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_event_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(EventSelector, Field, BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>)> {\n    if msg_content.len() <= PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n        // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // destructuring of the private event message encoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n            \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let randomness = msg_content.get(PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let serialized_event = array::subbvec(msg_content, PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((event_type_id, randomness, serialized_event))\n    }\n}\n\nmod test {\n    use crate::{\n        event::event_interface::EventInterface,\n        messages::{\n            encoding::decode_message,\n            logs::event::{decode_private_event_message, encode_private_event_message},\n            msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n        },\n    };\n    use crate::protocol::traits::Serialize;\n    use crate::test::mocks::mock_event::MockEvent;\n\n    global VALUE: Field = 7;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let event = MockEvent::new(VALUE).build_event();\n\n        let message_plaintext = encode_private_event_message(event, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_EVENT_MSG_TYPE_ID);\n\n        let (event_type_id, randomness, serialized_event) =\n            decode_private_event_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(event_type_id, MockEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event, BoundedVec::from_array(event.serialize()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_event_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0]);\n        assert(decode_private_event_message(0, content).is_none());\n    }\n}\n"
     },
-    "142": {
+    "143": {
       "function_locations": [
         {
           "name": "encode_private_note_message",
@@ -424,7 +424,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
       "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\n\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX: u32 = 1;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 2;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, randomness, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_note_message`].\npub fn encode_private_note_message<Note>(\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    let packed_note = note.pack();\n\n    // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_content = [0; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N];\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX] = storage_slot;\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    for i in 0..packed_note.len() {\n        msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_note[i];\n    }\n\n    // Notes use the note type id for metadata\n    encode_message(PRIVATE_NOTE_MSG_TYPE_ID, Note::get_id() as u64, msg_content)\n}\n\n/// Decodes the plaintext from a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_private_note_message`].\n///\n/// Note that while [`encode_private_note_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_note_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(Field, AztecAddress, Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>)> {\n    if msg_content.len() <= PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // decoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let owner = AztecAddress::from_field(msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX));\n        let storage_slot = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX);\n        let randomness = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((note_type_id, owner, storage_slot, randomness, packed_note))\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::note::{decode_private_note_message, encode_private_note_message, MAX_NOTE_PACKED_LEN},\n            msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global STORAGE_SLOT: Field = 9;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[derive(Packable)]\n    struct MaxSizeNote {\n        data: [Field; MAX_NOTE_PACKED_LEN],\n    }\n\n    impl NoteType for MaxSizeNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_note() {\n        let mut data = [0; MAX_NOTE_PACKED_LEN];\n        for i in 0..MAX_NOTE_PACKED_LEN {\n            data[i] = i as Field;\n        }\n        let note = MaxSizeNote { data };\n\n        let encoded = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n        let (msg_type_id, msg_metadata, msg_content) = decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MaxSizeNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(data));\n    }\n\n    #[derive(Packable)]\n    struct OversizedNote {\n        data: [Field; MAX_NOTE_PACKED_LEN + 1],\n    }\n\n    impl NoteType for OversizedNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_note_fails() {\n        let note = OversizedNote { data: [0; MAX_NOTE_PACKED_LEN + 1] };\n        let _ = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_note_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_only_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        assert(decode_private_note_message(0, content).is_none());\n    }\n}\n"
     },
-    "143": {
+    "144": {
       "function_locations": [
         {
           "name": "encode_partial_note_private_message",
@@ -450,7 +450,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/logs/partial_note.nr",
       "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 1;\npub(crate) global PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private message\n/// (e.g. the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n    MAX_MESSAGE_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a partial note private message (i.e. one of type [`PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_partial_note_private_message`].\npub fn encode_partial_note_private_message<PartialNotePrivateContent>(\n    partial_note_private_content: PartialNotePrivateContent,\n    owner: AztecAddress,\n    randomness: Field,\n    note_completion_log_tag: Field,\n    ) -> [Field; PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <PartialNotePrivateContent as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    PartialNotePrivateContent: NoteType + Packable,\n{\n    let packed_private_content = partial_note_private_content.pack();\n\n    // If PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then\n    // the encoding below must be updated as well.\n    std::static_assert(\n        PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN\",\n    );\n\n    let mut msg_content =\n        [0; PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <PartialNotePrivateContent as Packable>::N];\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX] = note_completion_log_tag;\n\n    for i in 0..packed_private_content.len() {\n        msg_content[PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_private_content[i];\n    }\n\n    encode_message(\n        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n        // Notes use the note type id for metadata\n        PartialNotePrivateContent::get_id() as u64,\n        msg_content,\n    )\n}\n\n/// Decodes the plaintext from a partial note private message (i.e. one of type\n/// [`PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` has too few fields. This plaintext is meant to have originated\n/// from [`encode_partial_note_private_message`].\n///\n/// Note that while [`encode_partial_note_private_message`] returns a fixed-size array, this function takes a\n/// [`BoundedVec`] instead. This is because when decoding we're typically processing runtime-sized plaintexts, more\n/// specifically, those that originate from\n/// [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_partial_note_private_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(AztecAddress, Field, Field, Field, BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>)> {\n    if msg_content.len() < PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id: Field = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail,\n        // then the destructuring of the partial note private message encoding below must be updated as well.\n        std::static_assert(\n            PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NON_NOTE_FIELDS_LEN\",\n        );\n\n        // We currently have three fields that are not the partial note's packed representation, which are the owner,\n        // the randomness, and the note completion log tag.\n        let owner = AztecAddress::from_field(\n            msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_OWNER_INDEX),\n        );\n        let randomness = msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let note_completion_log_tag = msg_content.get(PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_NOTE_COMPLETION_LOG_TAG_INDEX);\n\n        let packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN> = array::subbvec(\n            msg_content,\n            PARTIAL_NOTE_PRIVATE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN,\n        );\n\n        Option::some(\n            (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content),\n        )\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::partial_note::{decode_partial_note_private_message, encode_partial_note_private_message},\n            msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global RANDOMNESS: Field = 10;\n    global NOTE_COMPLETION_LOG_TAG: Field = 11;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        // Note that here we use MockNote as the private fields of a partial note\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_partial_note_private_message(note, OWNER, RANDOMNESS, NOTE_COMPLETION_LOG_TAG);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID);\n\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_note) =\n            decode_partial_note_private_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(note_completion_log_tag, NOTE_COMPLETION_LOG_TAG);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_partial_note_private_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([0, 0, 0]);\n        let (_, _, _, _, packed_note) = decode_partial_note_private_message(0, content).unwrap();\n        assert_eq(packed_note.len(), 0);\n    }\n}\n"
     },
-    "153": {
+    "154": {
       "function_locations": [
         {
           "name": "enqueue_note_for_validation",
@@ -472,59 +472,59 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
       "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\nmod message_context;\npub use message_context::MessageContext;\n\npub(crate) mod note_validation_request;\npub(crate) mod log_retrieval_request;\npub(crate) mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\n\nuse crate::{\n    capsules::CapsuleArray,\n    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\n        discovery::partial_notes::DeliveredPendingPartialNote,\n        encoding::MESSAGE_CIPHERTEXT_LEN,\n        logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},\n        processing::{\n            log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse,\n            note_validation_request::NoteValidationRequest,\n        },\n    },\n    oracle::message_processing,\n};\nuse crate::protocol::{\n    address::AztecAddress,\n    constants::DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n    hash::{compute_log_tag, sha256_to_field},\n    traits::{Deserialize, Serialize},\n};\nuse event_validation_request::EventValidationRequest;\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// An offchain-delivered message with resolved context, ready for processing during sync.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessageWithContext {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub message_context: MessageContext,\n}\n\n/// Enqueues a note for validation and storage by PXE.\n///\n/// Once validated, the note becomes retrievable via the `get_notes` oracle. The note will be scoped to\n/// `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// In order for the note validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many note validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// The `packed_note` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value is\n/// typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are the\n/// inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and `NoteHash::compute_nullifier`. PXE\n/// will verify that the siloed unique note hash was inserted into the tree at `tx_hash`, and will store the nullifier\n/// to later check for nullification.\n///\n/// `owner` is the address used in note hash and nullifier computation, often requiring knowledge of their nullifier\n/// secret key.\n///\n/// `scope` is the account to which the note message was delivered (i.e. the address the message was encrypted to).\n/// This determines which PXE account can see the note - other accounts will not be able to access it (e.g. other\n/// accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized. In\n/// most cases `recipient` equals `owner`, but they can differ in scenarios like delegated discovery.\npub unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        NoteValidationRequest {\n            contract_address,\n            owner,\n            storage_slot,\n            randomness,\n            note_nonce,\n            packed_note,\n            note_hash,\n            nullifier,\n            tx_hash,\n        },\n    )\n}\n\n/// Enqueues an event for validation and storage by PXE.\n///\n/// This is the primary way for custom message handlers (registered via\n/// [`crate::macros::AztecConfig::custom_message_handler`]) to deliver reassembled events back to PXE after processing\n/// application-specific message formats.\n///\n/// In order for the event validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many event validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// Note that `validate_and_store_enqueued_notes_and_events` is called by Aztec.nr after processing messages, so custom\n/// message processors do not need to be concerned with this.\npub unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    randomness: Field,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(\n        EventValidationRequest {\n            contract_address,\n            event_type_id,\n            randomness,\n            serialized_event,\n            event_commitment,\n            tx_hash,\n        },\n    )\n}\n\n/// Validates and stores all enqueued notes and events.\n///\n/// Processes all requests enqueued via [`enqueue_note_for_validation`] and [`enqueue_event_for_validation`], inserting\n/// them into the note database and event store respectively, making them queryable via `get_notes` oracle and our TS\n/// API (PXE::getPrivateEvents).\npub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAddress) {\n    message_processing::validate_and_store_enqueued_notes_and_events(\n        NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n        EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT,\n        MAX_NOTE_PACKED_LEN as Field,\n        MAX_EVENT_SERIALIZED_LEN as Field,\n        scope,\n    );\n\n    // Defensive clearing: purge the queues after processing to prevent double-processing if this function is called\n    // more than once in the same call frame. It is currently defensive because we only call this once per sync run.\n    let _ = EphemeralArray::<NoteValidationRequest>::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n    let _ = EphemeralArray::<EventValidationRequest>::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s stored in\n/// a `CapsuleArray` by performing all node communication concurrently. Returns an `EphemeralArray` with Options\n/// for the responses that correspond to the pending partial notes at the same index.\n///\n/// For example, given an array with pending partial notes `[ p1, p2, p3 ]`, where `p1` and `p3` have corresponding\n/// completion logs but `p2` does not, the returned `EphemeralArray` will have contents `[some(p1_log), none(),\n/// some(p3_log)]`.\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: CapsuleArray<DeliveredPendingPartialNote>,\n) -> EphemeralArray<Option<LogRetrievalResponse>> {\n    let log_retrieval_requests = EphemeralArray::at(LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    // We create a LogRetrievalRequest for each PendingPartialNote in the EphemeralArray. Because we need the indices in\n    // the request array to match the indices in the partial note array, we can't use EphemeralArray::for_each, as that\n    // function has arbitrary iteration order. Instead, we manually iterate the array from the beginning and push into\n    // the requests array, which we expect to be empty.\n    let mut i = 0;\n    let pending_partial_notes_count = pending_partial_notes.len();\n    while i < pending_partial_notes_count {\n        let pending_partial_note = pending_partial_notes.get(i);\n        // Partial note completion logs are emitted with a domain-separated tag. To find matching logs, we apply the\n        // same domain separation to the stored raw tag.\n        let log_tag = compute_log_tag(\n            pending_partial_note.note_completion_log_tag,\n            DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n        );\n        log_retrieval_requests.push(LogRetrievalRequest { contract_address, unsiloed_tag: log_tag });\n        i += 1;\n    }\n\n    let responses = message_processing::get_logs_by_tag(log_retrieval_requests);\n\n    // Defensive clearing: prevent stale requests if this function is called more than once in the same call frame.\n    let _ = log_retrieval_requests.clear();\n\n    responses\n}\n"
     },
-    "155": {
+    "156": {
       "function_locations": [
         {
           "name": "receive",
-          "start": 5298
+          "start": 5332
         },
         {
           "name": "sync_inbox",
-          "start": 6741
+          "start": 6775
         },
         {
           "name": "test::setup",
-          "start": 11111
+          "start": 11145
         },
         {
           "name": "test::make_msg",
-          "start": 11441
+          "start": 11475
         },
         {
           "name": "test::advance_by",
-          "start": 11724
+          "start": 11758
         },
         {
           "name": "test::empty_inbox_returns_empty_result",
-          "start": 11915
+          "start": 11949
         },
         {
           "name": "test::tx_bound_msg_expires_after_max_msg_ttl",
-          "start": 12378
+          "start": 12412
         },
         {
           "name": "test::tx_bound_msg_not_expired_before_max_msg_ttl",
-          "start": 13343
+          "start": 13377
         },
         {
           "name": "test::tx_less_msg_expires_after_max_msg_ttl",
-          "start": 14301
+          "start": 14335
         },
         {
           "name": "test::unresolved_tx_stays_in_inbox",
-          "start": 15243
+          "start": 15277
         },
         {
           "name": "test::multiple_messages_mixed_expiration",
-          "start": 16137
+          "start": 16171
         },
         {
           "name": "test::resolved_msg_is_ready_to_process",
-          "start": 17876
+          "start": 17910
         }
       ],
       "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(crate) type OffchainInboxSync<Env> = unconstrained fn[Env](\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// A message delivered via the `offchain_receive` utility function.\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\n/// An offchain message awaiting processing (or re-processing) in the inbox.\n///\n/// Messages remain in the inbox until they expire, even if they have already been processed. This is necessary to\n/// handle reorgs: a processed message may need to be re-processed if the transaction that provided its context is\n/// reverted. On each sync, resolved messages are promoted to [`OffchainMessageWithContext`] for processing.\n#[derive(Serialize, Deserialize)]\nstruct PendingOffchainMsg {\n    /// The encrypted message payload.\n    ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. A value of 0 indicates a tx-less message.\n    tx_hash: Field,\n    /// Anchor block timestamp at message emission. Used to compute the effective expiration: messages are evicted\n    /// after `anchor_block_timestamp + MAX_MSG_TTL`.\n    anchor_block_timestamp: u64,\n}\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Each message is routed to the inbox scoped to its `recipient` field, so messages for different accounts are\n/// automatically isolated.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The effective expiration is\n/// `anchor_block_timestamp + MAX_MSG_TTL`.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // May contain duplicates if multiple messages target the same recipient. This is harmless since\n    // cache invalidation on the TS side is idempotent (deleting an already-deleted key is a no-op).\n    let mut scopes: BoundedVec<AztecAddress, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n    let mut i = 0;\n    let messages_len = messages.len();\n    while i < messages_len {\n        let msg = messages.get(i);\n        let tx_hash = if msg.tx_hash.is_some() {\n            msg.tx_hash.unwrap()\n        } else {\n            0\n        };\n        let inbox: CapsuleArray<PendingOffchainMsg> =\n            CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, msg.recipient);\n        inbox.push(\n            PendingOffchainMsg {\n                ciphertext: msg.ciphertext,\n                recipient: msg.recipient,\n                tx_hash,\n                anchor_block_timestamp: msg.anchor_block_timestamp,\n            },\n        );\n        scopes.push(msg.recipient);\n        i += 1;\n    }\n\n    set_contract_sync_cache_invalid(contract_address, scopes);\n}\n\n/// Returns offchain-delivered messages to process during sync.\n///\n/// Messages remain in the inbox and are reprocessed on each sync until their originating transaction is no longer at\n/// risk of being dropped by a reorg.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, scope);\n    let context_resolution_requests: EphemeralArray<Field> = EphemeralArray::at(OFFCHAIN_CONTEXT_REQUESTS_SLOT).clear();\n    let ready_to_process: EphemeralArray<OffchainMessageWithContext> =\n        EphemeralArray::at(OFFCHAIN_READY_MESSAGES_SLOT).clear();\n\n    // Build a request list aligned with the inbox indices.\n    let mut i = 0;\n    let inbox_len = inbox.len();\n    while i < inbox_len {\n        let msg = inbox.get(i);\n        context_resolution_requests.push(msg.tx_hash);\n        i += 1;\n    }\n\n    // Ask PXE to resolve contexts for all requested tx hashes. The oracle returns responses in a new\n    // ephemeral array.\n    let resolved_contexts =\n        crate::oracle::message_processing::get_message_contexts_by_tx_hash(context_resolution_requests);\n\n    assert_eq(resolved_contexts.len(), inbox_len);\n\n    let now = UtilityContext::new().timestamp();\n\n    let mut j = inbox_len;\n    while j > 0 {\n        // This loop decides what to do with each message in the offchain message inbox. We need to handle 3\n        // different scenarios for each message.\n        //\n        // 1. The TX that emitted this message is still not known to PXE: in this case we can't yet process this\n        // message, as any notes or events discovered will fail to be validated. So we leave the message in the inbox,\n        // awaiting for future syncs to detect that the TX became available.\n        //\n        // 2. The message is not associated to a TX to begin with. The current version of offchain message processing\n        // does not support this case, but in the future it will. Right now, a message without an associated TX will\n        // sit in the inbox until it expires.\n        //\n        // 3. The TX that emitted this message has been found by PXE. That gives us all the information needed to\n        // process the message. We add the message to the `ready_to_process` EphemeralArray so that the `sync_state`\n        // loop\n        // processes it.\n        //\n        // In all cases, if the message has expired (i.e. `now > anchor_block_timestamp + MAX_MSG_TTL`), we remove it\n        // from the inbox.\n        //\n        // Note: the loop runs backwards because it might call `inbox.remove(j)` to purge expired messages and we also\n        // need to align it with `resolved_contexts.get(j)`. Going from last to first simplifies the algorithm as\n        // not yet visited element indexes remain stable.\n        j -= 1;\n        let maybe_ctx = resolved_contexts.get(j);\n        let msg = inbox.get(j);\n\n        // Compute the message's effective expiration timestamp to determine if we can purge it from the inbox.\n        let effective_expiration = msg.anchor_block_timestamp + MAX_MSG_TTL;\n\n        // Message expired. We remove it from the inbox.\n        if now > effective_expiration {\n            inbox.remove(j);\n        }\n\n        // Scenario 1: associated TX not yet available. We keep the message in the inbox, as it might become\n        // processable as new blocks get mined.\n        // Scenario 2: no TX associated to message. The message will sit in the inbox until it expires.\n        if maybe_ctx.is_none() {\n            continue;\n        }\n\n        // Scenario 3: Message is ready to process, add to result array. Note we still keep it in the inbox unless we\n        // consider it has expired: this is because we need to account for reorgs. If reorg occurs after we processed\n        // a message, the effects of processing the message get rewind. However, the associated TX can be included in\n        // a subsequent block. Should that happen, the message must be re-processed to ensure consistency.\n        let message_context = maybe_ctx.unwrap();\n        ready_to_process.push(OffchainMessageWithContext { message_ciphertext: msg.ciphertext, message_context });\n    }\n\n    ready_to_process\n}\n\nmod test {\n    use crate::{\n        capsules::CapsuleArray, oracle::random::random, protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{\n        MAX_MSG_TTL, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OFFCHAIN_INBOX_SLOT, OffchainMessage, PendingOffchainMsg,\n        receive, sync_inbox,\n    };\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let result = sync_inbox(context.this_address(), scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> =\n                CapsuleArray::at(context.this_address(), OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(inbox.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_not_expired_before_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance, but not past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_less_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::none(), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_tx_stays_in_inbox() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // not resolved, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let survivor_tx_hash = random();\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor_ts in the past so it expires at\n            // anchor_ts + MAX_MSG_TTL. We set anchor to 0 so it expires quickly.\n            msgs.push(make_msg(scope, Option::some(random()), 0));\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(make_msg(scope, Option::some(survivor_tx_hash), anchor_ts));\n            // Message 2: tx-less, anchor_ts=0 so it also expires.\n            msgs.push(make_msg(scope, Option::none(), 0));\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor_ts=0, but not for anchor_ts=anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            // Message 0 expired (anchor=0), message 1 survived (anchor=anchor_ts),\n            // Message 2 expired (anchor=0).\n            assert_eq(inbox.len(), 1);\n            assert_eq(inbox.get(0).tx_hash, survivor_tx_hash);\n        });\n    }\n\n    // -- Resolved context (ready to process) ------------------------------\n\n    #[test]\n    unconstrained fn resolved_msg_is_ready_to_process() {\n        let (env, scope) = setup();\n        // TestEnvironment::new() deploys protocol contracts, creating blocks with tx effects.\n        // In TXE, tx hashes equal Fr(blockNumber), so Fr(1) is the tx effect from block 1.\n        // We use this as a \"known resolvable\" tx hash.\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(known_tx_hash), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            // The message should be ready to process since its tx context was resolved.\n            assert_eq(result.len(), 1);\n\n            let ctx = result.get(0).message_context;\n            assert_eq(ctx.tx_hash, known_tx_hash);\n            assert(ctx.first_nullifier_in_tx != 0, \"resolved context must have a first nullifier\");\n\n            // Message stays in inbox (not expired) for potential reorg reprocessing.\n            assert_eq(inbox.len(), 1);\n        });\n    }\n}\n"
+      "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(crate) type OffchainInboxSync<Env> = unconstrained fn[Env](\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithContext>;\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\n/// An offchain message awaiting processing (or re-processing) in the inbox.\n///\n/// Messages remain in the inbox until they expire, even if they have already been processed. This is necessary to\n/// handle reorgs: a processed message may need to be re-processed if the transaction that provided its context is\n/// reverted. On each sync, resolved messages are promoted to [`OffchainMessageWithContext`] for processing.\n#[derive(Serialize, Deserialize)]\nstruct PendingOffchainMsg {\n    /// The encrypted message payload.\n    ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. A value of 0 indicates a tx-less message.\n    tx_hash: Field,\n    /// Anchor block timestamp at message emission. Used to compute the effective expiration: messages are evicted\n    /// after `anchor_block_timestamp + MAX_MSG_TTL`.\n    anchor_block_timestamp: u64,\n}\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Each message is routed to the inbox scoped to its `recipient` field, so messages for different accounts are\n/// automatically isolated.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are kept in the inbox until they expire. The effective expiration is\n/// `anchor_block_timestamp + MAX_MSG_TTL`.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // May contain duplicates if multiple messages target the same recipient. This is harmless since\n    // cache invalidation on the TS side is idempotent (deleting an already-deleted key is a no-op).\n    let mut scopes: BoundedVec<AztecAddress, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n    let mut i = 0;\n    let messages_len = messages.len();\n    while i < messages_len {\n        let msg = messages.get(i);\n        let tx_hash = if msg.tx_hash.is_some() {\n            msg.tx_hash.unwrap()\n        } else {\n            0\n        };\n        let inbox: CapsuleArray<PendingOffchainMsg> =\n            CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, msg.recipient);\n        inbox.push(\n            PendingOffchainMsg {\n                ciphertext: msg.ciphertext,\n                recipient: msg.recipient,\n                tx_hash,\n                anchor_block_timestamp: msg.anchor_block_timestamp,\n            },\n        );\n        scopes.push(msg.recipient);\n        i += 1;\n    }\n\n    set_contract_sync_cache_invalid(contract_address, scopes);\n}\n\n/// Returns offchain-delivered messages to process during sync.\n///\n/// Messages remain in the inbox and are reprocessed on each sync until their originating transaction is no longer at\n/// risk of being dropped by a reorg.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithContext> {\n    let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(contract_address, OFFCHAIN_INBOX_SLOT, scope);\n    let context_resolution_requests: EphemeralArray<Field> = EphemeralArray::at(OFFCHAIN_CONTEXT_REQUESTS_SLOT).clear();\n    let ready_to_process: EphemeralArray<OffchainMessageWithContext> =\n        EphemeralArray::at(OFFCHAIN_READY_MESSAGES_SLOT).clear();\n\n    // Build a request list aligned with the inbox indices.\n    let mut i = 0;\n    let inbox_len = inbox.len();\n    while i < inbox_len {\n        let msg = inbox.get(i);\n        context_resolution_requests.push(msg.tx_hash);\n        i += 1;\n    }\n\n    // Ask PXE to resolve contexts for all requested tx hashes. The oracle returns responses in a new\n    // ephemeral array.\n    let resolved_contexts =\n        crate::oracle::message_processing::get_message_contexts_by_tx_hash(context_resolution_requests);\n\n    assert_eq(resolved_contexts.len(), inbox_len);\n\n    let now = UtilityContext::new().timestamp();\n\n    let mut j = inbox_len;\n    while j > 0 {\n        // This loop decides what to do with each message in the offchain message inbox. We need to handle 3\n        // different scenarios for each message.\n        //\n        // 1. The TX that emitted this message is still not known to PXE: in this case we can't yet process this\n        // message, as any notes or events discovered will fail to be validated. So we leave the message in the inbox,\n        // awaiting for future syncs to detect that the TX became available.\n        //\n        // 2. The message is not associated to a TX to begin with. The current version of offchain message processing\n        // does not support this case, but in the future it will. Right now, a message without an associated TX will\n        // sit in the inbox until it expires.\n        //\n        // 3. The TX that emitted this message has been found by PXE. That gives us all the information needed to\n        // process the message. We add the message to the `ready_to_process` EphemeralArray so that the `sync_state`\n        // loop\n        // processes it.\n        //\n        // In all cases, if the message has expired (i.e. `now > anchor_block_timestamp + MAX_MSG_TTL`), we remove it\n        // from the inbox.\n        //\n        // Note: the loop runs backwards because it might call `inbox.remove(j)` to purge expired messages and we also\n        // need to align it with `resolved_contexts.get(j)`. Going from last to first simplifies the algorithm as\n        // not yet visited element indexes remain stable.\n        j -= 1;\n        let maybe_ctx = resolved_contexts.get(j);\n        let msg = inbox.get(j);\n\n        // Compute the message's effective expiration timestamp to determine if we can purge it from the inbox.\n        let effective_expiration = msg.anchor_block_timestamp + MAX_MSG_TTL;\n\n        // Message expired. We remove it from the inbox.\n        if now > effective_expiration {\n            inbox.remove(j);\n        }\n\n        // Scenario 1: associated TX not yet available. We keep the message in the inbox, as it might become\n        // processable as new blocks get mined.\n        // Scenario 2: no TX associated to message. The message will sit in the inbox until it expires.\n        if maybe_ctx.is_none() {\n            continue;\n        }\n\n        // Scenario 3: Message is ready to process, add to result array. Note we still keep it in the inbox unless we\n        // consider it has expired: this is because we need to account for reorgs. If reorg occurs after we processed\n        // a message, the effects of processing the message get rewind. However, the associated TX can be included in\n        // a subsequent block. Should that happen, the message must be re-processed to ensure consistency.\n        let message_context = maybe_ctx.unwrap();\n        ready_to_process.push(OffchainMessageWithContext { message_ciphertext: msg.ciphertext, message_context });\n    }\n\n    ready_to_process\n}\n\nmod test {\n    use crate::{\n        capsules::CapsuleArray, oracle::random::random, protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{\n        MAX_MSG_TTL, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OFFCHAIN_INBOX_SLOT, OffchainMessage, PendingOffchainMsg,\n        receive, sync_inbox,\n    };\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let result = sync_inbox(context.this_address(), scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> =\n                CapsuleArray::at(context.this_address(), OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(inbox.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_bound_msg_not_expired_before_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance, but not past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn tx_less_msg_expires_after_max_msg_ttl() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::none(), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        // Advance past anchor_ts + MAX_MSG_TTL.\n        let _now = advance_by(env, MAX_MSG_TTL + 1);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // context is None, not ready\n            assert_eq(inbox.len(), 0); // expired, removed\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_tx_stays_in_inbox() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(random()), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // not resolved, not ready\n            assert_eq(inbox.len(), 1); // not expired, stays\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let survivor_tx_hash = random();\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor_ts in the past so it expires at\n            // anchor_ts + MAX_MSG_TTL. We set anchor to 0 so it expires quickly.\n            msgs.push(make_msg(scope, Option::some(random()), 0));\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(make_msg(scope, Option::some(survivor_tx_hash), anchor_ts));\n            // Message 2: tx-less, anchor_ts=0 so it also expires.\n            msgs.push(make_msg(scope, Option::none(), 0));\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor_ts=0, but not for anchor_ts=anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            // Message 0 expired (anchor=0), message 1 survived (anchor=anchor_ts),\n            // Message 2 expired (anchor=0).\n            assert_eq(inbox.len(), 1);\n            assert_eq(inbox.get(0).tx_hash, survivor_tx_hash);\n        });\n    }\n\n    // -- Resolved context (ready to process) ------------------------------\n\n    #[test]\n    unconstrained fn resolved_msg_is_ready_to_process() {\n        let (env, scope) = setup();\n        // TestEnvironment::new() deploys protocol contracts, creating blocks with tx effects.\n        // In TXE, tx hashes equal Fr(blockNumber), so Fr(1) is the tx effect from block 1.\n        // We use this as a \"known resolvable\" tx hash.\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n\n        env.utility_context(|context| {\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            msgs.push(make_msg(scope, Option::some(known_tx_hash), anchor_ts));\n            receive(context.this_address(), msgs);\n        });\n\n        let _now = advance_by(env, 100);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n            let inbox: CapsuleArray<PendingOffchainMsg> = CapsuleArray::at(address, OFFCHAIN_INBOX_SLOT, scope);\n\n            // The message should be ready to process since its tx context was resolved.\n            assert_eq(result.len(), 1);\n\n            let ctx = result.get(0).message_context;\n            assert_eq(ctx.tx_hash, known_tx_hash);\n            assert(ctx.first_nullifier_in_tx != 0, \"resolved context must have a first nullifier\");\n\n            // Message stays in inbox (not expired) for potential reorg reprocessing.\n            assert_eq(inbox.len(), 1);\n        });\n    }\n}\n"
     },
     "16": {
       "function_locations": [
@@ -814,7 +814,7 @@
       "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    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\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    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\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\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\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\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]\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    /// 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"
     },
-    "173": {
+    "174": {
       "function_locations": [
         {
           "name": "aes128_decrypt_oracle",
@@ -836,7 +836,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/aes128_decrypt.nr",
       "source": "#[oracle(aztec_utl_decryptAes128)]\nunconstrained fn aes128_decrypt_oracle<let N: u32>(\n    ciphertext: BoundedVec<u8, N>,\n    iv: [u8; 16],\n    sym_key: [u8; 16],\n) -> Option<BoundedVec<u8, N>> {}\n\n/// Attempts to decrypt a ciphertext using AES128.\n///\n/// Returns `Option::some(plaintext)` on success, or `Option::none()` if decryption fails (e.g. due to malformed\n/// ciphertext or invalid PKCS#7 padding). Note that decryption with the wrong key will almost always return `None`\n/// because the decrypted garbage data will have invalid PKCS#7 padding.\n///\n/// Note that we accept ciphertext as a BoundedVec, not as an array. This is because this function is typically used\n/// when processing logs and at that point we don't have comptime information about the length of the ciphertext as\n/// the log is not specific to any individual note.\n// TODO(F-498): review naming consistency\npub unconstrained fn try_aes128_decrypt<let N: u32>(\n    ciphertext: BoundedVec<u8, N>,\n    iv: [u8; 16],\n    sym_key: [u8; 16],\n) -> Option<BoundedVec<u8, N>> {\n    aes128_decrypt_oracle(ciphertext, iv, sym_key)\n}\n\nmod test {\n    use crate::{\n        keys::ecdh_shared_secret::compute_app_siloed_shared_secret,\n        messages::encryption::aes128::derive_aes_symmetric_key_and_iv_from_shared_secret,\n        utils::{array::subarray::subarray, point::point_from_x_coord},\n    };\n    use crate::protocol::address::AztecAddress;\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::try_aes128_decrypt;\n    use std::aes128::aes128_encrypt;\n\n    global CONTRACT_ADDRESS: AztecAddress = AztecAddress { inner: 42 };\n    global TEST_PLAINTEXT_LENGTH: u32 = 10;\n    global TEST_CIPHERTEXT_LENGTH: u32 = 16;\n    global TEST_PADDING_LENGTH: u32 = TEST_CIPHERTEXT_LENGTH - TEST_PLAINTEXT_LENGTH;\n\n    #[test]\n    unconstrained fn aes_encrypt_then_decrypt() {\n        let env = TestEnvironment::new();\n\n        env.utility_context(|_| {\n            let shared_secret_point = point_from_x_coord(1).unwrap();\n            let s_app = compute_app_siloed_shared_secret(shared_secret_point, CONTRACT_ADDRESS);\n\n            let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_shared_secret::<1>(s_app)[0];\n\n            let plaintext: [u8; TEST_PLAINTEXT_LENGTH] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n\n            let ciphertext: [u8; TEST_CIPHERTEXT_LENGTH] = aes128_encrypt(plaintext, iv, sym_key);\n\n            let ciphertext_bvec = BoundedVec::<u8, TEST_CIPHERTEXT_LENGTH>::from_array(ciphertext);\n\n            let received_plaintext = try_aes128_decrypt(ciphertext_bvec, iv, sym_key).unwrap();\n            assert_eq(received_plaintext.len(), TEST_PLAINTEXT_LENGTH);\n            assert_eq(received_plaintext.max_len(), TEST_CIPHERTEXT_LENGTH);\n            assert_eq(subarray::<_, _, TEST_PLAINTEXT_LENGTH>(received_plaintext.storage(), 0), plaintext);\n            assert_eq(\n                subarray::<_, _, TEST_PADDING_LENGTH>(received_plaintext.storage(), TEST_PLAINTEXT_LENGTH),\n                [0 as u8; TEST_PADDING_LENGTH],\n            );\n        })\n    }\n\n    #[test]\n    unconstrained fn aes_encrypt_then_decrypt_with_bad_sym_key_is_caught() {\n        let env = TestEnvironment::new();\n\n        env.utility_context(|_| {\n            // Decrypting with the wrong key results in garbage data with invalid PKCS#7 padding,\n            // so the oracle returns None.\n            let shared_secret_point = point_from_x_coord(1).unwrap();\n            let s_app = compute_app_siloed_shared_secret(shared_secret_point, CONTRACT_ADDRESS);\n\n            let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_shared_secret::<1>(s_app)[0];\n\n            let plaintext: [u8; TEST_PLAINTEXT_LENGTH] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n            let ciphertext: [u8; TEST_CIPHERTEXT_LENGTH] = aes128_encrypt(plaintext, iv, sym_key);\n\n            let mut bad_sym_key = sym_key;\n            bad_sym_key[0] = 0;\n\n            let ciphertext_bvec = BoundedVec::<u8, TEST_CIPHERTEXT_LENGTH>::from_array(ciphertext);\n            // Decryption with wrong key returns None because the garbage output has invalid PKCS#7 padding.\n            let result = try_aes128_decrypt(ciphertext_bvec, iv, bad_sym_key);\n            assert(result.is_none(), \"decryption with bad key should return None\");\n        });\n    }\n}\n"
     },
-    "175": {
+    "176": {
       "function_locations": [
         {
           "name": "address",
@@ -1074,7 +1074,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/avm.nr",
       "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> bool {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> bool {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> bool {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> bool {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> bool {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> bool {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "178": {
+    "179": {
       "function_locations": [
         {
           "name": "store",
@@ -1168,20 +1168,6 @@
       "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"
     },
-    "179": {
-      "function_locations": [
-        {
-          "name": "set_contract_sync_cache_invalid_oracle",
-          "start": 242
-        },
-        {
-          "name": "set_contract_sync_cache_invalid",
-          "start": 700
-        }
-      ],
-      "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"
-    },
     "18": {
       "function_locations": [
         {
@@ -1336,7 +1322,21 @@
       "path": "std/hash/mod.nr",
       "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n        },\n    );\n}\n"
     },
-    "181": {
+    "180": {
+      "function_locations": [
+        {
+          "name": "set_contract_sync_cache_invalid_oracle",
+          "start": 242
+        },
+        {
+          "name": "set_contract_sync_cache_invalid",
+          "start": 700
+        }
+      ],
+      "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"
+    },
+    "182": {
       "function_locations": [
         {
           "name": "get_utility_context_oracle",
@@ -1350,7 +1350,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"
     },
-    "191": {
+    "192": {
       "function_locations": [
         {
           "name": "get_pending_tagged_logs",
@@ -1388,7 +1388,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::messages::processing::{\n    log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse, MessageContext,\n    pending_tagged_log::PendingTaggedLog,\n};\nuse crate::protocol::address::AztecAddress;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and\n/// returns them in an ephemeral array with an oracle-allocated base slot.\npub(crate) unconstrained fn get_pending_tagged_logs(scope: AztecAddress) -> EphemeralArray<PendingTaggedLog> {\n    let result_slot = get_pending_tagged_logs_oracle(scope);\n    EphemeralArray::at(result_slot)\n}\n\n#[oracle(aztec_utl_getPendingTaggedLogs_v2)]\nunconstrained fn get_pending_tagged_logs_oracle(scope: AztecAddress) -> Field {}\n\n/// Validates note/event requests stored in ephemeral arrays.\npub(crate) unconstrained fn validate_and_store_enqueued_notes_and_events(\n    note_validation_requests_array_slot: Field,\n    event_validation_requests_array_slot: Field,\n    max_note_packed_len: Field,\n    max_event_serialized_len: Field,\n    scope: AztecAddress,\n) {\n    validate_and_store_enqueued_notes_and_events_oracle(\n        note_validation_requests_array_slot,\n        event_validation_requests_array_slot,\n        max_note_packed_len,\n        max_event_serialized_len,\n        scope,\n    );\n}\n\n#[oracle(aztec_utl_validateAndStoreEnqueuedNotesAndEvents_v2)]\nunconstrained fn validate_and_store_enqueued_notes_and_events_oracle(\n    note_validation_requests_array_slot: Field,\n    event_validation_requests_array_slot: Field,\n    max_note_packed_len: Field,\n    max_event_serialized_len: Field,\n    scope: AztecAddress,\n) {}\n\n/// Fetches logs by tag from an ephemeral request array and returns a response ephemeral array.\npub(crate) unconstrained fn get_logs_by_tag(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<Option<LogRetrievalResponse>> {\n    let response_slot = get_logs_by_tag_v2_oracle(requests.slot);\n    EphemeralArray::at(response_slot)\n}\n\n#[oracle(aztec_utl_getLogsByTag_v2)]\nunconstrained fn get_logs_by_tag_v2_oracle(request_array_slot: Field) -> Field {}\n\n/// Resolves message contexts for tx hashes in an ephemeral request array and returns a response ephemeral array.\npub(crate) unconstrained fn get_message_contexts_by_tx_hash(\n    requests: EphemeralArray<Field>,\n) -> EphemeralArray<Option<MessageContext>> {\n    let response_slot = get_message_contexts_by_tx_hash_v2_oracle(requests.slot);\n    EphemeralArray::at(response_slot)\n}\n\n#[oracle(aztec_utl_getMessageContextsByTxHash_v2)]\nunconstrained fn get_message_contexts_by_tx_hash_v2_oracle(request_array_slot: Field) -> Field {}\n"
     },
-    "198": {
+    "199": {
       "function_locations": [
         {
           "name": "get_shared_secret_oracle",
@@ -1402,7 +1402,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
       "source": "use crate::protocol::address::aztec_address::AztecAddress;\nuse crate::protocol::point::Point;\n\n#[oracle(aztec_utl_getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(\n    address: AztecAddress,\n    ephPk: Point,\n    contract_address: AztecAddress,\n) -> Field {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an ephemeral\n/// public key `ephPk`.\n///\n/// The returned value is a Field `s_app`, computed as:\n///\n/// ```text\n/// S     = address_secret * ephPk          (raw ECDH point)\n/// s_app = h(DOM_SEP, S.x, S.y, contract)  (app-siloed scalar)\n/// ```\n///\n/// where `contract` is the address of the calling contract. The oracle host validates this matches its execution\n/// context.\n///\n/// Without app-siloing, a malicious contract could call this oracle with public information (address, ephPk) and\n/// obtain the same raw secret as the legitimate contract, enabling cross-contract decryption. By including the\n/// contract address in the hash, each contract receives a different `s_app`, preventing this attack.\n///\n/// Callers derive indexed subkeys from `s_app` via\n/// [`derive_shared_secret_subkey`](crate::keys::ecdh_shared_secret::derive_shared_secret_subkey).\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point, contract_address: AztecAddress) -> Field {\n    get_shared_secret_oracle(address, ephPk, contract_address)\n}\n"
     },
-    "247": {
+    "248": {
       "function_locations": [
         {
           "name": "append",
@@ -1424,7 +1424,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends the elements of the second `BoundedVec` to the end of the first one. The resulting `BoundedVec` can have\n/// any arbitrary maximum length, but it must be large enough to fit all of the elements of both the first and second\n/// vectors.\npub fn append<T, let ALen: u32, let BLen: u32, let DstLen: u32>(\n    a: BoundedVec<T, ALen>,\n    b: BoundedVec<T, BLen>,\n) -> BoundedVec<T, DstLen> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "250": {
+    "251": {
       "function_locations": [
         {
           "name": "subarray",
@@ -1454,7 +1454,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DstLen` elements from a source array, starting at `offset`. `DstLen` must not be larger than the number of\n/// elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SrcLen: u32, let DstLen: u32>(src: [T; SrcLen], offset: u32) -> [T; DstLen] {\n    assert(offset + DstLen <= SrcLen, \"DstLen too large for offset\");\n\n    let mut dst: [T; DstLen] = std::mem::zeroed();\n    for i in 0..DstLen {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DstLen to be 0, so we always get back an empty array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "251": {
+    "252": {
       "function_locations": [
         {
           "name": "subbvec",
@@ -1496,7 +1496,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DstMaxLen` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DstLen` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DstLen` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SrcMaxLen: u32, let DstMaxLen: u32>(\n    bvec: BoundedVec<T, SrcMaxLen>,\n    offset: u32,\n) -> BoundedVec<T, DstMaxLen> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not support capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "253": {
+    "254": {
       "function_locations": [
         {
           "name": "compare",
@@ -1510,7 +1510,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
       "source": "struct ComparatorEnum {\n    pub EQ: u8,\n    pub NEQ: u8,\n    pub LT: u8,\n    pub LTE: u8,\n    pub GT: u8,\n    pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum = ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n    // Values are computed ahead of time because circuits evaluate all branches\n    let is_equal = lhs == rhs;\n    let is_lt = lhs.lt(rhs);\n\n    if (operation == Comparator.EQ) {\n        is_equal\n    } else if (operation == Comparator.NEQ) {\n        !is_equal\n    } else if (operation == Comparator.LT) {\n        is_lt\n    } else if (operation == Comparator.LTE) {\n        is_lt | is_equal\n    } else if (operation == Comparator.GT) {\n        !is_lt & !is_equal\n    } else if (operation == Comparator.GTE) {\n        !is_lt\n    } else {\n        panic(f\"Invalid operation\")\n    }\n}\n\nmod test {\n    use super::Comparator;\n    use super::compare;\n\n    #[test]\n    unconstrained fn test_compare() {\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GTE, rhs), \"Expected lhs to be greater than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GTE, rhs), \"Expected lhs to be greater than or equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LTE, rhs), \"Expected lhs to not be less than or equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.GTE, rhs), \"Expected lhs to not be greater than or equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.GTE, rhs), \"Expected lhs to not be greater than or equal to rhs\");\n    }\n}\n"
     },
-    "254": {
+    "255": {
       "function_locations": [
         {
           "name": "encode_bytes_as_fields",
@@ -1536,7 +1536,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_as_fields.nr",
       "source": "use std::static_assert;\n\n/// Encodes an array of bytes as fields.\n///\n/// Use\n/// [`decode_bytes_from_fields`](crate::utils::conversion::bytes_as_fields::decode_bytes_from_fields) to recover\n/// the original bytes.\n///\n/// The `bytes` array length must be a multiple of 31. If padding is added, it will need to be manually removed\n/// after decoding.\n///\n/// ## Encoding\n///\n/// Each 31-byte chunk is interpreted as a big-endian integer and stored in a `Field`. For input `[1, 10, 3, ..., 0]`\n/// (31 bytes), the resulting `Field` is `1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0`.\npub fn encode_bytes_as_fields<let N: u32>(bytes: [u8; N]) -> [Field; N / 31] {\n    static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n    let mut fields = [0; N / 31];\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    fields\n}\n\n/// Decodes fields back into bytes.\n///\n/// Inverse of\n/// [`encode_bytes_as_fields`](crate::utils::conversion::bytes_as_fields::encode_bytes_as_fields).\n/// Each input `Field` must fit in 248 bits; `Field::to_be_bytes::<31>()` fails the proof otherwise.\npub fn decode_bytes_from_fields<let N: u32>(fields: BoundedVec<Field, N>) -> BoundedVec<u8, N * 31> {\n    let mut bytes = BoundedVec::new();\n    for i in 0..fields.len() {\n        let chunk: [u8; 31] = fields.get(i).to_be_bytes();\n        for j in 0..31 {\n            bytes.push(chunk[j]);\n        }\n    }\n    bytes\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{decode_bytes_from_fields, encode_bytes_as_fields};\n\n    #[test]\n    unconstrained fn round_trips_bytes(input: [u8; 93]) {\n        let fields = encode_bytes_as_fields(input);\n\n        // In production the fields fly through the system and arrive as a BoundedVec on the other end.\n        let fields_bvec = BoundedVec::<_, 6>::from_array(fields);\n        let bytes_back = decode_bytes_from_fields(fields_bvec);\n\n        assert_eq(bytes_back.len(), input.len());\n        assert_eq(subarray(bytes_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"N must be a multiple of 31\")]\n    unconstrained fn encode_rejects_length_not_multiple_of_31() {\n        let _fields = encode_bytes_as_fields([0; 32]);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 31 limbs\")]\n    unconstrained fn decode_rejects_oversized_field() {\n        // `Field::to_be_bytes::<31>()` fails the proof when a field has any bit above position 247 set.\n        let oversized: Field = (1 as Field) * 2.pow_32(249);\n        let input = BoundedVec::<_, 1>::from_array([oversized]);\n        let _bytes = decode_bytes_from_fields(input);\n    }\n}\n"
     },
-    "255": {
+    "256": {
       "function_locations": [
         {
           "name": "encode_fields_as_bytes",
@@ -1586,7 +1586,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_as_bytes.nr",
       "source": "/// Encodes an array of fields as bytes.\n///\n/// Losslessly preserves any field value; use\n/// [`try_decode_fields_from_bytes`](crate::utils::conversion::fields_as_bytes::try_decode_fields_from_bytes) to\n/// recover the original fields.\n///\n/// ## Encoding\n///\n/// Each field is written as 32 big-endian bytes and the chunks are concatenated. The field array `[5, 42]` becomes:\n///\n/// ```text\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,  // First field (32 bytes)\n///  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42] // Second field (32 bytes)\n/// ```\n///\n/// ## Privacy\n///\n/// The BN254 modulus is `< 2^254`, so every 32-byte chunk has its top bit at zero and the next bit biased. The output\n/// is therefore distinguishable from uniform random bytes; take this into account when feeding it into anything that\n/// assumes uniform randomness (e.g. ciphertexts meant to look random).\npub fn encode_fields_as_bytes<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n    for i in 0..N {\n        let chunk: [u8; 32] = fields[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[i * 32 + j] = chunk[j];\n        }\n    }\n    bytes\n}\n\n/// Decodes bytes back into fields.\n///\n/// Panics if the input length is not a multiple of 32 or if any chunk exceeds the BN254 field modulus. See\n/// [`try_decode_fields_from_bytes`](crate::utils::conversion::fields_as_bytes::try_decode_fields_from_bytes)\n/// for a non-panicking variant.\npub fn decode_fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> BoundedVec<Field, N / 32> {\n    assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n    try_decode_fields_from_bytes(bytes).expect(f\"Value does not fit in field\")\n}\n\n/// Decodes bytes back into fields, returning None on failure.\n///\n/// Inverse of\n/// [`encode_fields_as_bytes`](crate::utils::conversion::fields_as_bytes::encode_fields_as_bytes).\n/// Returns `Option::none()` if the input length is not a multiple of 32, or if any 32-byte chunk is `>=` the BN254\n/// field modulus.\npub fn try_decode_fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> Option<BoundedVec<Field, N / 32>> {\n    if bytes.len() % 32 == 0 {\n        let num_chunks = bytes.len() / 32;\n        let mut fields: BoundedVec<Field, N / 32> = BoundedVec::new();\n        for i in 0..num_chunks {\n            let maybe_field = try_decode_field_from_bytes(bytes, i * 32);\n            if maybe_field.is_some() {\n                fields.push(maybe_field.unwrap());\n            }\n        }\n        if fields.len() == num_chunks {\n            Option::some(fields)\n        } else {\n            Option::none()\n        }\n    } else {\n        Option::none()\n    }\n}\n\nfn try_decode_field_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>, offset: u32) -> Option<Field> {\n    // Field arithmetic silently wraps values >= the modulus, so we compare each chunk against the modulus\n    // byte-by-byte (big-endian) while building `field`. cmp: 0 = equal so far, 1 = less than modulus, 2 = exceeds.\n    let p = std::field::modulus_be_bytes();\n    let mut field = 0;\n    let mut cmp: u8 = 0;\n    for j in 0..32 {\n        let byte = bytes.get(offset + j);\n        field = field * 256 + byte as Field;\n        if cmp == 0 {\n            if byte < p[j] {\n                cmp = 1;\n            } else if byte > p[j] {\n                cmp = 2;\n            }\n        }\n    }\n\n    if cmp == 1 {\n        Option::some(field)\n    } else {\n        Option::none()\n    }\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{decode_fields_from_bytes, encode_fields_as_bytes, try_decode_fields_from_bytes};\n\n    #[test]\n    unconstrained fn round_trips_fields(input: [Field; 3]) {\n        let bytes = encode_fields_as_bytes(input);\n\n        // In production the bytes fly through the system and arrive as a BoundedVec on the other end. 113 is an\n        // arbitrary max length larger than the input length of 96.\n        let bytes_bvec = BoundedVec::<_, 113>::from_array(bytes);\n        let fields_back = try_decode_fields_from_bytes(bytes_bvec).unwrap();\n\n        assert_eq(fields_back.len(), input.len());\n        assert_eq(subarray(fields_back.storage(), 0), input);\n    }\n\n    #[test]\n    unconstrained fn try_decode_returns_none_on_length_not_multiple_of_32() {\n        let input = BoundedVec::<_, 64>::from_parts([0 as u8; 64], 33);\n        assert(try_decode_fields_from_bytes(input).is_none());\n    }\n\n    #[test]\n    unconstrained fn try_decode_accepts_max_field() {\n        // -1 in field arithmetic wraps to `modulus - 1`, the largest valid field value.\n        let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n        let fields = try_decode_fields_from_bytes(input).unwrap();\n\n        assert_eq(fields.get(0), -1);\n    }\n\n    // Verifies the overflow check: take the max allowed value, bump a random byte, feed it in.\n    #[test]\n    unconstrained fn try_decode_returns_none_on_chunk_above_modulus(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump as u32];\n\n        // Skip if the selected byte is already 255. Acceptable under fuzz testing.\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n            assert(try_decode_fields_from_bytes(input).is_none());\n        }\n    }\n\n    #[test]\n    unconstrained fn try_decode_returns_none_on_chunk_equal_to_modulus() {\n        // The field modulus itself is not a valid field value (it wraps to 0).\n        let p: [u8; 32] = std::field::modulus_be_bytes().as_array();\n        let input = BoundedVec::<u8, 32>::from_array(p);\n        assert(try_decode_fields_from_bytes(input).is_none());\n    }\n\n    #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n    unconstrained fn decode_asserts_length_multiple_of_32() {\n        let input = BoundedVec::<_, 143>::from_array([\n            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,\n            30, 31, 32, 33,\n        ]);\n        let _fields = decode_fields_from_bytes(input);\n    }\n\n    #[test(should_fail_with = \"Value does not fit in field\")]\n    unconstrained fn decode_panics_on_chunk_above_modulus(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump as u32];\n\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n            let _fields = decode_fields_from_bytes(input);\n        }\n    }\n}\n"
     },
-    "258": {
+    "259": {
       "function_locations": [
         {
           "name": "get_sign_of_point",
@@ -1636,7 +1636,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use crate::protocol::{point::Point, utils::field::sqrt};\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field = 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Returns: true if p.y <= MOD_DIV_2, else false.\npub fn get_sign_of_point(p: Point) -> bool {\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get the\n    // sign we check if the y coordinate is less or equal than the field's modulus minus 1 divided by 2. Ideally we'd\n    // do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is equivalent,\n    // and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\n/// Returns a `Point` in the Grumpkin curve given its x coordinate.\n///\n/// Because not all values in the field are valid x coordinates of points in the curve (i.e. there is no corresponding\n/// y value in the field that satisfies the curve equation), it may not be possible to reconstruct a `Point`.\n/// `Option::none()` is returned in such cases.\npub fn point_from_x_coord(x: Field) -> Option<Point> {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    sqrt(rhs).map(|y| Point { x, y, is_infinite: false })\n}\n\n/// Returns a `Point` in the Grumpkin curve given its x coordinate and sign for the y coordinate.\n///\n/// Because not all values in the field are valid x coordinates of points in the curve (i.e. there is no corresponding\n/// y value in the field that satisfies the curve equation), it may not be possible to reconstruct a `Point`.\n/// `Option::none()` is returned in such cases.\n///\n/// @param x - The x coordinate of the point @param sign - The \"sign\" of the y coordinate - determines whether y <=\n/// (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Option<Point> {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n\n    sqrt(rhs).map(|y| {\n        // If there is a square root, we need to ensure it has the correct \"sign\"\n        let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n        let final_y = if y_is_positive == sign { y } else { -y };\n        Point { x, y: final_y, is_infinite: false }\n    })\n}\n\nmod test {\n    use crate::protocol::point::Point;\n    use crate::utils::point::{\n        BN254_FR_MODULUS_DIV_2, get_sign_of_point, point_from_x_coord, point_from_x_coord_and_sign,\n    };\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign() {\n        // Test positive y coordinate\n        let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n        let sign = true;\n        let p = point_from_x_coord_and_sign(x, sign).unwrap();\n\n        assert_eq(p.x, x);\n        assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n        assert_eq(p.is_infinite, false);\n\n        // Test negative y coordinate\n        let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n        let sign2 = false;\n        let p2 = point_from_x_coord_and_sign(x2, sign2).unwrap();\n\n        assert_eq(p2.x, x2);\n        assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n        assert_eq(p2.is_infinite, false);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_valid() {\n        // x = 8 is a known quadratic residue - should give a valid point\n        let result = point_from_x_coord(Field::from(8));\n        assert(result.is_some());\n\n        let point = result.unwrap();\n        assert_eq(point.x, Field::from(8));\n        // Check curve equation y^2 = x^3 - 17\n        assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_invalid() {\n        // x = 3 is a non-residue for this curve - should give None\n        let x = Field::from(3);\n        let maybe_point = point_from_x_coord(x);\n        assert(maybe_point.is_none());\n    }\n\n    #[test]\n    unconstrained fn test_both_roots_satisfy_curve() {\n        // Derive a point from x = 8 (known to be valid from test_point_from_x_coord_valid)\n        let x: Field = 8;\n        let point = point_from_x_coord(x).unwrap();\n\n        // Check y satisfies curve equation\n        assert_eq(point.y * point.y, x * x * x - 17);\n\n        // Check -y also satisfies curve equation\n        let neg_y = 0 - point.y;\n        assert_eq(neg_y * neg_y, x * x * x - 17);\n\n        // Verify they are different (unless y = 0)\n        assert(point.y != neg_y);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign_invalid() {\n        // x = 3 has no valid point on the curve (from test_point_from_x_coord_invalid)\n        let x = Field::from(3);\n        let result_positive = point_from_x_coord_and_sign(x, true);\n        let result_negative = point_from_x_coord_and_sign(x, false);\n\n        assert(result_positive.is_none());\n        assert(result_negative.is_none());\n    }\n\n    #[test]\n    unconstrained fn test_get_sign_of_point() {\n        // Derive a point from x = 8, then test both possible y values\n        let point = point_from_x_coord(8).unwrap();\n        let neg_point = Point { x: point.x, y: 0 - point.y, is_infinite: false };\n\n        // One should be \"positive\" (y <= MOD_DIV_2) and one \"negative\"\n        let sign1 = get_sign_of_point(point);\n        let sign2 = get_sign_of_point(neg_point);\n        assert(sign1 != sign2);\n\n        // y = 0 should return true (0 <= MOD_DIV_2)\n        let zero_y_point = Point { x: 0, y: 0, is_infinite: false };\n        assert(get_sign_of_point(zero_y_point) == true);\n\n        // y = MOD_DIV_2 should return true (exactly at boundary)\n        let boundary_point = Point { x: 0, y: BN254_FR_MODULUS_DIV_2, is_infinite: false };\n        assert(get_sign_of_point(boundary_point) == true);\n\n        // y = MOD_DIV_2 + 1 should return false (just over boundary)\n        let over_boundary_point = Point { x: 0, y: BN254_FR_MODULUS_DIV_2 + 1, is_infinite: false };\n        assert(get_sign_of_point(over_boundary_point) == false);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_zero() {\n        // x = 0: y^2 = 0^3 - 17 = -17, which is not a quadratic residue in BN254 scalar field\n        let result = point_from_x_coord(0);\n        assert(result.is_none());\n    }\n\n    #[test]\n    unconstrained fn test_bn254_fr_modulus_div_2() {\n        // Verify that BN254_FR_MODULUS_DIV_2 == (p - 1) / 2 This means: 2 * BN254_FR_MODULUS_DIV_2 + 1 == p == 0 (in\n        // the field)\n        assert_eq(2 * BN254_FR_MODULUS_DIV_2 + 1, 0);\n    }\n\n}\n"
     },
-    "268": {
+    "269": {
       "function_locations": [
         {
           "name": "Poseidon2::hash",
@@ -1678,7 +1678,7 @@
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon2.nr",
       "source": "use std::default::Default;\nuse std::hash::Hasher;\n\nglobal RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        self.state[0] += self.cache[0];\n        self.state[1] += self.cache[1];\n        self.state[2] += self.cache[2];\n        self.state = crate::poseidon2_permutation(self.state);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut state = [0; 4];\n        state[RATE] = iv;\n\n        if std::runtime::is_unconstrained() {\n            for i in 0..(in_len / RATE) {\n                state[0] += input[i * RATE];\n                state[1] += input[i * RATE + 1];\n                state[2] += input[i * RATE + 2];\n                state = crate::poseidon2_permutation(state);\n            }\n\n            // handle remaining elements after last full RATE-sized chunk\n            let num_extra_fields = in_len % RATE;\n            if num_extra_fields != 0 {\n                let remainder_start = in_len - num_extra_fields;\n                state[0] += input[remainder_start];\n                if num_extra_fields > 1 {\n                    state[1] += input[remainder_start + 1];\n                }\n            }\n        } else {\n            let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n            states[0] = state;\n\n            // process all full RATE-sized chunks, storing state after each permutation\n            for chunk_idx in 0..(N / RATE) {\n                for i in 0..RATE {\n                    state[i] += input[chunk_idx * RATE + i];\n                }\n                state = crate::poseidon2_permutation(state);\n                states[chunk_idx + 1] = state;\n            }\n\n            // get state at the last full block before in_len\n            let first_partially_filled_chunk = in_len / RATE;\n            state = states[first_partially_filled_chunk];\n\n            // handle remaining elements after last full RATE-sized chunk\n            let remainder_start = (in_len / RATE) * RATE;\n            for j in 0..RATE {\n                let idx = remainder_start + j;\n                if idx < in_len {\n                    state[j] += input[idx];\n                }\n            }\n        }\n\n        // always run final permutation unless we just completed a full chunk\n        // still need to permute once if in_len is 0\n        if (in_len == 0) | (in_len % RATE != 0) {\n            state = crate::poseidon2_permutation(state);\n        };\n\n        state[0]\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: @[] }\n    }\n}\n"
     },
-    "357": {
+    "358": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -1800,7 +1800,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"
     },
-    "359": {
+    "360": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -1874,7 +1874,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_utl_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
-    "378": {
+    "379": {
       "function_locations": [
         {
           "name": "Poseidon2Sponge::hash",
@@ -1904,7 +1904,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\nuse crate::traits::{Deserialize, Serialize};\nuse std::meta::derive;\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n// TODO: Poseidon is stand-alone now\n\nglobal RATE: u32 = 3;\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        sponge.squeeze()\n    }\n}\n"
     },
-    "397": {
+    "398": {
       "function_locations": [
         {
           "name": "<impl ToField for Field>::to_field",
@@ -1942,7 +1942,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits/to_field.nr",
       "source": "use crate::utils::field::field_from_bytes;\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u16 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u128 {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    #[inline_always]\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n"
     },
-    "405": {
+    "406": {
       "function_locations": [
         {
           "name": "field_from_bytes",
@@ -2154,7 +2154,7 @@
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n"
     },
-    "411": {
+    "412": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -2204,7 +2204,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"
     },
-    "412": {
+    "413": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -2230,7 +2230,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"
     },
-    "414": {
+    "415": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -2544,7 +2544,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"
     },
-    "415": {
+    "416": {
       "function_locations": [
         {
           "name": "Writer<N>::new",
@@ -3596,7 +3596,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "tZfRbtswDEX/xc95ECWKkvorQ1GkqVsEMJLATQYMRf59ZKLr2ANsFN72El9f20ekRMrxV/PWvl4+XvaH9+Nn8/Tjq3nt9123/3jpjrvteX88qPvVOPsh0kPY6DE2T0mPXs/JmVCDSEVwELkKDirYhDlRRTRHTJiTVYg63sCijrebs6iwmwvdhXd2SZ/y3i7p6J5ZRTZRqhC7VFRkhihVFDilOsExBByCQ3A8HA8nwAlwGA7DsQTvIlchcAROgpNSFZkgahahOIgIUYdgBM+uApkCRAWy9xAVyIEgKpDZQQCILBhZMLJgAVAwRAIwYYgMYMYQWALGEnCpwOgCRAVG8hAVGD1BKDBoRUWrsbuAw3Csxm7Cgr+LVIUFfxdwLPibsGq5i1JFgVOqIy5A1MeFCEKq8HA8HIQqCFVugXkVyeLRmk9Bbyat52RLQOl63TRovZdz37bWeaNe1A49bfv2cG6eDpeu2zQ/t93ldtPnaXu4Hc/bXq9qX7aHNz0q8H3ftaaum8fTbv5RH1ysT/vg4wAgyhMELSAcRw+GY5EBkqZh+AVGyiAUfgSR4rfzkCwgpJxn8+B5hLY3piKwPKYi8YQQ/8FMyH+ciaD7zJCG49mZyAsIcowoVEuZy6PMM8gNC6Ivk/L3mchsJgsI8kMi5FMYEHGaBy2VpggXLImI5LnJoDAPEQ+ERLdmLiaJZJ5LZIkQhhgocFhD8PbmroSYZyczLSxp4UoYl6aP4dsEfdeB4PM8YaEyUyxUEUlo3GPT3WqpMploqEwaFbdMEQu7ZnAOkxmc51nEQmVqXyUe9ViaS2VxPnlYkeRWrUh0aPQYwjpCwhssFllFGPfXOkJyiCH5lYSEykylrCLkgCyyzMcQll6DbtiqRpXN/vtJBGwzaeVE6g6Jpch/tPiznm53+37ywXE1VL/fvnZtPX2/HHajq+dfJ1zBB8upP+7at0vfGunx1aJ/uH5Q5A0JP9u3y+2UNvoZ8ny10X8D",
+      "debug_symbols": "tZfRbtswDEX/xc95ECmKkvorQ1GkqVsEMJLATQYMRf59VKLr2ANsFN72El9f20ekRMrxV/PWvl4+XvaH9+Nn8/Tjq3nt9123/3jpjrvteX88mPvVuPJDZAe/sWNonqId2c7JFWEGkQnvIFIV4k1IEcUJJkJxtIjiJBNqDhewmsPl5qQmys2Z7oJduWRPMZdLNjqLmEhF5Cq0XMomkkDkKjKcXB3vBAIOwSE4DIfheDgejsAROCXBu0hVKByFE+HEWEUiiJqFzw4iQNQhBMGLq0AhD1GBwgxRgeIJogJFHASAyEKQhSALUQAVQ0QAI4ZIACYMgSUQLIHkCgzOQ1RgIIaowMAEYUBvFRVKjd0FHIFTauwmSvB3Easowd8FnBL8TZRquYtcRYaTq6POQ9THlQhCq2A4DAehKkLVW2BsIpZ4rOajt5vJ6jmWJaB4vW4atN7LuW/b0nmjXrQOPW379nBung6Xrts0P7fd5XbT52l7uB3P296uWl+2hzc7GvB937VFXTePp938o+xdqE+z5zAAiNIEQQsIJ4HBcKI6QOI0DF5gxARClkcQUb+dhyYFIaY0m4fMI6y9MRVe9DEVUSaE8A9mQv/jTHjbZ4Y0nMzORFpAkBNEYVrzXB55nkFuWBB7meS/z0RnM1lAEA+JEEc/IMI0D1oqTVXJWBJVTXOTQX4eogyEBrdmLiaJJJlLZInghxjIi19D4PLmroSQZiczLixplkoYlyYH+TbB3nUgcJonLFRmDJkqIiqNe2y6Wy1VphANlUmj4p6uJy/smt45TKZ3LLOIhcq0vooy6rE4l8rifMqwItGtWpHg0OjB+3WEiDdYyLqKMO6vdYToEEPklYSIyow5ryIkjyySzsfgl16DbtiqRpUt/P0kPLaZuHIibYfEUqQ/WvzZTre7fT/54LgWVL/fvnZtPX2/HHajq+dfJ1zBB8upP+7at0vfFtLjq8X+cP2gIBtSeS7fLrdT2thnyPO1jP4b",
       "is_unconstrained": true,
       "name": "check_block_number"
     },
@@ -3644,7 +3644,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "tZfRbtswDEX/xc95ECWKlPorQ1GkqVsEMJLATQYMRf59VKLr2ANsFN7Wh/r62joiJdKOv5q39vXy8bI/vB8/m6cfX81rv++6/cdLd9xtz/vjwdyvxpV/RHYIGzvG5knt6O2cXBFmEJkIDiJVwcEEF1GcaCIWR4ooTjIh5vgCFnN8uTmJiXJzprvwrlyyUd6XSza7ZzaRishVSLmUTSSGyFVkOLk6wTEEHIJDcDwcDyfACXAYDsMpCd5FqkLgCByFo1pFIoiaRcgOIkLUKRjBs6tApgBRgew9RAVyIIgKZHYQACILRhaMLFgAFEyhACqmSAAmTIEtYGwB5wqMLkBUYCQPUYHRE4QBg1VULDV2F3AYTqmxmyjB34VWUYK/Czgl+Jso1XIXuYoMJ1dHXICow4UIQqrwcDwchCoIVW6BeRNa4rGa12A3k9Wzli0gvV43DVrv5dy3bem8US9ah562fXs4N0+HS9dtmp/b7nK76fO0PdyO521vV60v28ObHQ34vu/aoq6bx2g3P9QHF+toH3wcAERpgqAFhOPowXAsMkB0GoZfYGgCIfMjCI3fzkOSgKApzebB8whrbyxFYHkshfKEEP/BSsh/XIlgz5khDcezK5EWEOQYUZiWPJdHnmeQGzbEXib57zOR2UwWEJpzJSRPAyBOs6DFwlShobDsb24pKMxDZIhCSdesxCiN4OfSWBifIrYz6arxCfNnn2eXURe2MnMFjEvSx/Btgr3jQPBpnrBQkRozdtL2dNxb06fUUkUy0VCRNCpqmSIWnpbBuQCE8zyLWKhJ6yflUW/pXCqL68nDjqhbtSPRocFjCOsIijdXzLKKIB6FKXEdQR1iUL+SoKhMa9NVhBSG9pb5GMLS68+B4EeVzf77SQQ8IXTlQoqAIOmPFn+20+1u308+NK4F1e+3r11bT98vh93o6vnXCVfwoXLqj7v27dK3hfT4WrEfWj8o8oaEn8s3SzmVaKf6fC2z/wY=",
+      "debug_symbols": "tZfRbtswDEX/Jc95ECmKlPorQ1GkqVsECJIgTQYMRf59VKLrOANsFN7Wh/r62joiJdKOvxZv3ev542Wze99/Lp5+fC1ej5vtdvPxst2vV6fNfufu1yLUf0R+iEs/psWT+ZH9nEIVbhC5iAEiNyHRhVRRneQiVUerqE52oe5wBas7XG/O6qLeXOgmONRLPoq5XvLZWcRFrqI0ofVScZEFojRR4JTmxCAQcAgOwWE4DCfCiXAEjsCpCd5EbkLhKByDY9ZEJoiWRSwBIkG0KQTBS2hAoQjRgMIM0YASCaIBRQIEgMhCkIUgC1EAFVMYgIYpMoAZU2ALBFsgpQFTiBANmIghGjAxQTgwekWlWmM3AUfg1Bq7ihr8TVgTNfibgFODv4paLTdRmihwSnM0RIg2XIkgtAmGw3AQqiJUvQbGLqzG4zVv0W8mr2erW0B2uSwXaL2X07HraucNetE79LA6drvT4ml33m6Xi5+r7fl60+dhtbseT6ujX/W+7HZvfnTg+2bbVXVZ3keH8aEcQ2qjOXLqAUT5AUETiCCJwQii2kPsMQyeYFgGocg9CNNv56FZQbCcR/OQcYS3N5Yiit6XwuSBkP7BSuh/XInoz5k+jSCjK5EnEBQEUbjWMpZHGWdQ6DfEXybl7zPR0UwmEFZKI2SmHpAes6DJwjSlvrD8b2wpKI5DtI/CyOasxCCNyGNpTIzPCduZbdb4jPkLl9FltImtLNIAw5LkJN8m+DsOBM7jhImKtFSwk76nw956fEpNVaQQ9RVJg6J+3EmeeFrGECIQgWUUMVGT3k8mg96ysVQm11P6HbEwa0dSQIOnGOcRDG+uVHQWQRmFqWkewQJiMJ5JMFSmt+ksQo59e+t4DHHq9RdA4EFlC38/iYgnhM1cSFUQNP/R4s9+ulpvjg8fGpeKOm5Wr9uunb6fd+vB1dOvA67gQ+Vw3K+7t/Oxq6T714r/0PpBSZak8ly/WeqpJj+150ud/Tc=",
       "is_unconstrained": true,
       "name": "check_timestamp"
     },
@@ -3778,11 +3778,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "tZndbhs5DEbfxde5EKkfinmVoCjc1C0MGE7gJgssgrz7khl9st2FBNdOb6KTxHNMcShK9rytvm++vf78ut3/ePq1un94W307bHe77c+vu6fH9cv2aW9/fVsF/1G4ru7jnY26ui82xtBGaiO3MbYxtTG3sbRR2ljb2Hyp+VLzpebL9jqxsdjf1Uduo/mJHDLA3oE8xCKACtAGEgAEYEAEJEAGwCwwC8wCc4W5wlxhrjBXmCvMFeYKc4W5wqwwK8wKs8KsMGszS/CrsgMBGOCvKQ4FIAB7dw4O2oACgAAMiAB7d/bLKQMKQABuFgdtwAHgZnUwc/TgOQISIAMKQAAVoA28NhcgAMwR5gizF2j0tHiFLiAAN3uEXqQf4FW6gF/uMSd7cSIHe3FyYdIGOQAsjJQcGBABCZABBSAAN3s8WRuUACCAmz2wEgEJ4ObqUAACqABt4AtkAQK42WfqC2SBBMgAM2dPgi+QBSrAzJkNfIEsQAAGREACZICbPYe+QBaoAG3gCyR7onyBZC82XyALRICbPRu+QBYoAAFUgC5QfREt4ObqwIAISADvdMGhAATgzY4ctIEvq8IOBGBABHgLLQ5u9rfwZbWAACpAG/iyWoAAblaHCDCzeBi+rBYoADOLv7svqwW0gS+rBQjAgAhwc3TIgAIQgJuTgzbwZbUAAfyq7CCACvCrfF6+vhYggMfjE/T1tUACZEABCKACzFz9fvn6WoAADHBzeX+/W2GT/Ppy2Gx8jzzZNW0vfV4fNvuX1f3+dbe7W/2z3r1+vOjX83r/Mb6sD/ZfU27232004Y/tbuP0fne8OowvpWCbbrvcuGhXUOAzCY0lyZvzhyIl6QI5v57H18eMGUSpxwAq/cEstPZZWPsaziKNJTlXbY5cQjkqcj5T5LGCCyOZbIePrigXx2DHhB6D8jCGicIOU7Ep7JwUhoo6Vtie3gxyKhC9eBrSY8i26w5joMk9jUy4HZFjHuRybtBeVzHUkWFSmIkYhkRRr7iftp0gEda3x4mYONTPWx8K5eMkEl0cg/ZJZNVwVU2FAEUJNFaQTNaoFlQVqaRjLs8nQpO6JKHeq+yUMFToLJkIQutJq7G2c7FBU+80lIcKnvRL5gQHcx7eU+ZZx+Nj2840DiNOCqN2R7Zt6ySMdO6YV4b2yuAwdsy6Zsq9acqJ4crC0HFhyOyeROr3JMWRgidRlJx7LrKmq6KgIojC+vhIESddL+W+Gcu4LuJsO6fCvevp6T0930vjrD5zvyE5nhjy5VFwr6zEIuMoJtVJXLEPUSQaxzFxRIl9H6qhjuMof9dBhVLPaSGJw7UWJzWqWZERPa3R/zmmkcRjD7TvWsarPs1253I89KXhnZkaUk/qWff6zTDb30NE60khyXgeEwdHzIMzXxUF197/ahnXqMyOjaF3ciuT8TzKJ+Si3JyLcnMuyu25yOH2XMwcl+Viarg5FxZ87fModNVqvzgX+e86Lsxnvjmf0z1J+zzipI9n/YQ9aVaf0j+ppjA+xc4OGrHimMB2S646qyTqp9h8cgT9TVHirWeVMtudg2K1WzLHe2LJs8+J5fhJs/KVjj4V09WxQ26t8Gk+L6qL2XGeMxpG4TL+vCqT4rQHHEiFPdmIgw/NU0NlnILtcYdeZZA+jypXfHC3R1T9LB/D+BPv9KxV+glWC5Xrzmunjjiub/mEHVHk9g4uN9f31DDu4F/s1/Xj9nD22PHdVYft+ttu03798bp/PPnvy7/P+A8eWz4fnh43318PGzcdn13aj4dq3ypX5S93K/v+9sHO4HeFxX7zr98fqhWMBvry7rH8Bw==",
+      "debug_symbols": "tZndTis7DEbfpde9iJ0fJ7wKQqhA2apUFdQNRzpCvPuxmXyZKUeJulv2DVlAZ9Xx2Emm/Vg9bR/ef93vDs8vv1c3tx+rh+Nuv9/9ut+/PG7edi8H/evHytmPxHl149c6ltVN0tG7OlIduY6+jqGOsY6pjlLHXMfqC9UXqi9UX9TXiY5J/15s5Dqqn8ggAvQdyEJMAsiAUkEcgAAM8IAAiACYBWaBWWDOMGeYM8wZ5gxzhjnDnGHOMGeYC8wF5gJzgbnAXKpZnF0VDQjAAHtNMkgAAei7szMoFcgBCMAAD9B3Z7ucIiABBGBmMSgV2AHMXAzU7C149oAAiIAEEEAGlApWmxMQAGYPs4fZCtRbWqxCJxCAmS1CK9IvsCqdwC63mIO+OJCBvjiYMJQK0QE0jBAMGOABARABCSAAM1s8sVRIDkAAM1tgyQMCwMzZIAEEkAGlgjXIBAQws83UGmSCAIgANUdLgjXIBBmg5sgK1iATEIABHhAAEWBmy6E1yAQZUCpYg0RLlDVItGKzBpnAA8xs2bAGmSABBJABZYJsTTSBmbMBAzwgAGylcwYJIABb7MigVLC2SmxAAAZ4gC2hycDM9hbWVhMIIANKBWurCQhg5mLgAWoWC8PaaoIEULPYu1tbTVAqWFtNQAAGeICZvUEEJIAAzBwMSgVrqwkIYFdFAwFkgF1l87L+moAAFo9N0PprggCIgAQQQAaoOdv9sv6agAAMMHP6/FyvsEnevx23W9sjF7um7qWvm+P28La6Obzv9+vVP5v9+9eLfr9uDl/j2+ao/1Xl9vCkowqfd/ut0ed6vtr1LyWni1i9XFmoKcjxiYT6kmCL85ciBGkCOb2e+9f7iBl4yXMAmc+fhXZZm0XOsTuL0JfExL46op4kZkVMJ4rYV3BirgrWw0dTpLNj0K0SMegu1Y1hoNBDk1SFziJ0Fbmv0D29GnQpX9wPd/40WgxRN5xuDDS4p56poCrYx04ux4bS6sq73DMMCjMQwxDIlwvupy6OSEQOvp+IgaMQFIXnSQQ6O4YS0eHJcbioppyfFaGvIBn0aEmoKioyO9LpRGhQlySE9iI9JXQVZZRMBFHyYqmRcr6hzOslxa6CB+slc4CDOXbvKfNoxWsrDblI/TD8sDi5FeeiS4NO68QxrAxX5uJyfcdo1QyxLZqyMPBlhVH6hSGje+Kp3ZNFp35T8CCKFGPLRSzhoigoYeHUeLpR+MGqF2LbjKVfF360nVPituqV5T31p45RfcZ2Q6JfGNL5UXCrrMAi/SgG1UmcsaWTJ+rHMXB48W0fyi7340h/10GJQstpIvHdXvODGi2xICNlWaP/cwwj8fMaqJ+19Ls+jHbnNB/6QvfODA2hJfVk9fpmGO3vzmPp0aOS9OcxcLDHPDjyRVFwbutfTv0aldHR1bWVXMukP4/0A7lIV+ciXZ2LdH0uors+FyPHebkYGq7OhQaf2zwSXdTtZ+ci/l3HmfmMV+dzuCeVNg8/WMdj+YE9aVSfgpUvLh9Uv59iRwcNn3FM4OVT4p+cVQK1U2xcHEG/KZK/9qySRruzK+h2TWZ/T0xx9JyY5ifNzBc62lRUl/sOubbCh/k8qy5Gx3lu6dQvZ/rPqzIoTv2CA6nQbzZ856F5aMjcPsLQT+ouMkhuBrngwV2/gvItEb7/xDs8a6V2gi2J0mXntaXD9+tbfmBHFLl+BZer63to6K/gd/rr5nF3PPna8dNUx93mYb+tvz6/Hx4X/3379xX/wdeWr8eXx+3T+3Frpvm7S/1xm/VT5Vz4br3Sz29v9Qy+Tiz6m338fptLWRdHd58Wy38=",
       "is_unconstrained": true,
       "name": "offchain_receive"
     },
@@ -3835,7 +3835,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "tZnbbhs7DEX/xc95kERSl/xKURRp6hYBjCRwkwMcFPn3kiNu2g4wg8BoXqIl2rMpUtRl4j+7H/vvr7++PTz+fPq9u/3yZ/f9+HA4PPz6dni6v3t5eHpU659dsj+Z8+423+yyJG9ld1u0rclb7zfvN/Z2zLZ7v3t/kLd9aUsq3rbZsuqwteztmK14X7xfvd/0+WZtm23X8XZr62yH94f2c7rZUcoAHXnWkCgngFlEoZhlGFh0OiwiC48MugNbINXALOqaxCzdoDvUAqgOS5oWYMBw6LB0PD78cU4JMLPNaWaTM3urj5AGxYUAzYEKABYbsIbL0mbbZEklt5la7uyt94f3x+xLmqmWXLydqZaSvfU+aZ+KQXWwySUyEIelrMRAZsplKSz78lJZ9p1GAItSUy7dojTXlioyX1ZWE9qEavM8QQDDwbI2AZZCADxOeIpnYVdmb2fqq3imq3juay0Az3RtsNiAyzDoDgOW4ZaWCABLhiXDUgqgORAsBAvDwtXBkjxBAMPBltEEuGhw2iDYIdghaItqggv2lAAMcBcdUXRE0RFFRxSdMsBddIYgwwVDUOBCIFjhokKwwUWDYIeLDsEBFwOCw10MzMXAXIxcAO5ilAxwF4MSQAAQZAZAUOBCIFjhokKwwUWDYIeLZZEmg+Ew3JKT7alODZRzUAWVsNk+N8n2t0m2wTmFTcImoVxDpYaKbXNOYeth6zFSDD6nEcoD3rJtw5wXMpVqZDnmZrSMqhsto1po8TuMbKGJqZSk8YqpFMvBpGKf2jFUbJFMkhwUthq2GrYWthY2i81JQCNsAzZKKYiDMBayleLUQLZWnOCNKAeFMocyh7KtmEkSyhLeaijX8BaxUcRGERtFbNRDeYS3AWVOFARlziUIylxyEJSZUhAHwRtzKHN4E1PmhRqohs0qwkmCBsgq0SlsVokLyVI5Cy2VMylsJWxFgqAiFCq2oiZx2DhsMXqJ0csyUjFaslvf3m52uJp9eznu93YzO7ur6Q3u+e64f3zZ3T6+Hg43u//uDq/Ll34/3z0u7cvdUT/V9bB//KGtCv58OOyN3m5OT6f1R5kb+dOsN4IQ0BX+YYncGyT0PniNRGHLyyKh6zWtStCWxCghQXSSaPLhUYyBXFCqZXUUsiGR7cY5R6HbUUjoje5Com7mAgq1nQnkq8ZAaXUMslUVHFPK0lclxieGcTGGCwn+6IRSrxUSenquTmguG3HoCwUC0feGk0bulxpbtZlYojgT1xoq7XKhZt4QaR0S5+v0XXlvhlI70qFifT2UjerUYwjpIK6ndLTLScntX2Sjf2Y2iFqLSBKvZqNsFZhdoiCiF6WxFkrJ6yJ6XcK0ZL0m/YNg6vrUbmi0MVyilxwK8i6QzQptNXYefc9oq9nYWPY1RtFyuyoXZ3FQWYtjS6B3CIwy1gQ2D0SJbSeP9dOsbGyfuuukOIuarCZiI5P634mozdrG6gZK+RN38YtB9PWTZGs+9DYPDb2c09qM0FZp1sojItExrZUmbZVmgUSVdFVpXkTS+Zri1FsFLil267+iPPV2hEEInZfW+8vW1umeIpv5FAaXD5/Mg+NgPj2vF7cPr7GCI4RLXxXgrW1CBjYr3bbOz5BLCdo6DOOmpXi2c9dLCd5a5+l05yy8KrFRlnpoND47QNpaKJuvATEfLV0zH/pSFTVFVwk07Hcy6jUC56vzKoGWMIJWrhNoqEk9gq4R6BQnV10fgdDnrcsWW0O7Lomn7b72dwv7q3bv7h+OFz9HvJnU8eHu+2Hv3Z+vj/dnn778/4xP8HPG8/Hpfv/j9bg3pdNvGvoW/oX0nYGkfbV/FVlXw9H70Nc38/4X",
+      "debug_symbols": "tZnbbhs7DEX/xc95kERSl/xKURRp6hYBjCRwkwMcFPn3kiNu2g4wg8BoXqIlOrMpUtRl7D+7H/vvr7++PTz+fPq9u/3yZ/f9+HA4PPz6dni6v3t5eHpU659dsj+Z8+423+yyJG9ld1u0rclb7zfvN/Z2zLZ7v3t/kLd9aUsq3rbZsuqwteztmK14X7xfvd/0+WZtm23X8XZr62yH94f2c7rZUcoAHXnWkCgngFlEoZhlGFh0OiwiC48MugNbINXALOqaxCzdoDvUAqgOS5oWYMBw6LB0PD78cU4JMLPNaWaTM3urj5AGxYUAzYEKABYbsIbL0mbbZEklt5la7uyt94f3x+xLmqmWXLydqZaSvfU+aZ+KQXWwySUyEIelrMRAZsplKSz756Wy7H8aASxKTbl0i9JcW6rIfFlZTWgTqs3zBAEMB8vaBFgKAfA44SmehV2ZvZ2pr+KZruK5r7UAPNO1wWIDLsOgOwxYhltaIgAsGZYMSymA5kCwECwMC1cHS/IEAQwHW0YT4KLBaYNgh2CHoC2qCS7YUwIwwF10RNERRUcUHVF0ygB30RmCDBcMQYELgWCFiwrBBhcNgh0uOgQHXAwIDncxMBcDczFyAbiLUTLAXQxKAAFAkBkAQYELgWCFiwrBBhcNgh0ulkWaDIbDcEtOtqc6NVDOQRVUwmb73CTb3ybZBucUNgmbhHINlRoqts05ha2HrcdIMficRigPeMu2DXNeyFSqkeWYm9Eyqm60jGqhxe8wsoUmplKSxiumUiwHk4p9asdQsUUySXJQ2GrYatha2FrYLDYnAY2wDdgopSAOwljIVopTA9lacYI3ohwUyhzKHMq2YiZJKEt4q6Fcw1vERhEbRWwUsVEP5RHeBpQ5URCUOZcgKHPJQVBmSkEcBG/MoczhTUyZF2qgGjarCCcJGiCrRKewWSUuJEvlLLRUzqSwlbAVCYKKUKjYiprEYeOwxeglRi/LSMVoyW59e7vZ4Wr27eW439vN7Oyupje457vj/vFld/v4ejjc7P67O7wu//T7+e5xaV/ujvqprof94w9tVfDnw2Fv9HZzejqtP8rcyJ9mvRGEgK7wD0vk3iCh98FrJApbXhYJXa9pVYK2JEYJCaKTRKsfHsUYyAWlWlZHIRsS2W6ccxS6HYUEZ7mQqJu5gEJtZwLlqjFQWh2DbFUFx5Sy9FWJ8YlhXIzhQkI+OqHUa4WEnp6rE5rLRhz6QoFA9L3hpJH7pcZWbSaWKM7EtYZKu1yomTdEWofE+Tp9V96bodSOdKhYXw9lozr1GEI6iOspHY0vJdq/yEb/zGwQtRaRJF7NRtkqMLtEQUQvSmMtlJLXRfS6hGnJek36B8HU9and0GhjuEQvORTkXSCbFdpq7Dz6ntFWs7Gx7GuMouV2VS7O4qCyFseWQO8QGGWsCWweiBLbTh7rp1nZ2D5110lxFjVZTcRGJvXbiajN2sbqBkr5E3fxi0H09ZNkaz70Ng8NvZzT2ozQVmnWyiMi0TGtlSZtlWaBRJV0VWleRNL5muLUWwUuKXbrv6I89XaEQQidl9b7y9bW6Z4im/kUBpcPn8yD42A+Pa/fBn54jRUcIVz6qgBvbRMysFnptnV+hlxK0NZhGDctxbOd+7IimLfWeTrdOQuvSmyUpR4ajc8OkLYWyuZrQMxHS9fMh75URU3RVQIN+52Meo3A+eq8SqAljKCV6wQaalKPoGsEOsXJVddHIPR567LF1tCuS+Jpu6/93cL+qt27+4fjxc8RbyZ1fLj7fth79+fr4/3Zpy//P+MT/JzxfHy63/94Pe5N6fSbhr6FfyF9ZyBpX+2rIutqOHof+vpm3v8C",
       "is_unconstrained": true,
       "name": "public_dispatch"
     },
@@ -3964,17 +3964,17 @@
         ],
         "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": "vb3bjuzKcXb7LutaF5VxyINf5ccPQ7ZlQ4AgGbK8gQ3D774rg2SOmHOistldvfaN17DdMwYryfh4SpL/89u//elf/vs//vnPf/33v/3Xb//0f/7nt3/5+5//8pc//8c//+Vv//rHf/z5b399/l//57fH/B+j//ZP+offxvjtn/wPv5XH4/xvOf8r53/1/K+d//Xzv/X8bzv/28//nvXKWa+c9cpZr5z1ylmvnPXKWa+c9cpZr5z15KwnZz0568lZT856ctaTs56c9eSsJ2c9PevpWU/PenrW07OenvX0rKdnPT3r6VnPznp21rOznp317KxnZz0769lZz856dtbzs56f9fys52c9P+v5Wc/Pen7W87Oen/XqWa+e9epZr5716lmvnvXqWa+e9epZr5712lmvnfXaWa+d9dpZr5312lmvnfXaWa+d9fpZr5/1+lmvn/X6Wa+f9fpZr5/1+lmvn/XGs16b/y3nf+X8r57/fdYrZYJfUC94liw64Vmz1D/8JrMZSpvw/GN5THj+sciE5x+LT+gXjBNmCxxQLpALnkuhZYJd4BfUC56VdSpmKxwwTpgbveqE+cez4NzMdS7h3M61TxgnzC39gHLBczFsKuZGbLPg3Gpt1pmbq82fHNvn/KWxgQb0C8YJsY0GlAvmWpv/PDbTALvAL5iV56LGphowK88Fi411QmytAeUCuUAvsAueleu0z232gHZBv2CcMLfbA8oFcoFeYBdcldtVuV2V21W5XZX7VblflftVuV+V+1W5X5X7VblflftVuV+Vx1V5XJXHVXlclcdVeVyVx1V5XJXHVXmclfXxuKBcIBfoBXaBX1AvaBf0C67K5apcrsrlqlyuyuWqXK7K5apcrsrlqlyuynJVlquyXJXlqixXZbkqy1VZrspyVZarsl6V9aqsV2W9KutVWa/KelXWq7JelfWqPPcO1SaUC+SCWblPsAv8gnpBu6Bf8Kzc5j+fPXhAuUAumFHnE+wCv2D+82cz6myrNgvOtupzUWdbdZnw/OM+/3i21QHtgn7BOGG21QHPxRhlglygF9gFz8pjKmZbHdAueFYeOmGcMNvqgHLBrDwXfjbRaBNmUD/m0s+eOWg2zUll0qw+2+Z5JDNpxv9jLnDk/0F1UVsUladjjJPs8VhUFskiXRS7GJnki2Ino5NmvblTsdkqJ5VFskgX2SJfVBe1RX3RcshyyHJIOMYkXTQdcw9ns3NOqhfNvngegU2Kv5u/SH1RXdQWzWWR+XtnLxw0m+Gksmguy9w12uyHk2yRLwrHXHpri/qicZE/FpVF4eiTdJEt8kVrTH2Nqa8x9TWmdY1pXWNa13qra73Vtd7qWm91Oepy1OWo8Tvm+miPRWWRLFrrrdkiX1QXtUV90bjWan8sKov8WtPRW7Euo7eCorcOKovkWpdDF9kiX1SvdRlddlBfNE7yx7UG/VEWyaJrDfrDFvmielH0jD5/kUcHzIMmjw44SBbpIlvki2Y9tUltUV80LtJw1EllkSwKx1z66J6DfFFd1Bb1ReOi6J55GOfRPQfJIl0UledIRgfEGMT2HL8otueDxkV1jVBdI1TXCMX2HL8ytueDfNEaodie4/fG9nzQuCi25/gdsT0fJIvWCLU1Qm2NUFsjFNtz/MrYng8aF/U1Ql2uMYit2OYYxFYcFFvxQWWRLNJFtsgX1UVt0XKMy1Efj0VlkSzSRbbIF9VFbVFftBxlOcpylOUoyxEdMA/3a3TAQbIo/q5NskW+qC5qi/qiuSz+3EpqdMBBZZEsmg63SbbIF02H+6S2qC8Kx7RFB8wj/xodMA+wanTAQbrIFvmiumg6apnUF42LYv9xUFkki3SRLfJFddFy+HL4ctTliH6rc4Si3w7SReGYIxT9dlBd1Bb1ReOi6LeDot4cyeitg3xR1KuT2qK+aFwUvXVQWSSLdJEt8kXL0ZejL0dfjrEcYznGcozlGMsxlmMsx1iOsRzjcrTHY1FZJIt0kS3yRXVRW9QXLUdZjrIcZTnKcpTlKMtRlqMsR1mOshyyHLIcshyyHLIcshyyHLIcshyyHLocuhy6HLocuhy6HLocuhy6HLocthy2HLYcthy2HLYcthy2HLYcthy+HL4cvhy+HL4cvhy+HL4cvhy+HHU56nLU5ajLUZejLkddjrocdTnqcrTlaMvRlqMtR1uOthyrz9vq87b6vK0+b6vP2+rztvq8rT5vq8/b6vO2+rytPm+rz9vq87b6vK0+b6vP2+rztvq8rT5vq8/b6vO2+rytPu+rz/vq8776vK8+76vP++rzvvq8rz7vq8/70efPI+l+9HlQWRSVbZIt8kWzciuT2qK+aFwU3X1QWSSLdJEt8kXLIcshyyHLocuhy6HLocuhy6HLocuhy6HLocthy2HLYcthy2HLYcthy2HLYcthy+HL4cvhy+HL4cvhy+HL4cvhy+HLUZejLkddjrocdTnqctTlqMtRl6MuR1uOthxtOdpytOVoy9GWoy1HW462HH05+nL05ejL0ZejL0dfjr4cfTn6cozlGMsxlmMsx1iOsRxjOcZyjOUYl2M8HovKIlmki2yRL6qL2qK+aDnKcpTlKMtRlqMsR1mO1edj9flYfT5Wn4/V52P1+Vh9Plafj9XnY/X5WH0+Vp+P1edj9flYfT5Wn4/V52P1+Vh9Plafj9XnY/X5WH0+Vp+P1efj6HOfJIt0UTjaJF9UF4VjTOqLxkXR5306os8PCkefpIts0XT0ea8z+vygtmg6uk0aF0WfH1QWySJdZIt8UTjmr4w+P6gvGhdFn/f5e6PPD5JFusgWhUMm1UVt0XSMx6RxUfT5QWWRLNJFtsgX1UVt0XL05RjLMZZjLMdYjrEcYznGcozlGMsRfT6vCj8v4z7AAgoYNTUwCsS96OjiA6ONTyxgVKiBChroYBRrcW881lMPVNBAByvYwFjIA8fC6NETCyigggY6WMEGYotmHSPu6M+7kfMK+RMVNNDBCjawg2Ph7NALCxi2WFmuoIEOVrCBHRwL6wMsILaKrWKr2Cq2iq1iq9gatoatYWvYGraGrWFr2Bq2hq1j69g6to6tY+vYOraOrWPr2Aa2gW1gG9gGtoFtYBvYBraxbDHh5MICCqiggQ5WsIEdxFawFWwFW8FWsBVsBVvBVrAVbIJNsAk2wSbYBJtgE2yCTbApNsWm2BSbYlNsik2xKTbFZtgMm2EzbIbNsBk2w2bYDJtjc2xkSSFLCllSyJJClhSypJAlhSwpZEkhSwpZUsiSQpYUsqSQJYUsKWRJIUsKWVLIkkKWFLKkkCWFLClkSSFLCllSjiyZu69yZMmBBZy2cky4mrZ5+6nEZJsLHaxgAzs4FkaWnFhAAbENbAPbwDawjWWTSI3SA2eFeReqHDN0TqxgAzs4FkY+SBSLfDhRQAXDNgIdrOC0zRsuJebuXDgWRj7MST5PLKCACk6bxkJGEsybMSWm+Vw4FkYSnBh1jxlyUbcGRt0YvkiCEx2sYNjiF0cSnDgWRhKcOG0Wvy3a32J5o/0tFifa346JelPhx982sINjYbT/iQUUcNo8Bira/8S+No3o7gOju09k24nuPlFBAx2sYAOxVWzR3R4/Prr7RAEVNNDBCjawg2Nhx9axdWwdW8d2dPeBFWxg2CxwLIzuPjFssXFFd5+ooIEOVrCBHRwXxiSlCwsooIIGOljBBnYQW8FWsBVsBVvBVrAVbAVbwVawCTbBJtgEm2ATbIJNsAk2wRb5MO+hlZjidGHscXqgX2cHepxJHNjADq4ziZjedGEBBVTQQGyGzbAZNsPm2BybY3Nsjs2xOTbH5tgcW8VWsVVsFVvFVrFVbBVbxVaxNWwNW8PWsDVsDVvD1rA1bA1bx9axdWwdW8fWsXVsHVvH1rENbAPbwDawDWwD28A2sA1sY9mOWVonFlBABQ10sIIN7CC2gq1gK9gKtoKtYCvYCraCrWATbIJNsAk2wSbYBJtgE2yCTbEpNsWm2BQbWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkSUyUex7gB3ZwLIwzlBMLKKCCBjpYQWyGzbA5Nsfm2BybY3Nsji2uVcyJSiXm6l04FsbZzInTViVQQAUNdLCCYSuBHRwL42xmzkYqMXHvQgEVNNDBCraFcbJSjweWBFTQQAcrGMVqYAfHwjhZObGAAipo4CzWYnzjXCQw5vNdWEABFZzF5iz7EpP6LqxgA8PWAsfCOBc5MWw9UEAFp62HOM5F5o2xJ07bvM/1xAZ2cCyMc5ETCzht885WiSmCFxroYAUb2MGxMM5FTiwgNsWm2BRbXKvoMXyRBCd2cNri/lDMGbywgAIqaKCDFWxgB7E5NscWSTBi0SMJTjTQwQo2sINhO57Ue4BP2/MkOVBABQ10sIIN7OBYOJNA4+pibQUMW2wwTUEDHYy68SvaWNgfYAGjbqzNrqCBDlawgdMWz/XFFMMTZyhcWEABFTTQwQo2ENtYtphteGHYNFDAsFmggb6wRIXjgcv42xpooIMVjCVrgR0cC+UBxpKNQAEVNHDa4sppzCK8sIEdHAvjUcQTp03ix8+ev1BBA8N2PF1awQZ2cCy0B1hAARU0EJthM2wWthgzGwv9ARYwbD1QQQMdrGADwxaj7mNhfYCzWFxXjnmDGpeNY+LghWNhNO+JcyHjunJMHrxQQQPnQmpsiHM3fmEDO8jq7qzuaOkTWd2d1d1Z3dHSJ4YtNuVo6RM7GL8tBipa+sQCxm+LgYqWPtFAByvYwA6OC2Ni4YUFFFBBA2fduFAeUwQ1ro7HHMELHaxgAzs4F8fmqMdMwQsLKGDYaqCBDoatBTawg2Nh9PGJBRQwbD3QQAcrGIrjGe/42xioaCeXwAIKqKCBDk5FXOaOWX0XdnAsjHby47nyAgoYthio6LcTHaxgAzs4FkYXxrXXmON3oYAKhiJWYfSQx5hFD52ooIHzn8XZQUzYu7CBHRwLo4dOnLZ6PFIv4LTFAXJM0tN2/G0DZ90WKyC6JTAm6l1YQAEVNNDBCjawg9gKthI2CxQwbPGagGi9E31htFMcmcfsO23HKwQMdLCCsWQ9sINjYTTOiXPJ4ng9puFdqKCBfo1vTMW7sIEdHAtjB3hi2EqggArawmi9HsMXPdRjSKKHTuzgWBg9dGIBwxYjGT10ooEOhi1GJ3roxA6GbeZDTJ+7sIACKmigg9M2YnRiT3ZiB8fCaL0e6zh6KA7oYzrchWNh9NCJBRRQQQMdrCC2gW1cNnlEX8xTgic2sIPxt/M9CTEH7sICCqiggc8ls0cUm7ukCxvYwTExXoMxe+jCAsrEGqiggWELsYRtBE7bPIKWmDp34Vg4O+vCAgo4bSXGbHbWhQ5WsIEdHAvtARZQQGyGzbBZ2GLMrIEdDFuMmT/AAgoYthi+2bF2vKJkduyFHRwLZ8deWMBZV6LY7NgLDXQwbPFmlNrADoYt1mZ7gAUMW6zjpqCBDk6bxkLO3rR4TUpMkruwgALOuvG6lJgkZxrjO/eQpsebWyrYwA6GLX7xeIAFFDBs8dtmS5vF8s6WtnjnSsyMM4vFmS1tdvztuDBmxl1YQAEVNDBsI7AunN1tc1aExBS3Cw2c/8yP19RUsIEdHAuju08soIAKGohNsAm26O54K0xMcTsxuvvEsMVvi+4+UcFZrMZvizadFxol5qpZDUW06YkKzoWcRzYSc9UurGADOzgWRpueGLZY3mjTExU0cNrmXlpirtqFDZy2Fj8omvfAaN4TCyigggaGTQIr2MAOxm+LjSua98QChi3GN5r3RAOjboxvtGmLXxxt2mJlRZueqOCs0OPHR5ueWMEGdnAsjDY9cdp6/Pho0xMVNJB1MVgXg3UxWBdjrQt5PMACCqiggWtdxFy1CxvYwfht8c6n8gALGL/NAhWMMYs3REVLn9jBqBsvjIqWPrGAUXcEKmiggxVsYAenbR5SScxVu7CAAoatBs4KI8YsdsIHRnefGBXiF0d3n6jgXN4Rvzi6+8QKNrCDY2F094lhiyWL7j5RQQPDFqswXmr1iN8Wr7U6UUAFDXSwToy68V62Ezs4FsYL2uZ7aCTmn10oYNhiHcfL2k50cNpKiOOtbXEcFfPPvMQmF+9uOzBe33ZiAQVUcNriICfmn11YwQZ2cCwcD7CAAiqIbWAb2EbYYsxGB8eFMf/M57tQJOafXSigggY6WMFpizfHxfyzC6dtXvKSmH92YQEFjLoWWMEGdjDqxq+IFyieWEABFTRw2uI4KmaaXdjADo6F8XrFEwsooIIGYlNsii1euxjHcjH/7MR4+WIc1sX8swsFjAqzeWP2mMehWsweu1BABWPJWqCDFWxgLNkIHAuj508s4LTFi/di9tiFBjpYwQZOWxxExuyxE6PnTyxg2OLHR8+faKCDFWxgB8fC6PkTC4itY+vYouctxix6/sQGdjBsM41i9tiFBRRQQQPDFqMePX9iuzAmh/nxXsNo3jgqjmlgF1awgXMh54VGiWlgJ0bznljAuZDzGp7ENLALDXRwre6YBnZhB9fqjmlgFxZQwLDVQAMdjN/WA2fdeDtgTPi6sICzbo1liOY9MerGSEbznljBBnZwLIzmPTFsMQ7RvCcqaKCDFWxgB8fCaP8TsTk2x+bYHJtjc2yOzbFVbBVbxVaxVWwVW8VWsVVsFVvD1rA1bA1bw9awNWwNW8PWsHVsHVvH1rF1bB1bx9axdWwd28A2sA1sA9vANrANbAPbwDaWLSZ8XVhAARU00MEKNrCD2Aq2gq1gK9gKtoKtYCvYCraCTbAJtkiNOKuLCV8XGhg2DaxgA6ctzpJiwteJkSUnTluczcSErwsVNNDBCjawg2NhZMmJ2AybYYvUiNPUmMTlLcYh8uHEAgoYFWqggQ5WsIGxvC1wLIx8OLGAAipooIMVbCC2iq1hi1BosWIjFOK8O2ZuXehgBRvYwamIk+1499qFBRRQQQMdjD1DLFn0/IkFFFBBAx2ci95jdUfPn9jBcWFM7bqwgAIqaKCDFWxgB7EVbAVbwVawFWwFW8FWsBVsBZtgE2yCTbAJNsEm2ASbYBNsik2xKTbFptgUm2JTbIpNsRk2w2bYDJthM2yGzbAZNsPm2BybY3Nsjs2xOTbH5tgcW8VWsVVsFVvFVrFVbBVbxVaxNWwNW8PWsDVsDVvD1rA1bA1bx9axdWxHVNRAAx2MYjPPYmKWx3WjmJh1YQM7OC6MiVkXzmWIq0kxMetCBQ0MmwZWsIFhs8CxMHr+xAIKqKCBYfPACjawL4xGj8tNMTHL4yJUzLDyOWdaYobVhQY6WMEG9vkm6xio46XWgfFa6xMLKBNjGeLl1ica6BNjoOIV1yc2sINjoT/AAoYtBsoVNNDBUMxVeLwErMQV+OM1YBdbYk9cE7fEPfGAj5c6n1wSJ29J3pK8JXlL8pbkLclbkleSV5JXkjcm4cfbauR46dfF8Tf9+BtNbIk9cU3cEseyxaHV8RKwk+PRnngPiRwvArs4vHF4dbwM7GJLHN7YyI9Xgl3cEvfEA/ZH4pJYEh/eGmyJPXFN3BL3xAM+XxB9cEksiZO3Jm9N3pq8NXlr8tbkbcnbkrclb0ve81XQszf7+TLog0tiSayJLbEnrolb4p44eUfyjuQdyTuSdyTvSN6RvCN5R/IOvMcrv47t8Hjp18nlkbgklsSaONZdhOXxArCLa+KW+FieEjxgeSRmHI7XgV2siS2xJ66JW+LDq8ED1kfikjiNj6bxSb08Ui8fr/u6OI2PpfGxND6WxsfS+FgaH0vj42l8PI2Pp/HxND6exsfT+HgaH0/j42l8PI1PTeNT0/jUND41jU9L49PS+LQ0Pi2NT0vj09L4tDQ+LY1PS+PT0vj0ND6pf0fq35H6d6T+Hal/R+rfkfp39DQ+PY3PSOMz0viMND5jjY8eb/S6uCSWxJp4jY8eL/u6uCZuidf46PEasJPLI/EaHz3eBHaxJrbEnrgmbonX+OijDFgeiUvizm+UND6axkfT+GgaH03jo2l8NI2PpvHRND6axkfT+FgaH0vjY2l8LI2PpfGxND6WxsfS+FgaH0vj42l8PI2Pp/HxND41jU9N41PT+NQ0PjWNT03jU9P41DQ+NY1PTePT0vi0ND4tjU9L49PS+LQ0Pi2NT0vj09L4tDQ+PY1PT+PT0/j0ND4jjc9I4zPS+Iw0PiONz0jjM9L4jDQ+I43PYHzK45GY8SkPSayJLbEnrolbYsanPBifUh6JS+LjOKcHW2JPXBMfx1cjuCce8PkxlYOP4+f4vccx9sma2BIfY2vBNXGD40xoPpSjMdPowrEwzoROnGdCJRY9zoROVNDAeSZUYrHn7u/CBnZwLKwPsIACKmggtoqtYotPcc05hxrvtKoSAxSf2jqxgR2cSyaxMcQnt04soIAKGhi22Dzi81snNrCDY2F8huvEAgoY56rP0wmV48NaNbCAAipooIMVbGAHx8KC7fjcVg8UUEEDHaxgAzs4Fh4f4DoQm2ATbIJNsAk2wSbYBJtiU2yKTbEpNsWm2BSbYlNshs2wGTbDZtgMm2EzbIbNsDk2x+bYHJtjc2yOzbE5NsdWsVVsFVvFVrFVbBVbxVaxVWwNW8PWsDVsDVvD1rA1bA1bw9axdWwdW8fWsXVsHVvH1rF1bAPbwDawDWwD28A2sA1sA9tYtvMjfQcWUEAFDXSwgg3sILaCjSxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCxRskTJEiVLlCwxssTIEiNLjCwxssTIEiNLjCwxssTIkpgOVefzLhrToS4UMGwt0EAH48jRAhvYwbEwsuTEAgqooIEOYhNsgk2wKTbFptgUm2JTbIpNsSk2xWbYDJthM2yGzbAZNsNm2AybY3Nsjs2xOTbH5tgcm2NzbBVbxVaxVWwVW8VWsVVsFVvF1rA1bA1bw9awNWwNW8PWsDVsHVvH1rF1bB1bx9axdWwdW8c2sA1sA9vANrANbAPbwDawjWWLSVIXhq0GCqiggQ5WsIEdHAuPLDkQW8FWsBVsBVvBVrAVbAWbYIuOnW9+0Jh0VOeDbRqTjk6M3jyxgAIqaKCDFWwgNsPm2Jwli347sYFRYQSOhdFvJ87lnU/UaUw6ulBBAx2sYAM7OG1zxrbGpKMLCyhg2DTQQAcr2MCwxc+Mfjsw+k1jdKLfTpx/a7Fk0S0HRrecWEABFTTQwQo2ENtYtphedGEU08AoZoFRzAMbGMVG4FgYzXBiAQVU0EAHp81jcaIZ5qxmjdlDdU5a1pg9VD2WLHahHosTu9ATDXSwgg3sC2NnOWcfa8wIulBBAx2sYFsYrTenemnM56kevy3a6cQGdnD+tvgwd8znubCAAipooIMVbGAHsVVsFVvFVrFVbBVbxVaxVWwVW8PWsDVsDVvD1rA1bA1bw9awdWwdW8fWsXVsHVvH1rF1bB3bwDawDWwD28A2sA1sA9vANpYt5gldWEABFTTQwQo2sIPYCraCrWAr2Aq2gq1gK9gKtoJNsAk2wSbYBJtgE2yCTbAJNsWm2BSbYlNsik2xKTbFptgMm2EzbIbNsBk2w2bYDBtZ0siSRpY0sqSRJY0saWRJI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGljSypJEljSxpZEkjSxpZ0siSRpY0sqSRJY0saWRJI0saWdLIkkaWNLKkkSWNLGlkSSNLGlnSyJJGljSypJEljSxpZEkjSxpZ0siSRpb0IypKoIEOVrCBHRwLj6g4sIACYivYCraCrWAr2Ao2wSbYBJtgE2yCTbAJNsEm2BSbYlNsik2xKTbFptgUm2IzbIbNsBk2w2bYDJthM2yGzbE5Nsfm2BybY3Nsjs2xObaKrWKr2Cq2iq1iq9gqtoqtYmvYGraGrWFr2Bq2hq1ha9gato6tY+vYOraOrWPr2Dq2jq1jG9gGtoFtYBvYBraBbWAb2MayjccDLKCAChroYAUb2EFsZMkgSwZZMsiSQZYMsmSQJYMsGWTJIEsGWTLIkkGWDLJkkCWDLBlkySBLBlkyjkbvgSGeZzPjaPQRWEABFTTQF0bHzoeINKadXaiggQ5WsIEdHAujY0/EVrFVbNGQ8yUbGrPRakxkiMloJ0ZDnlhAARU00MEKNhBbw9axRevFPImYT1Z7LG802YkdHAujyU4soIAKGuggtoFtYBuXzWIGWZ3v0LCYKFbnFH+LeWIXFlBABQ10sIIN7CA2wSbYBFs0w4iFjGY40cEKNrCDY2HsWOdUE4upZRc+bW3O4LeYWHahgQ5WsIEdHAtnv11YQGyGzbAZNgtbrCxrYAfHQn+ABRQwbDEObmDYamAFG9jBsbA+wAIKGLYRaKCDFWxgB8fC9gCnrcTozD6+UEEDHaxgAzs4Fs4+vhBbx9ax9SgWW+pgUx5syoNNedA4g8YZNM6gcQaNM2icsRonpptdWEABFVyNEzPNLqxgAzu4GqccoXDgapxyhMKBa1OOyWYXOljBBnZwNU5MM7uwgAJiE2yCTbDJapx4xdaFq3HiFVsXFlBABVfjlCMUDlyNU7SBHVyNU+wBFlBABVfjFHOwgg3s4Gqc4g+wgGtTjvlyFxroYAUb2MHVODFf7sICYqvYKra6eihmxrUSg3o0+oECRoXY5I5GP9DBCjawg2Ph0egHFlBAbB1bx9bD5oEN7OBYOB5gAQVU0EAHsQ1sY9lixl2bN28s5tYdYxZz6y6s4BqdmFt34RqdmFt3YQEFVNBAByuIrWAr2GSNTsytu1BABQ10sIINZHRkrYuYW3chNsUW3X2MZPTxnHNqMV/uxOjjEwsooIIGOljBWN4e2MGxMPr4xAIKqKCBDoZtBDawg9M2J5pazJe7sIACKmiggxVsYAexNWwNW3T3nLVqMQeuSayW6OMTx8Lo4xMLKKCCBjpYQWwdW8cWHSux3qI3JYYvevPEBnZwXBjz2i4soIAKzn82b/xZTEVr826fxVS0Cw2cizNv/FlMRbtwLs58L6fFVLSmUTda78BovRMLKOC0zXd4WkxFu9DBabNYyGi9E6dt3uKzmIrWLBYy+sJicaIvDoyt2qNYbNUnKmiggxVsYAfHwtiqT8RWsVVssdF6LHpstCeOhbHRnlhAARU00MEKYmvYGrbYlD2GLzZajxUbG+2JDezgWBj7lnm/0GLOU5vXCSzmPF1ooIMVbGAHx8LYX5xYQGwFW8EW2+S8QGExpenE2CZPLKCAChroYF0YaT+fALaYsXShgAoa6GAFG9jBsdCwGTbDFsE/3wxjMSHpwg6OhRH8LQYqmmE+T2wx9ehCByvYwA6OhdEMJxZQQGwVW8UWzdBifKMZ5hO1FjOLLhRQQQMdrGADOzgWdmwdW1+2mFzT5tteLKbRtHlJxmLCTJtvWrGYMHOhgQ5WsIEdHAtjSz2xgNgEm2CL1R3XYWKOy4mxuk8soIAKGhjFSuBYGOv4xChmgQIqaKCDFWxgB8fC2AhOxNawNWwNW8PWsDVsDVvD1rF1bB1bx9axdWwdW8fWsXVsA9vANrANbAPbwDawDWwD21i2mDBzYQEFVNBAByvYwA5iK9gKtoKtYCvYCraCrWAr2Ao2wSbYBJtgE2yCTbAJNsEm2BSbYlNsik2xKTbFptgUm2IzbIbNsBk2w2bYDJthM2yGzbE5Nsfm2BybY3Nsjs2xObaKjSypZEklSypZUsmSSpZUsqSSJZUsqWRJJUsqWVLJkkqWVLKkkiWVLKlkSSVLKllSyZJKllSypJIllSypZEklSypZUsmSSpZUsqSSJZUsqWRJJUsqWVLJkkqWVLKkkSWNLGlkSSNL2pElPdDBCk7FfGmQxaSdEyNATpyK+RIei0k7Fyo4FfO9IxbTc9pogR0cCyMq5jO3FtNzTpwd2x/xB7Pf+iOWbPbbhQLG38Y/m/3W43JTzHG5sE4sgQ3sCz0wRmc2w4mzGS4soIAKGuhgBRuIrWJr2Fr8s/jxrYEdjH8Wv7g/wAIKqKCBDlawgR3ENrANbAPbwDawDWwD28A2sI1li2+QXTht81laizcbXaiggQ5WsIEdHAvnBn4htoKtYCvYCraCrWAr2Ao2wSbYBJtgE2yCTbAJNglbCRwL9QEWMGwaqKCBDtaFtg5OuxnoYPytBzawg2OhP8ACCqiggQ5ic2yOzbFVbBVbxVaxVWwVW8VWsVVsFVvD1rA1bA1bw9awNWwNW8PWsHVsHVvH1rF1bB1bx9axdWwd28A2sA1sA9vANrANbAPbwDaWLSaKXFhAARU00MEKNrCD2Aq2gq1gK9gKtoKtYCvYCraCTbAJNsEm2ASbYBNsgk2wCTbFptgUm2JTbIpNsSk2xabYDJthM2yGzbAZNrJkkCWDLBlkySBLBlkyyJJBlgyyZJAlgywZZMkgSwZZMsiSQZYMsmSQJYMsGWTJIEsGWTLIkkGWDLJkkCWDLBlkySBLBlkyyJJBlgyyZJAlgywZZMkgSwZZMsiScWTJCKxgA6diPhZjMQnmwgJOxfwoq8UkmD4/b2AxCeZCBys4FXEdPCbB9LigHZNg+rx07fE6pgunbV669ngZU5/Xqz3exXThtM3383u8ianPB0o8ptGcGPkwny3xmDsTy+Axd+ZCBec/8xBHz8+HTzzmw3SPZYieP1FABQ10sIJtYXSshzg69sQKxt/Gz4yOPXEsjI49sYACKmiggxXEZtgMm2NzbI7NsTk2x+bYHJtjc2wVW8VWsVVsFVvFVrFVbBVbxdawNWwNW8PWsDVsDVvD1rA1bB1bx9axdWwdW8fWsXVsHVvHNrANbAPbwDawDWwD28A2sI1li0kwFxZQQAUNdLCCDewgtoKtYCvYCraCrWAr2Aq2gq1gE2yCTbAJNsEm2ASbYBNsgk2xKTbFptgUm2JTbGRJIUsKWVLIkkKWFLKkkCWFLClkSSFLCllSyJJClhSypJAlhSwpZEkhSwpZUsiSQpYUsqSQJYUsKWRJIUsKWVLIkkKWFLKkkCWFLClkSSFLCllSyJJClhSypJAlhSwpZEkhSwpZUsiSQpYUsqSQJYUsKWRJIUsKWVLIkkKWFLKkkCWFLClkSSFLCllSyJJClhSypJAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlQpYIWSJkiZAlSpYoWaJkiZIlSpbokSU9sIINnIr5MJ3H26ouLOA6O9BioIOz7vyAlce8oAs7OBZGapxYQAEVNNBBbIJNsAk2xabYFJtiU2yKTbEpNsWm2AybYTNshs2wGTbDZtgMm2FzbI7NsTk2x+bYHJtjc2yOrWKr2Cq2iq1iq9gqtoqtYqvYGraGrWFr2Bq2hq1ha9gatoatY+vYOraOrWPr2Dq2jq1j69gGtoFtYBvYBraBbWAb2Aa2sWzxiqoLCyigggY6WMEGdhBbwVawFWwFW8FWsJElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJkiZMlTpY4WeJHltSJR5YcWMA4HC+BBjpYwQZ2cCw8TmEOLKCA2Aa2gW1gG9gGtrFs9fEACyigggY6WMEGdhBbwVawFWwFW8FWsHE7pRZsBVvBJtgEm2ATbIJNsAk2wSbYBJtiU2yKTbEpNsWm2BSbYlNshs2wGTbDZtgMm2EzbIbNsDk2x+bYHJtjc2yOzbE5NsdWsVVsFVvFVrFVbPW6M+gxCfHCDk7bnHrvMQnxwgLOui3+NqLixAo2sINjYUTFiQUUUEFsHVvH1rF1bB3bwDawDWwD28A2sA1sA9tYtpg32OfUe495gxdWMP5ZD+zgXMg5Gd5jCuGFBZwLOScOeUwhvNBAByvYwA6OhdH+JxYQm2ATbIJNsAm2aP/5PgWP936dGO1/YgEFVNBAByvYQGyKzbAZNsNm2AybYTNshs2wGTbH5tgcW7R/j60k2v9EBysYtthgov1PHAuj/U8sYPyzFtjBsTD6uI/AAgqooIEOVrCBHRwLO7aOrWPr2Dq2jq1j69g6to5tYBvYBraBbWAb2Aa2gW1gG8t2TLs8sYACKmiggxVsYAexFWwFW8FWsBVsBVvBVrAVbAWbYBNsgk2wCTbBJtgEm2ATbIpNsSk2xabYFJtiU2yKTbEZNsNm2AybYTNshs2wGTbD5tgcm2NzbI7NsTk2x+bYHFvFVrFVbBVbxVaxVWwVW8VWsZElnSzpZEknSzpZ0smSTpZ0sqSTJZ0s6WRJJ0s6WdLJkk6WdLKkkyWdLOlkSSdLOlnSyZJOlnSypJMlnSzpZEknSzpZ0smSQZYMsmSQJYMsGWTJIEsGWTLIkkGWDLJkkCWDLBlkySBLBlkyyJJBlhwTN+fLUPyYuHniWBgBMp9y8GO25okKTsV8cYofszVPrGAoWuBTMeZnxTxma544A+TCAgqooIEOVrCB2BSbYTNshs2wGTbDZtgMm2EzbI7NsTk2x+bYHJtj87DFavEOjoX1AYYtVkAVUEEDo26szRYVYmW1AgqoYFTogbG8sUXNUBgllneGwoUdHAtnKFxYQAEVNNBBbD1sEtjBsXA8wAIKqKCBDlYQ28A2LluNyZhjPppTYzLmhQIqaKCDFWxgB8fCgq1gK2HTQAUNdLCCDezgWCgPsIDYJOpaYFSogVGhTYyeP7GAAsby9kADHaxgAzs4FkbPn1jAsI3AaZMYs+j5E6dN4ldEz5/YwGmbs4JrzPc8MXr+xGmT+EHR8ycqaKCDFWxgB8fC6PkTsVVsFVvFVrFVbBVbxVaxNWyRDxLDF/kw5zbXmO95oYEOVrCBHRwLIx9OLCC2jq1j69g6to6tY+vYBraBbWAb2Aa2gW1gG9gGtrFsMd/zwgIKqKCBDlawgR0M20yjmO95YSgsUMFQ1EAHK9jADo6FEQpzenqNSZ4XCqiggQ5WsIEdHAsVW0TFfClMjemcFzpYwVl3fsChxnTOC8fCiIoTCyhg2EaggQ5Om8UKiKg4sYNjYUTFiQUUUMG4pBjLcFxSPHAsrA+wgAIqaKCDFcRWsVVsDVvD1rA1bA1bw9awNWwNW8PWsXVsHVvH1rF1bB1bx9axdWwD28A2sA1sA9vANrANbAPbWLZztuaBBRRQQQMdrGADO4itYCvYCraCrWAr2Aq2gq1gK9gEm2ATbIJNsAk2wSbYBJtgU2yKTbEpNsWm2BSbYlNsis2wGTbDZtgMm2EzbIbNsBk2x+bYHJtj8+tRonrM1jyxgnEV+/jbDo6FcVRh8bdx/GA10MAZePN9VzXmZV44A+9Yhjh+OHEG3nwmqMa8zAsLOANvTuqrMS/zQgMdrGADOzgWxvGDx6+I44cTBVQwbPHb4vjhxAo2sC+Mvb/Hj4+9/4kN7OC4MGZVXlhAARU00MEKNrCD2Aq2gq1gK9gKtoIt9tLzuzs1JkJe2MApnm/BqjER8sTYS59YQAEVNNDBCjYQm2IzbIbNsBk2w2bYDJthM2yGzbE5Nsfm2BybY3Nsjs2xObaKrWKr2Cq2iq1iq9gqtoqtYmvYGraGrWFr2Bq2hq1ha9gato6tY+vYOraOrWPr2Dq2jq1jG9gGtoFtYBvYBraBbWAb2MayxUTICwsooIIGOljBBnYQW8FWsBVsBVvBVrAVbAVbwVawCTbBJtgEm2ATbIJNsJElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZElRpYYWWJkiZEldmTJvL5jR5YcWMBQtEADHZyKONCK2Y8XdnBcGLMfLyzg/EFzRkKN2Y8XGuhg2FpgAzsYtrkbj9mPY97DrjH78UIBp61H3QiQEx2sYAM7OBZGgJxYQAGxCTbBJtgEm2CLAJmvfKox+3GMGL4IkBMFVNBAByvYwA6OhYbNsBk2w2bYDJthM2yGzbA5Nsfm2BybY3Nsjs2xOTbHVrFFgMxX89eY/Xhh2CTQQAcrGLZYWREgI1ZWBMiBESAnFlBABQ0MW2zVESAnxvyoEMflhQPj8sKJBRRQQQMdrGADsXVsA9vANrANbAPbwDawDWwD21i2Y/bjiQUUUEEDHaxgAzuIrWAr2Aq2gq1gK9gKtoKtYCvYBJtgE2yCTbAJNsEm2ASbYFNsik2xKTbFptgUm2JTbIrNsBk2w2bYDJthM2yGzbAZNsfm2BybY3Nsjs2xOTbHFpcX4vrDMfvxxALKdf3hmP14ooFh08AKNvBpe15Zjz+eWfHkUM+wWKyJLbEnrolb4p54wDM/FidvT96evD15e/L25O3J25O3J+9I3pG86/0wtR5JMLEd74fRwALOUZ9vgqnteD/MgccSWrAnromPJfTgnnjA5ZG4JJbEmtgSH94aXBO3xD3x4Z3pHxMjF5fEklhhPf4mxkklsSaOZZt3m2vMaVxcE7fEPfGA7ZG4JJbEmjh5LXkteS15LXkteT15PXk9eT15PXk9eT15PXk9eT15a/LW5K3JW5O3Jm9N3pq8NXlr8tbkbcnbkrclb0velrwteVvytuRtyduStydvT96evD15e/L25O3J25O3J29P3pG8I3lH8o7kHck7knck70jekbwDb8ylXFwSS2JNbIk9cU3cEvfEyVuStyRvSd6SvCV5S/KW5C3JW5K3JK8krySvJK8krySvJK8krySvJK8kryavJq8mryZvyque8qqnvOopr3rKq57yqqe86imvesqrnvKqp7zqKa96yque8qqnvOopr3rKq57yqqe86imvesqrnvKqp7zqKa96yque8qqnvOopr3rKq57yqqe86imvesqrnvKqp7zqKa96yque8qqnvOopr3rKq57yqqe86imvesqrfubV3M/2M68OLokPVwu2xJ74cPXglrgnPlxzH9rPjDq4JJbEmtgSe+KauCXuifGOI6NiXs84smi+HraOI4vmx3nqOLLo5Jq4Je6JB3xk0cklsSQ+vBZsiT1xTdwS98QDPrLo5JJYEievJK8krySvJK8krySvJq8mryavJq8mryavJq8mryavJq8lryWvJa8lryWvJa8lryWvJa8lryevJ68nryevJ68nryevJ68nrydvTd6avDV5a/LW5K3JW5O3Jm9N3pq8LXlb8rbkbcnbkrclb0velrwteVvy9uTtyduTtydvT96evD15e/L25O3JO5J3JO9I3pG8I3lH8o7kHck7kncsb3s8HolLYkmsiS2xJ66JW+KeOHlL8pbkLclbkrckb0nekrwleUvyluSV5JXkleSV5JXkleSV5JXkleSV5NXk1eTV5NXk1eTV5NXk1eTV5NXkteS15LXkteS15LXkteS15LXkteT15PXk9eT15PXk9eT15PXk9eT15D3zqgeXxJL4cI1gT1wTt8Q98YDPjDq4JJbE8RvnfMj2ODLqZE9cE7fEPfGAj4w6uSSWxMnbk7cnb0/enrw9eXvyjuQdyTuSdyTvSN6RvCN5R/KO5B14y+ORuCSWxJrYEnvimrgl7omTtyRvSd6SvCV5S/KW5C3JW5K3JG9JXkleSV5JXkleSV5JXkleSV5JXkleTV5NXk1eTV5NXk1eTV5NXk1eTV5LXkteS15LXkteS15LXkteS15LXk9eT15PXk9eT15PXk9eT15PXk/emrw1eWvy1uStyVuTtyZvTd6avDV5W/K25G3Jm/KqpLwqKa9KyquS8qqkvCopr0rKq5LyqqS8KimvSsqrkvKqpLwqKa9KyquS8qqkvCopr0rKq5LyqqS8KimvSsqrkvKqpLwqKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJKUV5LySlJeScorSXklKa8k5ZWkvJIzrzx4LNYzrw4O15x53fTIqDnfuumRUSd74pq4Je6JB3xk1MklsSRO3pK8JXlL8pbkLcl7ZNG8n9j0yJaTW+Ke+FjOedyuR7acXBJLYk1siT1xTdwS98TJa8lryWvJa8l7ZItJsCeuicM758I3PbLl5AEf2eLx90e2nCyJNbEl9sQ1cUvcEw+4Jm9N3pq8NXlr8tbkrclbk7cmb03elrwteVvytuRtyduStyVvS96WvC15e/L25O3J25O3J29P3p68PXl78h7ZMh9FaHpky8lHtsQ2H59FbAc6WMGjeATCESAnj8V2BMjJJfHxo2qwJrbEnrgmbol74gEfYXJySZy8JXlL8pbkLclbkrckb0leSV5JXkleSV5JXkleSV5JXkleSV5NXk1eTV5NXk1eTV5NXk1eTV5NXkteS15LXkteS15LXkteS15LXkteT15PXk9eT15PXk9eT15PXk9eT96avDV5a/LW5K3JW5O3Jm9N3pq8NXlb8rbkbcnbkrclb0velrwtec+QacHH388LYnYcYMzXnjc7DjBOtsSeOOrPFzc2O/Lh5J44fledgeNHPpxcEktiTWyJPfHhteCWuCce8JEJc9Z086PH5wTp5kePn9wTD/jo8TlfuvnR4ydL4mOZR7Al9sQ1cUvcE4d3zjFrfvR4i2U+erxJcHhbjMPRvy1+49G/J/fEAz76t8XvOvp0zsxufvRI5PzxhfPYHI4vnJ94WA/WxJbYE9fELXFPPOBja24xCsfW3GMUjq355Jq4Je6JB3zsYnuM4LGLPVkSa2JL7Ilr4gYfu88ea+XonJM18VEz1tbROSfXxC1xTzwW16NzTi6Jj5oWXBO3xEdNDx7wsdc8uSSWxJrYEnvio+bckurRLSeXxEfNFqyJLbEnrolb4p748M7tpx7dMt8l1OrRLSdLYk1siT1xeOeU8laPjjq5Jx7w0VEnl8SSWBN3xsTSuHkat2MPd/xGT+Pmadw8jZuncfM0bp7G7djDHWN17OGO31vTuNU0bjWNW03jVtO4Hf1+/K6axq2mcatp3Goat5bGraVxa2ncjh6fE/nbOeF1TtRv54TXg48eP7kkPupEjxw9frIl9sQ1cUt8eKOPjsPog4/D6JNLYkmsiS3x4Y3eOXJgxHo/cuDknngsbkcOnFwSH94WrIktsSeuiVvinnjARybEujinycY4n9NkT/bENTHjeU6TPXnAR26cXBJLYsaziSX2xDVxS9wTsx7bkRuxLs6pt8d4Hrlxsia2xJ64Jk7jqWk8NY3nmRsHl8RpPVpaj5bW43HEPB8jaecU25Nn/fKIdRR5cnFJLIk1sSX24BifyJOLW+KeeMD1kbgklsRHnRjzdvx9jFs7vPEbW03cEh/eHjzg/kh8eGNMuiTWxJbYE9fELXF459us2jHV9eTIgYtLYuF3RV+XEr0weuKx+Ji6enFJLIlj+ecrrNoxdfViT1wTH94RHN75SfF2TF09OY4BLi6JJbEmtsSeuCZuiZO3JK8krxxeD5bEmtgSe+KauCU+vDEOMmA9vC04vBpjq5L+75o4vBrLGf1+cU3cEvfEA45+v7gkjn8bZxHH9NOLB3z08sklsSTWxJbYE9fEyevJ68kb+/QSZxrHtNGL4+/jjOKYNnry0csnx3LG2cUxbfRiTWyJPXFN3BL3xAM+ev/k5O3J25P36OU42zmmfpY4Bzmmfl6siS3xsZzRU6Mmbol74ljOOF84pn5eXBJL4vDGcfsxJfRiT1wTt8Q98eGdvXBMCb24JJbEh7cFW2JPXBO3xD3x4Z1jdUwJvbgklsThjeO9Y0roxZ64Jm6Je+LwxvHJMSX04pJYEh9eCbbEnvjwxngePX5yh4/ejOOHY0plGfG7jv46uSce8LGvPLkkPpZzBGtiS+yJp1di331Mqby4Jx7B8buiTy8uiSWxJrbEnvjwanBL3BMPuB+uWF9Hf8UVqGMK48WeuCZuiXvicXE/pjBeXBJLYk1s8NEj81pHP6YVlvk6mX5MKyzzalc/phVe3BMP+Njm55WmfkwrvFgSa2JL7IkPrwQfXg0+vBZ8eH3ysc2fXBJHfYvfdWzbJ9fELXFPPOBj/3VySRy/y2Ks7BjbGAc7xjZ+ix3jGb/FauKWuCce8NFfJ5fEklgTW+Lk9eT15PXk9eStyVuTtyZvTd6avDV5a/LW5K3JW5O3Je+xD/VY78c+9OSjTmwDx/7OY133tGw9LVtPy9bTsvW0bD0tW0/L1tOyjbRsI43JSN6RvCN5R/KO5B3JO5J34C2PR+KSWBJrYkvsiWvitsbzmPZ38rEfjLE9pugdY3tM0Tv/bUnLJmnZJC2bpGWTtGySlk3SsklaNmmJk1eSV5NXk1eTV5NXk1eTV5NXk1eTV5PXkteS19g+y5kDB3fG8+zZGM/UsyX1bEk9W1LPltSzJfVsST1bUs+W1LMl9WxJPVtSz5bUsyX1bEk9W1LPltSzJfVsacnbkrclb0velrzHce8xbi1tn2dfxxiePRtjmHq2pJ4tqWdL6tmSerakni2pZ0vq2ZJ6tqSeLalnS+rZknpWUs9K6llJPSupZyX1rKSeldSz8miJe+KxxkrO/fjBvsZNzp6d4yapZyX1rKSeldSzknpWUs9K6llJPSupZyX1rKSeldSzknpWUs9K6llJPSupZyX1rKSeldSzknpWjH2KpJ4VY58izj5F0n5WUs9K6llJPSupZyX1rKSeldSzknpWUs9K6llJPSupZyX1rKSeldSzknpWUs9K6llJPStpPytNE5Nj0skxSftZSftZSftZSftZST0rqWcl9ayknpXUs5J6VlLPSupZST0rqWcl9ayknpXUs5p6VlPP6oMx0YcmZkyOaVvHmGhh2Y5pWxd74pq4Je6J07KlntXUs5p6VlPPaupZTT2rqWc19aymntXUs5p6VpXeUU1jovSOGr2jlpbN0rJZWrZ0bKzp2FjTsbGmY2NNx8aajo01HRtr6llNPaupZzX1rKae1dSzmnpWnYzV+khMxmolYzX1l6b+0rRP1LRP1LRP1LRP1JaWraVla2nZWhqTnrw9edOxsaae1dSzmnpWO/ti7eyLdbAv1sG+WFN/aeovTf1lqb8s9ZelfaKlfaKlfaKlfaKlfaKlfaKlfaI9krckb0newjZsRRPT1yb0taX+stRflvrLUn9Z6i9L/WWpvyz1l6V9oqV9oqV9oqV9oqV9oqV9oinry5RjezOO7c04trfUX5b6y1J/WeovS/1lqb8s9Zel/rLUX5b6y1J/WdonWtonWiVzrKb1Vckca2SOpf6y1F+W+stSf1nqL0v9Zam/LPWXpf6y1F+W+stSf9nZX7HMZ38Fn/u4WP5z/xXLn/ZflvZflvrLUn9Z6i9P/eWpvzz1l6f+8tRfnvrLH/S+p/NEL/S+F3rf0/7L0/7L0/7L0/7L0/7L0/7LU3956i9P/eWpv1zSsgnbuSvbuSvbuafjQ0/Hh56ODz2d03naf3naf3naf3naf3naf7mlZbO0bJ6WzdOypV7w1AueesHT8aGn40NPx4eejg89HR96Teu0pmVraZ22tE5TL3jqBU+94KkXPPWCp17w1AueesFTL3jqBU+94KkXPPWCp17w1AueeqGmXqgPMqSmY7n6IENqIUNqYflrOpar6ViupmO5mo7lamFsa2G9V2G9V2G917RfqGm/UNN+oab9Qk3HXVU1Mfusauyzatpua9pua9puq7Ft1LTdVmfbqM62UVOG17Td1nSMVNMxUk3HSDUdI9V0jFTTtb6azkFqutZX07W+2tPf9DQOPY3DsZ3owcd9yfi3x3YSfMwnubgklsRRf35cpR/zRsqcMt6PeSMX98QDPo49Tj7q92BJrIktsSeuiVvinnjAR97O1831Yz7JxZJYE1vi49r4I7gl7okHfGyrJ5fEklgTW+LjmnwJrolb4p54wOc1+YNLYmHMj+18Pv7Rj9e0lfmyvX7OFTn4OM6Zj/r0c67IyZL4WP7YHo7jnJM9cU3c0r/tiQdck7cmb03eI9tPTr+lpt9S029pqWZLNVuq2dJvaem3tPRbWvotLf2Wln5LS7+lJ29P3p68Pf2Wnn5LT7+lp98yUs2Rao5Uc6TfMtJvGem3jPRbRvotI/2WwW8556KcXBJLYk3siWvilrgnPlxz+zznn5xcEktiTWyJPfHhrcFPVy3H/3ksnIlwYQFlYg9U0EAH68QR2MAOjoX6AAsooIIGOohNsSk2xWbYDJthM2yGzbAZthkNdb6gqsdMkjrfT9VjIsmFFWzgXLL5fqkek0hOnD1+YQEFVDBsGuhgBRvYwbGwPcCw6f/+7x9++8vf/vWP//jz3/76z//4+5/+9Ns//c/6P/zXb//0f/7nt//849//9Nd//PZPf/3vv/zlD7/9P3/8y3/HH/3Xf/7xr/Hff/zx78//73M8/vTXf3v+91nw3//8lz9N+t8/8K8fr//peMwvEMa/Hs+bmKvA8wbWDyXK6xI2Zy9FheeZ6yrQfvz38vrfq1/L/7xywgJ0uf8b+lVhPC8kvfwNtlkGnbezj4V4XntIJcrdEs/bENdIPtFXiTF+qFBfV6hztxgFak0DMeRugTbnj0SBZ+asAs9rYj8U6JvfUOfMoOM3PA9lXpYYr0sIK0OedyBfliibFfq8k3EN5fOGxXhZY7M2ngezV4n5blhGU35cHWWzYToltLxcH7uFaGvTni9vfb0Quy2zzvcMHlvmzIzVX+3HEr5ZqzbnQxxr9XmR5GWJ7VJYWUth9VWJTYU5Jf+sMGdavx6LzeZZ41NYR43HI9Xw+mONzfb5vEuwOv1RX/6S3WK0x+qz+W6Xl4sh5fddDLGrWedrEV4vhm42jVZkNXyj4euPsSebFRvfrT3Ct6eFaON+hdVn86War0vUXWIYiZHGwn76HW0zFPECynMx8p7w58XYrJLn5ZWrxvxofVoM/7HGZgOt8SLtIzQeKUB/rqG7ALWr1543HFMF+dqGMV5uGPvts61ufd5zfN2tuxperwSdzxK9rKG2G4zVJ/K8lvoyyLfLUfktdejr5ajvx/DNxXhe7vjakDaxVWOTXjrePOSzx7vHfPufMa6jpfkkwsufYduR6IxEeblLMn1792z29naxX4p3d8/P00q9jh2fN+Jej0XbHUT3wUF0OubSnw6i+9s7JBvv7pC2Fe7tkLy8vUNyeX+H5Pr+Dsnt/R2S+7s7pNsbxusd0u3tU/z19rmtoUaN9rKGj7d/yq6EtmYEaHt5slneP9er8v7JXtVvONnbrZW2Tp31eV3t5Vqpvjt57uvs+fHDvtV+rFHfTq/a3k2vbYV76VXH2+nVHu+nVyvvp1eT99Or6bvpdXvDeN3yu+2zx4v5z+0zD+jP2+euho9rMZ6XMV/XaO3WdS55POz1dardcrS+luN5mf31crx/Ir+LjecavIbUfjiR/yk2enn/6G27GOsExUp7fdzU3z+R72+fyPf3T+T7+yfy/RtO5Ps3nMj3bziRH2+fyPf3T+Rvt0mrXzpusnj286ghm3OD8f6l0PH+pdDxu14KnbM3rvRrj9eXhcd2Ax3r0nL54eLfjwk6dsehZR3LlufYvkzy3XLM721fy2Hj9XLE6xvejPLtcvi6jzU/wLlZDn1/ObZbR61r60gt+6kSnRLDXl4nemxj9KErRk2+WGNtps8D8/66xu6s7Wm4fsx8/YS+TMF4l8XrMuKUeV5XfF1md1/JV3642Ms0LaW8G8h3lyLdVvqlxH489LFS/dnFfTMeuyDq7RrVPjQPqv5UZBupsq7EFdNim2XZbW117XGlpi22fmZJvLEkPnyzJLttVpquWHzstpPby1LLblm2Zaqyw6o6vlqm0z/Wq369jFNmyJfLqFLGN1vM7rZR0b5GWId+bT3dPUgr27tP90JhW2KdmMn2p2y32562W/3qdls9bbfVvrqK22MdW9jzNvjrMlq+Ye2ovL12tiVurp39wLJ6rO32hLrbXtuK7Pmd0lcxuS3RZR2ydRtfK9H6KtFeltjvwmxds5sTAMtmPHZ3ovQ6GP+xxGcOUZ57UA5RpL5eENtfByBh2+u9xgdHfpxajNdHXLtbQWlvbCry8kSr7G5JSVu7QGm9vLz7a/72FYmYF/neJYl9iXvXJMru3sPNixJld0/p7lWJeEfJu5clin9HqPr7oXp7A9lMMdhvqGtW0XND1a/V6L2vdH88Xtbw3dQ9XzdCqqdzts/V8HGnxv63rBvrz33W5re8ff90X+Ju093+Ka83j939qbFOtYZs2nYXp7qS0FxtE6fbIrou8Kq/voAW705685Zf2d6GuHnPr+zuL92e4Vn7+3f99uPaV8f4o2zGdXej6t42sqtwd83sblPdXjPb+1R310yz33nN+MMea83stvhWf8/udVknmv68mrVZjM2mqlLWtAFRf3Wwuy+xrtaqpomrP8/aety8CK8vD7m3o0EM+TPWXo9G3+346zq+lHyMWu+XeB6vrR3/s29XibmG7hfxdYXzeaAiXyxiMiiimyK7U/dHW2d2Tx71S+umjrVuuj4266bvtpE1LU/Tj3leHvyxxHj7Mtx2KVbrWzo0/GUpxu5k6sFp7vzywsvz3H2Rng5DRrqS95kfs5bDH5sh3Z3VzQ9idH6Mv+zdD4rcHBH7hhHZbqm9rnP/ZzR+7Yio2mqZ552bxxeL9BUBz2srXzw2q+1x7WXqKK93EbK7gXUvnLclbh5EyO7+1d2DCHnY+wcR8vDf+SCiDi5UDd+tmt1sgPnlrzUoJvZy5WwfPFkzB+dHrTZLsp2zV9dxxA+b60+3KGV38+h5irCuwD9vdL66RCRl+8DeugBg0trL2z6yezjqeQDBr3n0TZHtBqsE0vO++uuLEbJ/OonZ5PnKW/3MksQDz+eSlKabJdkdstY1tKOW15cSP9hktZW1yWq+/na/eeZnRq5Ntm0SVrYPS5V1V11LOsj6+fEgebx9HVB2T0vdfMZoW+LmQ0aib18HlO1dq7uPGYm/fx1Qdrec7l4HlN1TUzefNLq9gby+DvjBhsqknFL1azXcrwMb9TTN6XM11lS+r9doKc7q+GINWxOifzji/KnG7rmpm9c0P6hx65rm/rd0WdO+urX3a3j5Wo26jsC178Zjdxegrwe4nkfqm+7fLYiVdfBsJc1y+OWhzfL+yt3XeH/lWtzSPo9F/PF6OXaRKr4uBUgKkM8Nqqyue57AbgZ1k6i2JllY26zb7ZMMj3Wr+bnz3RyF2PZy01oQldo3RXZXAnSdBri8Pqjajsc6HXF7vB6Pjw7fJR2+P14dvu9uVt08PdsdH37L4a7X9Vu8biZKyfZRqnvrZX8S0TklSg9CfeY+c/V16azWzaRg8d1dgHUEkucEm3zmksZQrosM61+7LsKLBeaH0l5uIfXtawAfLYdo+jHja5e97v4Ye//HlPd/zP6Zl3Xe3UvZnDJv71fdm8wg9f3HUqW+fV91X+LmSUx7/8lUad/waKq0b3g2Vdo3PJwq7e2nU+9vIJuTmP2Gemsyw77GvckMsnuy6u6x4b7GvWPD/W+5NZlBurzddNsSd19PcvunvN48ur95O3SbproqdPvhzQ8/penu6arnlfs1AdHT3VD1/lORTbcMXRfdh6a7TL8W2YXhY72yYDxvZrwusnvASlcNTdvHM4R/KlG2t8y4I5pG5FNFdHClLe8rfy2ymw8R0xTOk6n8EEz/zIKsa49PfL0g2w3NnA2ty+sNbdT3r3SP9g1XunePFt0+9N89a3X30F8fj7cP/fejeuvQf/8Q8bp9P99v/XLt7l9YcusxqX2JW49J6f421a3HpD6ocesxKd2e5T4enQOqUsbLjUx3t6nuPs+j24nZt5/n0e07/G5NJPhgSe4+z6O7O1V3n+f5xLLsnuf5oMzd53k+KHP3eZ4Py9x7nuejMjef59Ht8ys3n+fZLsvtFtjdkbj9CjZ5+0nBfYlbj51sf8onunl31+pmN++X5HY37+5a3X3K6YMiNyPh/g/aRsK+zO1I2Je5HQkflbkZCR+UuRsJqt8RCduda+FJo+cZ3ON1KOj+1QG3HvD54JjlzgM+qtt3Hd2aKLSt0do6p52fYOUQ7qc3EHy04d58VPCDMncfFVT7hqda1N5+qmVf4jsy++6jgmpvPyq4L3HrUcEPStx5VPCjg6a7G9q+zO0Nzb/j4MDfPzjw9w8OPhjYuxva9gWB9za0bYl7G9q+xK1nUrdXpdYtraF5DrZ/psbaCw9t7WUN9fH+aem+xr3T0u0rAm+/vUN3T2Hdf3uH7l4UeO/tHVrt7ba7uRSbt3d8MB53396hu2vKt091dvctbqfZ9nWBN4e1f8t5Sitvn6fsl+T2ecru7tbtU4z7y7I9xdiXuX2KsS9z+xTjozI3TzE+KHP3FGN3o+r2Kca2Ae7tiz9YR3cPcvZlbh/k7N4adzsW+vtpuy3xLQN79yBne9/r3kHOtsS9g5x9iVtH0/u9z90Xb+juPtGtF298cHRx98Uburvpdfe8fHvUxjMiTxyvj9p27xa8Oc9Ex/svENbx9huE9yXu3fLW8f47hO3xDS8Rtsc3vEU4Jhq+G4j2ePs9wvc3kLHZQPzteSb7GvfmmdjuwtzNeSYf1Lg1z+SD33JrnomVx7tNty9xt+lu/5TXb3vdzVK999j9Lk25QTzq5tMc2xp1hemoY3ytRuPbdk1efy3Fyu5y671HoKx8w0ctyvtftSjvzx40eX/2oMk3zB40+YbZgybfMHvQ5P1vW5T3Zw9+sKHeegRqX+PeI1Af1Lj1CNS+xr1HoD6ocesRKNu99+/uHmpf49Yeav9b7j0Cdb/G60eg9jXuPQJlu3tPdx+B2i7IzUegTMc3rNzx+67cm49AmW3nuNx7BGq/IPcegbLds1j3HoGy3R2ju49A2e7Ro7uPQNnuYax78+3243HrEajtvuHBN/Ce3DbHMf72a672y9F5jUndnCXb9qtW96Z1mm/nua4DzGf3v76fb7v7RYWnZFxfr9ztctycXmp+d0JLKZsl2W3uN+eo2u5prLtzVLdF7r9Iwepuc/Wxjv9zsH5yWe6+XsJ2V8zuvV5iXyIdE41NCftdS9zMs7p/K+NVotfNtvoN86mtfse2urtsf3dIx/tDOt4e0vp7D+knOnf3RNbtzq3f07m7Nwje7NxtiXvbyPbtf++XuLmZbUvc7Nz9u6WvGqa7zWz7zr3b+7vtUcStxxj2G+rNd/XcL6Kbltm9QfB2mO1uDd3cyvr7x7u9vR9mj29YL7eL7NbLkG9YL7v7UzfXy67EzfWyLXFrvWw/uKyP64yqaXn93Wgb7z+LbeM7PhH8/tXU8Q0fCX58w1eCH9/xmeDHd3wn+PEdHwp+vH81dXzD1dTx/rPY+xr37pH54/2LVB/UuHeRarz/LLaXt5/F3pe4eQvj/k95/fnl8u6z2Ps05dvzWl/PNfXdBbub11J8tyBua2qY267zyzc83ery9tOtHwzIvRfbbFdMZ8X0zY3H9z8CWN7/CKDL+0+3flDj1jRil295utXlG55ujRcTvVyW2/NMXd9+uvWDJbk7z9T1G55u/cSy7OaZflDm7jzTD8rcnWf6YZl780w/KnNznqnrNzzdul2W2y1g3/AAi9vbD7DsS9ya27n9KZ/oZnv76dYPluR2N9s3PN36QZGbkXD/B20jwb7l6dYPytyOhI/K3IwE+5anW931OyLhW55udf+Gp1vL+5+vc9/PkV7nO91ffxt7W6Q91t3w9kizpH8tsrs5cOuzLx+UuPPZF3//rYL7IR3rqm3bPezrVd9ejrp9heatB5d99+6Zu1848Lr9YMu9Lxz49o1eN79wsN9QZfVue15m2KyasSuybrg0Txf3PlXk7jd5vG1nWq/nG9L0EfFyv0Rd74ysMl6X2P6Um18G+mA87n0ZyLfvFbz5ZaAPtpGbq3c7rCsQa9Uvrhnjfa/21RIr262+LrHfP/D1mVE3Ydbf/9bKvsbjsaYX5qPoX2psnxHkcpamp0l/yZD+Dd9r8f4N32v56Fjv5iNsH5S5+wib9294stX720+27kt8x2nO3UfYfHc7694jbPsStx5h+6DEnUfYPrrOcHdDk295IYTvriff3tB29yxubmjbEvc2NPmWF0LU3W2texvavsStDe2DEnc2tN1Fvgf3gMojf1/scbtEWTdNpfzw4ajbJcqQFc3F/WWJ+mhv7632Ne7tNev2jSM3j9/r9tWCN/d4tZT393jbldtXCdXX20ctN+/tp+yQ+xVU16G7Wv6C3eOnVwOX7aHqjTfx7z5POtZ3Ekt5eWh3r4B8qcC9k4/Hu6cej3cPsh/vHmI/3j3A3rbWunX+PGHJX3X48d2udfuJq9bXzc0np/ebFK2fKNNLWZ9B60V8U2b3EZI7D6p/8HvGOuko/ZHuX/26ILv9860v525L3D1L3xe5eX78wZLcOz+uu3tXd8+PP9hMHutBryfX8nrt7L5Ude9y3wcl7lzuq1rfvcz2Yfc5beNtMx67Sau++kbd/GXj7J6Outd626WwleqaN/ifa+zuM5XuHOY/L9ZvBmT7Yr/Cnrrk17z7+GqR8Q1FzL5axMsqkuaO/FpkdyU1ZredRy95kvbj54HdHVcOvos60pzAX4vsT37WAcww/WoRjglHngvzuSLGktTHdxTxTZHd2mEOieTn338psrtJ5W1dfnxeD7OvrWKrbU0cb0W/WORRriywh44vjomvje25pe/GZLck/bGe2OxlfHFgebGA57OYTxV5HvCtc1yzxzf8HNmt4tt5sgml3WNSN+fD1rr9SOuabPQ8t2qbBdnsRJuP69e0PKGt/PSZhN29qufJWOG8LB00/jSqu1tVz/N25bzdXtfY3SEuj3Xi/uQfng7+xLBqY1jbbqdzf1fs9fWuuD3ePzZp776/ar8UN49Ntm8J7JWvk/fqthmQ3TEfDzoVK+l86+drMx8sy1jH9D1fnfl1WbZfGFGu8TwPD18e1Lfd3dVbM3I+WA7rzI618fKQfjsmo6wvFT3ZNhts313DizeLnzd6PJ9y/XRVtb/9bssPlmN9IKho3yzHfkxkXZt9ct+cDu/uW7muq3jPHn5sivjumGBdaX6m7WaL3T1+VTrTU0dakvHTNY/dc093v2hVt5/FuvlFq9q3D7WuPcbmi1Z17Ge33vqi1bbI3S9a1bH9cuutL1p9sCA3v2i13dCKsaGNzTWG3du57m5ouxfA3d7Qtu/3u7uhbb+LdXNDG9+xoY33N7T2KN+woY3fe0PjhoDJ5lpF2z2J5bJufT3v9708fG2P7ecDmInX8o6vfebHrEMk04dtfkz7hh/Tf+cfo+vk5In+xR0Wh9GWD6M/t+u0dfvb3V6HUds9SmVj3Sx43nvRrxZZN52f+MUizhOMT/xykfVU1xNlc+y6PbTR9RK1yeOrZSwdNVrRr5bxdWI++ctLUwtlan99DNvk7ftr2xL37rBtf8zzBpWthyqf203f/JjdmGhZ18aKyuPVHIX2/kexPlgO4R3Iz/sO9rLI7pCg8Pbiku6+1s8Mq3D55qHy2Azr/h1R6dPj+RlP++qymG4CQd8/PW+6O+V62Lqn++SxaZ3tfa7nEQVP0T02Z0wflCnrsdMnb26ItvfvdLX373S19+90fWY81L8+rFx1LLv96Qdl1inCkzfXttpurt/NtbMvcWvtmPzeayePR61fXzuayrSv7QR/DBWXTQvubh8YDxhbe8jLUNm+VfDhPID++OEFyV//RVVl84u2r2nvg8vl+vIX7d4teOta6gdLcevCf/PtbILBuM63YrwekO19mXvHOdu7MreOc/Y/Ju1Knx1QNsc525cLjqKWrl+2V528L8JD4JP720cYRWxzMrh9pOrepf9W395ct0tx89hie6/ruQPvzAUom93O7r7M9x9yFRubdNze8bq7ct6drrVfirsrp+/vZrJyfHd6vH21X1l3VOYhQYqCrxaRxxeLtEeaC7Ap0uTtdbPP+TWs8sNd4s/8FmXdqG5Gdfts1r2Tt/1yrMsworV98cf8MCHhq5tIXff/pLbNsLZ3Z2ttp0OvAqI/RMiPSdR2N7k8DgaPyzijvp6AulsOY836DycFPy+H/s5Fbs66b7sLhnefEWv9G554bf0bnnjdv+JH6VzbjOr23W033r203chUVuPOc6XXi7H7ANa9xdhVcO79e34zwjyT/bGIvr+3G9sXt62rnvXxw/VB/0QR7qA8rzeWTZH69tnvvsSts9/dna2bZ78312398Srlj6PRH+9fwurbp6D4MsDzZGS3IJsdfyvrXsETd0U2W+rNOVX9sX0J9q05Vf2x/b7ArTlV/bE7Jbo7p+qDYV13T57HZPbFdSNKkR8OVD9XZK0b6e3LRdZWIsM3CXCzcTQ/zfTzkhR5+6JG3z1Wdetw6IOluHVRo++ey6q6Zs4+j1LHZjjq71zk7rMnffd2vXtPOH1Q4s4zTvufcvMJmA/G494TMF2+4QmY/THzWCeItZTXhzN9dzPrW4rcPODtUt8/4O3S3j/g7dsHtm4e8O6PNek9/eF9kj+Pq7778Zb9YnBHWs3saydnz7vHXExMTyX8vHr13Vjd/xSXNPHINiO6ydW+XlU1fji7059KbL8MsDYPtZaK2GeKjPWopObnVn4t0t89av6gxJ2j5r677XTvqHk7GvZY93rskY+afx6N3b2rm6OxL3FvNOz3HY3y4DNHeXLrL6NR3x+N+v5ovH9GtW378WCaX37P+WcSzGS9mdf0Ub9YhHdyW/5AwecudPG8jJf2xZ/jYx1x+/DNhYzdBznu7rT9G65Sdf+Gq1Tdv+Eq1X5cKeLS9fUuxn/X61Q2nLcq/HBW9tNi1HevU20r3N1Atrep7m4g9RteddXrN7zqansU09aljJ4C4Nfl2L6r/N6rUPr2PtXtERm/c8uYrgl15nVz/rB9gWBtXDRLJX46o9rdo9KepqXnh99/3uLb2+f++8UYPNRsu8XYXamq62JX+hpX/8RiGM9imea5078sRnv7EGK7HLZeSfw8ah6b5djdoOJDmM/97heL3L6M0d9+F+IHJW5dxmjf8KLLD8bj5mWM/g0vutw2f+9826P7pvvL9rrsmuos+fXBPxfZPYb1LUXu7jR3Ty7d3mmO8g27iCHfsNPcrRw+y5PfRvDLqO5uMt07mNluZWsCQm+PzULszsvW53QsvbO3f2IheJNab5vta/uRo85bb0aaI91+3r52vX9z9vl4bK9NyfqsT/FXEyn2v2Wsz1eWkR5L/em3jP1nsBovmn/88MH3TxVZz5M++eWrCz8o0tNXisbDvjIkQnzII+XpL0Oyu5L6KHwf6FHSm5F+fs7vozIpmUua2fHpMmtje0h6KOaTZURZRVJfP7w4du8QLNwEfCKrSH8e4H2R9cBfybP69XNriWsST25fHl4VPhOuKl8uk1a2phvGvw6v/+5lpKyDeflh+/1lLe1P+JiHnq7Tfq6IMXPFttvLrojyilZ7vF6SvpuG47SRSz6U9h9PtIbsjpPufTls7O5d3f36+dg9AHX3y8Vje9vpO4rc//zx2D6MdfPrpR8sy93PH4/dDax7nz/eLsndL7sNffvLbh9ssLe+7PZRtvHa6EeesflLKO2u/dw7Hf6gxJ0r6kP93SvqH42HsRPU9MTSr7uM7fHOSHvkYf1rB00jz2OvL3/Q9n2DN8dkvxyi6cd86VbFc1+xXqgl9voGwdjdgyo9vSrph5mw5aciuw2ts632/Hy22f0i1h68vS0/GvpLEX+7a7bL0dccduvpJcG/Lkf7fZeDF07YyNNpflmO8bsuhz/yO5Pt9XL49lbHeluo//DA+2eK3L2oti9y83LWB0ty73LW8G+4nLVvvXy/Mj+/9cvAtjcvRG9jRIyHWz1/C0s/U6SuaZfSfphj+FOR+vidi9y8rDaqvH9ZbWzfh3fzstrY3tC6eVltv3JK4xsDP8xm/3lc65sX1sbudmcZnMaO9vIr06O+/2n3Ud/+tPu+xL2vTI/2/qfdR/uGT7uPtn2e9d6n3Uf7hk+7j/b2p93vbyCvP+2+3VCFuc7PlfTy0+6j7Sah3vuk+n45SuXxsfJ6OXYv9LN1acPaZvvYT4m5eRq/nUNy9wy86+9c5BOn8bs7WrdP4/fLcvs0fnfF5+Zp/LbEumGpP0TAzyXG2yfx26113Yz29K7iX7bWbdMwzeCH63Cfarx8SJRi9ecau8eubjbe2E6WXlcDtZTNdjq2p1W8PF26fLXI+jXPen1TpL29fWwH9db2sZ9Pq7LmTOTXEn5uUq4yeeOHt3f9VOR55+DdNwx/MAF08C7A6rvl0PfP8PZV7p7ifVDl5jneR8ty7ySvPB7t/bO87Tzy8qh8ie6HdzjoJ4oYL+nw/BlY/Xk9b+9GfUuVmydY5VG+4QyrPMo3nGLN+5zfMHVhv5qNm2s/vKX7l7F99ySrPHYfULu9eh7bI2B2gD++7EM/U8X5Zphr/WIVLZ0d2A/vnftUFVknOfrjW1M/VeXBl9Sklk2V7Tv9mvFO92by6v7/vsrNr+09i3zD57LnPejv6EP5honZH27/D7Z//+qm29ecFX3orgG2bxi8u4r0O/JWvyVv9VvyVu13X8/C2Mo2onYHUPdbUdv2mHI9o1V1t81tn7BqHKn3/O4L//kwTMfbN+6P/dW7p/zlYeX90/VnFfmOc+Ty2F5uv3WS/NGy3L128KzzDRcPPtp4lelFTXt5vfF+0AKSWuDxssr7z2/tR/d7tpe7ExLmBdN3T1Y/asVbUxL2L26y9WGQ5/XifFb1mbc/EXLPIvKyyHNItq/FqOwTR/1qlcIhVNm84OuDKpzgqemX36zF/Sb/4T2MvyzK209x7VcP72/LH8n7dTnq29/U/qDGrY9qf1Tjzle1P9pIBtebHl/f1NalwGdB343r28/HflTjznSeZ41vSNjtiHCl5/lbvjyuQk6LfzlO8rK8UaVSpemXq4zO+vn6sozyDVV0zXNSrV/+Rdr5Rf11tn30XteWP+T08nVb23fd3vro9b7EraepPihx52mqD96i7yvpS339QYBtiTuPQuw/kXBvLOTtj4B/8DENvs31w0tlP/dFjnVp1B+tfbFIUR6BNvlqkZWtXuyrHxgp69az7z81tpu1aXz+xVr/hiJdvljE13UHcylfXZLBQ78P++qSGDdK7KsD606R+tWP8/g6Gn8uyW7tbC/DryPG5wabD0t+PkEZb7/S5aMatw5LyuPtl7rcHxB7vB6QspuYe/MrUM8iu93E3c9AbX8OL0GyWl/+nA+KrPcPFRvlq0VGuiW3Hdj69onFvsa9E4sPatw5sfjgk5/OTPTq/vJyXynl7U3+owUpaUFe917ZfpC18bnO55C8fit7Kfs7YLXx1u22+cJWKfsHqZQXkadZDz99vvCjIlyseC7Lpsju+4VSlbPy1881zg8nbCJlfR/W8wNqo39mSW5+jrGU3SHb3e8xPqts3/F254OMzxrbmb73vsi4r3L3k4zPKttXaN36JuNHi3Lvo4wftlAdd1toW4f3mz/ZdnV2T3bdfJfus8j2Kxa3Xqb7zKj9/as7b9MtRfevbbj5ifIPUrdwK8HlVeq+fbiz2ydz6f95JTTdcf1pEtO2BN8gzCeBnynReYy9t68tBe8DlUd6XcMnSggngE/sX1qKtq5zlP742g/pPNDV9Us/5Jm6azjzHIXPlNB0wPf4WglbpwTPk1j5WgmOj8zG10qsU76SZ+n9XKKU7Xe07kX7LnfSy5E0HYzYo94vwdST/HKkL5foXyphjzTZ8PGlEr52Kk/Ur5Xgvo3Xr/0Q5sQ/j1v8SyX4UqlW+9Iaed4JSO+orS9LPA9Sty8hNl4BVF+eKG6Xo3NtdXxptT6PlNdc50dqkk+VWFfh5aH1iyWYJant7RL21aVYx035UZhPlXDGIk+V/uJS9C812s1X05fy9keytgtx6+Gk50JsP/Z67+mkZ5XdXfTHo1OmlPF6XkDsM17V6Rzy9KGyq7J9fNS5JWL5e0y/zC8o2ye3pPFipUeepSBfXppatkvzwUOx1NHdrIny/jezPlqWynuaLH/25rO/qTvHMr3qG3W4PNmHfL2OKnV8N8Z9f6C4VpUO/eKWM9hwxnO8N92we6rr7lN/pew/pXXnsb8PavDinC+PySd+Tf2GX1N/319jtt7/ZuZ992vGN/ya8f/jr/lhSfxT+5KivOCl+GOz3Y/t8yVGtLSvp3f1lN7VvpwsjTeBWPPdlrt7beH97X/7mNfNLWZb4xu2mOeI8jq55wht8l92N7hu3v7Y17h3++ODGi9vf/zf5//yx3/989//+S9/+9c//uPPf/vrfz3/3f/OUn//8x//5S9/Ov/Xf//vv/5r+v/+4//9z+v/8y9///Nf/vLn//jn//z73/71T//233//06w0/3+/Pc7/8X9kfixTngPwf//wW3n+730uTu/j8fzf9fm/qz+v1D5PLm3+/8vxD+T5D5r93/+dS/j/AQ==",
       "is_unconstrained": true,
       "name": "sync_state"
     }
   ],
   "name": "PublicChecks",
-  "noir_version": "1.0.0-beta.20+ad02a20cd80b3e8a6189722b11a625998e578435",
+  "noir_version": "1.0.0-beta.20+f39ac4f5748a1ea5dc7bcb8eb5b2c2a8032a2199",
   "outputs": {
     "globals": {},
     "structs": {