@aztec-labs/accounts 6.0.0-rc.3 → 6.0.0

package/artifacts/SimulatedSchnorrAccount.json

@@ -18,7 +18,7 @@
       "path": "std/aes128.nr",
       "source": "// docs:start:aes128\n/// Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.\npub fn aes128_encrypt<let N: u32>(\n    input: [u8; N],\n    iv: [u8; 16],\n    key: [u8; 16],\n) -> [u8; N + 16 - N % 16] {\n    let padding_length = (16 - N % 16) as u8;\n    let mut padded_input: [u8; N + 16 - N % 16] = [0; N + 16 - N % 16];\n    for i in 0..N {\n        padded_input[i] = input[i];\n    }\n    for i in N..N + 16 - N % 16 {\n        padded_input[i] = padding_length;\n    }\n    let output = aes128_encrypt_padded_input(padded_input, iv, key);\n    output\n}\n\n#[foreign(aes128_encrypt)]\nfn aes128_encrypt_padded_input<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8; N] {}\n\n// docs:end:aes128\n\nmod tests {\n    use super::aes128_encrypt;\n\n    #[test]\n    fn encrypt() {\n        let input = \"kevlovesrust\".as_bytes();\n        let iv = \"0000000000000000\".as_bytes();\n        let key = \"0000000000000000\".as_bytes();\n        let output = [244, 14, 126, 172, 171, 40, 208, 186, 173, 184, 226, 105, 238, 122, 205, 191];\n        assert_eq(aes128_encrypt(input, iv, key), output);\n    }\n}\n"
     },
-    "100": {
+    "101": {
       "function_locations": [
         {
           "name": "get_nhk_app",
@@ -44,7 +44,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr",
       "source": "use crate::{\n    keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n    oracle::{\n        key_validation_request::get_key_validation_request,\n        keys::{get_public_keys_and_partial_address, try_get_public_keys_and_partial_address},\n    },\n};\nuse crate::protocol::{address::AztecAddress, public_keys::PublicKeys};\n\npub unconstrained fn get_nhk_app(npk_m_hash: Field) -> Field {\n    get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used in\n// unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n    get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all keys at once\n// since the constraints for reading them all are actually fewer than if we read them one at a time - any read keys\n// that are not required by the caller can simply be discarded.\n// Fails if the public keys are not registered\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n    // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n    let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n    assert_eq(account, AztecAddress::compute(public_keys, partial_address), \"Invalid public keys hint for address\");\n\n    public_keys\n}\n\n/// Returns all public keys for a given account, or `None` if the public keys are not registered in the PXE.\npub unconstrained fn try_get_public_keys(account: AztecAddress) -> Option<PublicKeys> {\n    try_get_public_keys_and_partial_address(account).map(|(public_keys, _)| public_keys)\n}\n\nmod test {\n    use super::get_public_keys;\n\n    use crate::protocol::{address::PartialAddress, point::EmbeddedCurvePoint, public_keys::{IvpkM, PublicKeys}};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use std::test::OracleMock;\n\n    #[test(should_fail_with = \"Invalid public keys hint for address\")]\n    unconstrained fn get_public_keys_fails_with_bad_hint() {\n        let mut env = TestEnvironment::new();\n        let account = env.create_light_account();\n\n        // Instead of querying for some unknown account, which would result in the oracle erroring out, we mock a bad\n        // oracle response to check that the circuit properly checks the address derivation. The values below are\n        // arbitrary; `ivpk_m` does not have to be on-curve to make this test fail.\n        let public_keys = PublicKeys {\n            npk_m_hash: 0x292364b852c6c6f01472951e76a39cbcf074591fd0e063a81965e7b51ad868a5,\n            ivpk_m: IvpkM {\n                inner: EmbeddedCurvePoint {\n                    x: 0x173c5229a00c5425255680dd6edc27e278c48883991f348fe6985de43b4ec25f,\n                    y: 0x1698608e23b5f6c2f43c49a559108bb64e2247b8fc2da842296a416817f40b7f,\n                },\n            },\n            ovpk_m_hash: 0x1bad2f7d1ad960a1bd0fe4d2c8d17f5ab4a86ef8b103e0a9e7f67ec0d3b4795e,\n            tpk_m_hash: 0x05e3bd9cfe6b47daa139613619cf7d7fd8bb0112b6f2908caa6d9b536ed948ed,\n            mspk_m_hash: 0x1a4f87ed20a8ce7e8d2b2c731f9b3d39f37e2d4ab2c6db66f7c8e3e9f1b6b39d,\n            fbpk_m_hash: 0x0fbb9c2bf6cb4d4a1d4ee2f8b3a2c5e3d4b9c1a8e5f2d6b7c8e3f4a5b6c7d8e9,\n        };\n        let partial_address = PartialAddress::from_field(\n            0x236703e2cb00a182e024e98e9f759231b556d25ff19f98896cebb69e9e678cc9,\n        );\n\n        let _ = OracleMock::mock(\"aztec_utl_getPublicKeysAndPartialAddress\").returns(Option::some((\n            public_keys, partial_address,\n        )));\n        let _ = get_public_keys(account);\n    }\n}\n"
     },
-    "103": {
+    "104": {
       "function_locations": [
         {
           "name": "log_prefix",
@@ -114,7 +114,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/logging.nr",
       "source": "// Not all log levels are currently used, but we provide the full set so that new call sites can use any level. Because\n// of that we tag all with `#[allow(dead_code)]` to prevent warnings.\n//\n// All wrappers resolve function paths at comptime via `resolve_fn` so that the emitted `Quoted` code works both inside\n// aztec-nr (where `crate::` = aztec) and inside macro-generated contract code (where `crate::` = the contract).\n\nuse std::meta::ctstring::AsCtString;\n\ncomptime fn log_prefix<let N: u32>(msg: str<N>) -> CtString {\n    \"[aztec-nr] \".as_ctstring().append_str(msg)\n}\n\n// --- No-args variants (direct call) ---\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_fatal_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::fatal_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_error_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::error_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_warn_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::warn_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_info_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::info_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_verbose_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::verbose_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_debug_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::debug_log });\n    quote { $f($msg) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_trace_log<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::trace_log });\n    quote { $f($msg) }\n}\n\n// --- Format variants (return lambda for runtime args) ---\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_fatal_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::fatal_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_error_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::error_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_warn_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::warn_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_info_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::info_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_verbose_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::verbose_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_debug_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::debug_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n#[allow(dead_code)]\npub(crate) comptime fn aztecnr_trace_log_format<let N: u32>(msg: str<N>) -> Quoted {\n    let msg = log_prefix(msg);\n    let f = resolve_fn(quote { crate::protocol::logging::trace_log_format });\n    quote { (|args| $f($msg, args)) }\n}\n\n// See module-level comment for why this is needed.\ncomptime fn resolve_fn(path: Quoted) -> TypedExpr {\n    path.as_expr().unwrap().resolve(Option::none())\n}\n"
     },
-    "105": {
+    "106": {
       "function_locations": [
         {
           "name": "generate_contract_library_methods_compute_note_hash_and_nullifier",
@@ -132,7 +132,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/macros/aztec/compute_note_hash_and_nullifier.nr",
       "source": "use crate::logging;\nuse crate::macros::{notes::NOTES, utils::get_trait_impl_method};\n\n/// Generates two contract library methods called `_compute_note_hash` and `_compute_note_nullifier`, plus a\n/// (deprecated) wrapper called `_compute_note_hash_and_nullifier`, which are used for note discovery (i.e. these are\n/// of the `aztec::messages::discovery::ComputeNoteHash` and `aztec::messages::discovery::ComputeNoteNullifier` types).\npub(crate) comptime fn generate_contract_library_methods_compute_note_hash_and_nullifier() -> Quoted {\n    let compute_note_hash = generate_contract_library_method_compute_note_hash();\n    let compute_note_nullifier = generate_contract_library_method_compute_note_nullifier();\n\n    quote {\n        $compute_note_hash\n        $compute_note_nullifier\n\n        /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash tree with `note_nonce`.\n        ///\n        /// This function is automatically injected by the `#[aztec]` macro.\n        #[contract_library_method]\n        #[allow(dead_code)]\n        unconstrained fn _compute_note_hash_and_nullifier(\n            packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n            owner: aztec::protocol::address::AztecAddress,\n            storage_slot: Field,\n            note_type_id: Field,\n            contract_address: aztec::protocol::address::AztecAddress,\n            randomness: Field,\n            note_nonce: Field,\n        ) -> Option<aztec::messages::discovery::NoteHashAndNullifier> {\n            _compute_note_hash(packed_note, owner, storage_slot, note_type_id, contract_address, randomness).map(|note_hash| {\n\n                let siloed_note_hash = aztec::protocol::hash::compute_siloed_note_hash(contract_address, note_hash);\n                let unique_note_hash = aztec::protocol::hash::compute_unique_note_hash(note_nonce, siloed_note_hash);\n                \n                let inner_nullifier = _compute_note_nullifier(unique_note_hash, packed_note, owner, storage_slot, note_type_id, contract_address, randomness);\n\n                aztec::messages::discovery::NoteHashAndNullifier {\n                    note_hash,\n                    inner_nullifier,\n                }\n            })\n        }\n    }\n}\n\ncomptime fn generate_contract_library_method_compute_note_hash() -> Quoted {\n    if NOTES.len() == 0 {\n        // Contracts with no notes still implement this function to avoid having special-casing. Since the contract\n        // declares no note types there is never a note to hash, so we return `Option::none()`. This will cause any\n        // messages related to (non-existing) notes to be simply skipped, mirroring the unknown-note-type branch of the\n        // with-notes implementation.\n        quote {\n            /// This contract does not use private notes, so this function always returns `Option::none()`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash(\n                _packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                _owner: aztec::protocol::address::AztecAddress,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                _randomness: Field,\n            ) -> Option<Field> {\n                Option::none()\n            }\n        }\n    } else {\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call the correct `unpack` method from the `Packable` trait to obtain the underlying\n        // note type, and compute the note hash (non-siloed).\n\n        // We resolve the log format calls here so that the resulting Quoted values can be spliced into the quote\n        // block below.\n        let warn_length_mismatch = logging::aztecnr_warn_log_format(\n            \"Packed note length mismatch for note type id {0}: expected {1} fields, got {2}. Skipping note.\",\n        );\n        let warn_unknown_note_type = logging::aztecnr_warn_log_format(\"Unknown note type id {0}. Skipping note.\");\n\n        let mut if_note_type_id_match_statements_list = @[];\n        for i in 0..NOTES.len() {\n            let typ = NOTES.get(i);\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol::traits::Packable },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret its raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = <$typ as $crate::protocol::traits::Packable>::N;\n                        let actual_len = packed_note.len();\n                        if actual_len != expected_len {\n                            $warn_length_mismatch([note_type_id, expected_len as Field, actual_len as Field]);\n                            Option::none()\n                        } else {\n                            let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                            Option::some($compute_note_hash(note, owner, storage_slot, randomness))\n                        }\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed).\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHash` type,\n            /// and so it can be used to call functions from that module such as `do_sync_state` and\n            /// `process_private_note_msg`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash(\n                packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                owner: aztec::protocol::address::AztecAddress,\n                storage_slot: Field,\n                note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                randomness: Field,\n            ) -> Option<Field> {\n                $if_note_type_id_match_statements\n                else {\n                    $warn_unknown_note_type([note_type_id]);\n                    Option::none()\n                }\n            }\n        }\n    }\n}\n\ncomptime fn generate_contract_library_method_compute_note_nullifier() -> Quoted {\n    if NOTES.len() == 0 {\n        // Contracts with no notes still implement this function to avoid having special-casing. Since the contract\n        // declares no note types there is never a note to nullify, so we return `Option::none()`. This will cause any\n        // messages related to (non-existing) notes to be simply skipped, mirroring the unknown-note-type branch of the\n        // with-notes implementation.\n        quote {\n            /// This contract does not use private notes, so this function always returns `Option::none()`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_nullifier(\n                _unique_note_hash: Field,\n                _packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                _owner: aztec::protocol::address::AztecAddress,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                _randomness: Field,\n            ) -> Option<Field> {\n                Option::none()\n            }\n        }\n    } else {\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call the correct `unpack` method from the `Packable` trait to obtain the underlying\n        // note type, and compute the inner nullifier (non-siloed).\n\n        // We resolve the log format calls here so that the resulting Quoted values can be spliced into the quote\n        // block below.\n        let warn_length_mismatch = logging::aztecnr_warn_log_format(\n            \"Packed note length mismatch for note type id {0}: expected {1} fields, got {2}. Skipping note.\",\n        );\n        let warn_unknown_note_type = logging::aztecnr_warn_log_format(\"Unknown note type id {0}. Skipping note.\");\n\n        let mut if_note_type_id_match_statements_list = @[];\n        for i in 0..NOTES.len() {\n            let typ = NOTES.get(i);\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol::traits::Packable },\n                quote { unpack },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret its raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = <$typ as $crate::protocol::traits::Packable>::N;\n                        let actual_len = packed_note.len();\n                        if actual_len != expected_len {\n                            $warn_length_mismatch([note_type_id, expected_len as Field, actual_len as Field]);\n                            Option::none()\n                        } else {\n                            let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                            // The message discovery process finds settled notes, that is, notes that were created in\n                            // prior transactions and are therefore already part of the note hash tree. The note hash\n                            // for nullification is hence the unique note hash.\n                            $compute_nullifier_unconstrained(note, owner, unique_note_hash)\n                        }\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Computes a note's inner nullifier (non-siloed) given its unique note hash, preimage and extra data.\n            ///\n            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteNullifier`\n            /// type, and so it can be used to call functions from that module such as `do_sync_state` and\n            /// `process_private_note_msg`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_nullifier(\n                unique_note_hash: Field,\n                packed_note: BoundedVec<Field, aztec::messages::logs::note::MAX_NOTE_PACKED_LEN>,\n                owner: aztec::protocol::address::AztecAddress,\n                _storage_slot: Field,\n                note_type_id: Field,\n                _contract_address: aztec::protocol::address::AztecAddress,\n                _randomness: Field,\n            ) -> Option<Field> {\n                $if_note_type_id_match_statements\n                else {\n                    $warn_unknown_note_type([note_type_id]);\n                    Option::none()\n                }\n            }\n        }\n    }\n}\n"
     },
-    "106": {
+    "107": {
       "function_locations": [
         {
           "name": "AztecConfig::new",
@@ -160,17 +160,17 @@
         },
         {
           "name": "generate_offchain_receive",
-          "start": 11291
+          "start": 11363
         },
         {
           "name": "check_each_fn_macroified",
-          "start": 12880
+          "start": 13024
         }
       ],
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
-      "source": "mod compute_note_hash_and_nullifier;\n\nuse crate::{\n    macros::{\n        calls_generation::{\n            external_functions::{generate_external_function_calls, generate_external_function_self_calls_structs},\n            internal_functions::generate_call_internal_struct,\n        },\n        dispatch::generate_public_dispatch,\n        emit_public_init_nullifier::generate_emit_public_init_nullifier,\n        internals_functions_generation::{create_fn_abi_exports, process_functions},\n        offchain_receive::{\n            OFFCHAIN_RECEIVE_FN_NAME, OFFCHAIN_RECEIVE_PARAM_NAME, offchain_receive_param_type,\n            OFFCHAIN_RECEIVE_RETURN_TYPE,\n        },\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{is_fn_contract_library_method, is_fn_external, is_fn_internal, is_fn_test, module_has_storage},\n    },\n    messages::discovery::{CustomMessageHandler, CustomSyncHandler},\n};\n\nuse compute_note_hash_and_nullifier::generate_contract_library_methods_compute_note_hash_and_nullifier;\n\n/// Configuration for the [`aztec`] macro.\n///\n/// This type lets users override different parts of the default aztec-nr contract behavior, such\n/// as message handling and state synchronization. These are advanced features that require careful\n/// understanding of the behavior of these systems.\n///\n/// ## Examples\n///\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyContract { ... }\n/// ```\npub struct AztecConfig {\n    custom_message_handler: Option<CustomMessageHandler>,\n    custom_sync_state: Option<CustomSyncHandler>,\n}\n\nimpl AztecConfig {\n    /// Creates a new `AztecConfig` with default values.\n    ///\n    /// Calling `new` is equivalent to invoking the [`aztec`] macro with no parameters. The different methods\n    /// (e.g. [`AztecConfig::custom_message_handler`]) can then be used to change the default behavior.\n    pub comptime fn new() -> Self {\n        Self { custom_message_handler: Option::none(), custom_sync_state: Option::none() }\n    }\n\n    /// Sets a handler for custom messages.\n    ///\n    /// This enables contracts to process non-standard messages (i.e. any with a message type that is not in\n    /// [`crate::messages::msg_type`]).\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomMessageHandler`] type signature.\n    pub comptime fn custom_message_handler(&mut self, handler: CustomMessageHandler) -> Self {\n        self.custom_message_handler = Option::some(handler);\n        *self\n    }\n\n    /// Overrides the default state synchronization logic.\n    ///\n    /// The generated `sync_state` function will call `handler` instead of\n    /// [`crate::messages::discovery::do_sync_state`]. The handler receives all of the same parameters, so it can\n    /// run custom logic (e.g. fetching and decrypting custom logs) before, after, or instead of calling\n    /// `do_sync_state`.\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomSyncHandler`] type signature.\n    pub comptime fn custom_sync_state(&mut self, handler: CustomSyncHandler) -> Self {\n        self.custom_sync_state = Option::some(handler);\n        *self\n    }\n}\n\n/// Enables aztec-nr features on a `contract`.\n///\n/// All aztec-nr contracts should have this macro invoked on them, as it is the one that processes all contract\n/// functions, notes, storage, generates interfaces for external calls, and creates the message processing\n/// boilerplate.\n///\n/// ## Examples\n///\n/// Most contracts can simply invoke the macro with no parameters, resulting in default aztec-nr behavior:\n/// ```noir\n/// #[aztec]\n/// contract MyContract { ... }\n/// ```\n///\n/// Advanced contracts can use [`AztecConfig`] to customize parts of its behavior, such as message\n/// processing.\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyAdvancedContract { ... }\n/// ```\n#[varargs]\npub comptime fn aztec(m: Module, args: [AztecConfig]) -> Quoted {\n    let num_args = args.len();\n    let config = if num_args == 0 {\n        AztecConfig::new()\n    } else if num_args == 1 {\n        args[0]\n    } else {\n        panic(f\"#[aztec] expects 0 or 1 arguments, got {num_args}\")\n    };\n\n    // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n    check_each_fn_macroified(m);\n\n    // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n    // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n    let functions = process_functions(m);\n\n    // We generate structs and their implementations necessary for convenient functions calls.\n    let interface = generate_contract_interface(m);\n    let self_call_structs = generate_external_function_self_calls_structs(m);\n    let call_internal_struct = generate_call_internal_struct(m);\n\n    // We generate ABI exports for all the external functions in the contract.\n    let fn_abi_exports = create_fn_abi_exports(m);\n\n    // We generate `_compute_note_hash`, `_compute_note_nullifier` (and the deprecated\n    // `_compute_note_hash_and_nullifier` wrapper) only if they are not already implemented.\n    // If they are implemented we just insert empty quotes.\n    let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n        // Note that we don't test for `_compute_note_hash` or `_compute_note_nullifier` in order to make this simpler\n        // - users must either implement all three or none.\n        // Down the line we'll remove this check and use `AztecConfig`.\n        f.name() == quote { _compute_note_hash_and_nullifier }\n    }) {\n        generate_contract_library_methods_compute_note_hash_and_nullifier()\n    } else {\n        quote {}\n    };\n    let process_custom_message_option = if config.custom_message_handler.is_some() {\n        let handler = config.custom_message_handler.unwrap();\n        quote { Option::some($handler) }\n    } else {\n        quote { Option::<aztec::messages::discovery::CustomMessageHandler>::none() }\n    };\n\n    let offchain_inbox_sync_option = quote {\n        Option::some(aztec::messages::processing::offchain::sync_inbox)\n    };\n\n    if m.functions().any(|f| f.name() == quote { sync_state }) {\n        panic(\n            \"User-defined 'sync_state' is not allowed. Use AztecConfig::custom_sync_state() to customize sync behavior.\",\n        );\n    }\n\n    let custom_sync_handler = if config.custom_sync_state.is_some() {\n        let handler = config.custom_sync_state.unwrap();\n        Option::some(quote { $handler })\n    } else {\n        Option::none()\n    };\n\n    let sync_state_fn_and_abi_export = generate_sync_state(\n        process_custom_message_option,\n        offchain_inbox_sync_option,\n        custom_sync_handler,\n    );\n\n    if m.functions().any(|f| f.name() == quote { offchain_receive }) {\n        panic(\n            \"User-defined 'offchain_receive' is not allowed. The function is auto-injected by the #[aztec] macro. See https://docs.aztec.network/errors/7\",\n        );\n    }\n    let offchain_receive_fn_and_abi_export = generate_offchain_receive();\n\n    let (has_public_init_nullifier_fn, emit_public_init_nullifier_fn_body) = generate_emit_public_init_nullifier(m);\n    let public_dispatch = generate_public_dispatch(m, has_public_init_nullifier_fn);\n\n    quote {\n        $interface\n        $self_call_structs\n        $call_internal_struct\n        $functions\n        $fn_abi_exports\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_state_fn_and_abi_export\n        $emit_public_init_nullifier_fn_body\n        $offchain_receive_fn_and_abi_export\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let calls = generate_external_function_calls(m);\n\n    let module_name = m.name();\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: aztec::protocol::address::AztecAddress\n        }\n\n        impl $module_name {\n            $calls\n\n            pub fn at(\n                addr: aztec::protocol::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates the `sync_state` utility function that performs message discovery.\ncomptime fn generate_sync_state(\n    process_custom_message_option: Quoted,\n    offchain_inbox_sync_option: Quoted,\n    custom_sync_handler: Option<Quoted>,\n) -> Quoted {\n    let body = if custom_sync_handler.is_some() {\n        let handler = custom_sync_handler.unwrap();\n        quote {\n            $handler(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    } else {\n        quote {\n            aztec::messages::discovery::do_sync_state(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    };\n\n    quote {\n        pub struct sync_state_parameters {\n            pub scope: aztec::protocol::address::AztecAddress,\n        }\n\n        #[abi(functions)]\n        pub struct sync_state_abi {\n            parameters: sync_state_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn sync_state(scope: aztec::protocol::address::AztecAddress) {\n            let address = aztec::context::UtilityContext::new().this_address();\n            $body\n        }\n    }\n}\n\n/// Generates an `offchain_receive` utility function that lets callers add messages to the offchain message inbox.\n///\n/// For more details, see `aztec::messages::processing::offchain::receive`.\ncomptime fn generate_offchain_receive() -> Quoted {\n    let param_type = offchain_receive_param_type(quote { aztec });\n    let parameters_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_parameters\".quoted_contents();\n    let abi_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_abi\".quoted_contents();\n\n    quote {\n        pub struct $parameters_struct_name {\n            pub $OFFCHAIN_RECEIVE_PARAM_NAME: $param_type,\n        }\n\n        #[abi(functions)]\n        pub struct $abi_struct_name {\n            parameters: $parameters_struct_name,\n        }\n\n        /// Receives offchain messages into this contract's offchain inbox for subsequent processing.\n        ///\n        /// Each message is routed to the inbox scoped to its `recipient` field.\n        ///\n        /// For more details, see `aztec::messages::processing::offchain::receive`.\n        ///\n        /// This function is automatically injected by the `#[aztec]` macro.\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn $OFFCHAIN_RECEIVE_FN_NAME($OFFCHAIN_RECEIVE_PARAM_NAME: $param_type) -> $OFFCHAIN_RECEIVE_RETURN_TYPE {\n            let address = aztec::context::UtilityContext::new().this_address();\n            aztec::messages::processing::offchain::receive(address, $OFFCHAIN_RECEIVE_PARAM_NAME);\n        }\n    }\n}\n\n/// Checks that all functions in the module have a context macro applied.\n///\n/// Non-macroified functions are not allowed in contracts. They must all be one of\n/// [`crate::macros::functions::external`], [`crate::macros::functions::internal`] or `test`.\ncomptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_external(f) & !is_fn_contract_library_method(f) & !is_fn_internal(f) & !is_fn_test(f) {\n            // We  don't suggest that #[contract_library_method] is allowed because we don't want to introduce another\n            // concept\n            panic(\n                f\"Function {name} must be marked as either #[external(...)], #[internal(...)], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "source": "mod compute_note_hash_and_nullifier;\n\nuse crate::{\n    macros::{\n        calls_generation::{\n            external_functions::{generate_external_function_calls, generate_external_function_self_calls_structs},\n            internal_functions::generate_call_internal_struct,\n        },\n        dispatch::generate_public_dispatch,\n        emit_public_init_nullifier::generate_emit_public_init_nullifier,\n        internals_functions_generation::{create_fn_abi_exports, process_functions},\n        offchain_receive::{\n            OFFCHAIN_RECEIVE_FN_NAME, OFFCHAIN_RECEIVE_PARAM_NAME, offchain_receive_param_type,\n            OFFCHAIN_RECEIVE_RETURN_TYPE,\n        },\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{is_fn_contract_library_method, is_fn_external, is_fn_internal, is_fn_test, module_has_storage},\n    },\n    messages::discovery::{CustomMessageHandler, CustomSyncHandler},\n};\n\nuse compute_note_hash_and_nullifier::generate_contract_library_methods_compute_note_hash_and_nullifier;\n\n/// Configuration for the [`aztec`] macro.\n///\n/// This type lets users override different parts of the default aztec-nr contract behavior, such\n/// as message handling and state synchronization. These are advanced features that require careful\n/// understanding of the behavior of these systems.\n///\n/// ## Examples\n///\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyContract { ... }\n/// ```\npub struct AztecConfig {\n    custom_message_handler: Option<CustomMessageHandler>,\n    custom_sync_state: Option<CustomSyncHandler>,\n}\n\nimpl AztecConfig {\n    /// Creates a new `AztecConfig` with default values.\n    ///\n    /// Calling `new` is equivalent to invoking the [`aztec`] macro with no parameters. The different methods\n    /// (e.g. [`AztecConfig::custom_message_handler`]) can then be used to change the default behavior.\n    pub comptime fn new() -> Self {\n        Self { custom_message_handler: Option::none(), custom_sync_state: Option::none() }\n    }\n\n    /// Sets a handler for custom messages.\n    ///\n    /// This enables contracts to process non-standard messages (i.e. any with a message type that is not in\n    /// [`crate::messages::msg_type`]).\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomMessageHandler`] type signature.\n    pub comptime fn custom_message_handler(&mut self, handler: CustomMessageHandler) -> Self {\n        self.custom_message_handler = Option::some(handler);\n        *self\n    }\n\n    /// Overrides the default state synchronization logic.\n    ///\n    /// The generated `sync_state` function will call `handler` instead of\n    /// [`crate::messages::discovery::do_sync_state`]. The handler receives all of the same parameters, so it can\n    /// run custom logic (e.g. fetching and decrypting custom logs) before, after, or instead of calling\n    /// `do_sync_state`.\n    ///\n    /// `handler` must be a function that conforms to the\n    /// [`crate::messages::discovery::CustomSyncHandler`] type signature.\n    pub comptime fn custom_sync_state(&mut self, handler: CustomSyncHandler) -> Self {\n        self.custom_sync_state = Option::some(handler);\n        *self\n    }\n}\n\n/// Enables aztec-nr features on a `contract`.\n///\n/// All aztec-nr contracts should have this macro invoked on them, as it is the one that processes all contract\n/// functions, notes, storage, generates interfaces for external calls, and creates the message processing\n/// boilerplate.\n///\n/// ## Examples\n///\n/// Most contracts can simply invoke the macro with no parameters, resulting in default aztec-nr behavior:\n/// ```noir\n/// #[aztec]\n/// contract MyContract { ... }\n/// ```\n///\n/// Advanced contracts can use [`AztecConfig`] to customize parts of its behavior, such as message\n/// processing.\n/// ```noir\n/// #[aztec(aztec::macros::AztecConfig::new().custom_message_handler(my_handler))]\n/// contract MyAdvancedContract { ... }\n/// ```\n#[varargs]\npub comptime fn aztec(m: Module, args: [AztecConfig]) -> Quoted {\n    let num_args = args.len();\n    let config = if num_args == 0 {\n        AztecConfig::new()\n    } else if num_args == 1 {\n        args[0]\n    } else {\n        panic(f\"#[aztec] expects 0 or 1 arguments, got {num_args}\")\n    };\n\n    // Functions that don't have #[external(...)], #[contract_library_method], or #[test] are not allowed in contracts.\n    check_each_fn_macroified(m);\n\n    // We generate new functions prefixed with `__aztec_nr_internals__` and we replace the original functions' bodies\n    // with `static_assert(false, ...)` to prevent them from being called directly from within the contract.\n    let functions = process_functions(m);\n\n    // We generate structs and their implementations necessary for convenient functions calls.\n    let interface = generate_contract_interface(m);\n    let self_call_structs = generate_external_function_self_calls_structs(m);\n    let call_internal_struct = generate_call_internal_struct(m);\n\n    // We generate ABI exports for all the external functions in the contract.\n    let fn_abi_exports = create_fn_abi_exports(m);\n\n    // We generate `_compute_note_hash`, `_compute_note_nullifier` (and the deprecated\n    // `_compute_note_hash_and_nullifier` wrapper) only if they are not already implemented.\n    // If they are implemented we just insert empty quotes.\n    let contract_library_method_compute_note_hash_and_nullifier = if !m.functions().any(|f| {\n        // Note that we don't test for `_compute_note_hash` or `_compute_note_nullifier` in order to make this simpler\n        // - users must either implement all three or none.\n        // Down the line we'll remove this check and use `AztecConfig`.\n        f.name() == quote { _compute_note_hash_and_nullifier }\n    }) {\n        generate_contract_library_methods_compute_note_hash_and_nullifier()\n    } else {\n        quote {}\n    };\n    let process_custom_message_option = if config.custom_message_handler.is_some() {\n        let handler = config.custom_message_handler.unwrap();\n        quote { Option::some($handler) }\n    } else {\n        quote { Option::<aztec::messages::discovery::CustomMessageHandler>::none() }\n    };\n\n    let offchain_inbox_sync_option = quote {\n        Option::some(aztec::messages::processing::offchain::sync_inbox)\n    };\n\n    if m.functions().any(|f| f.name() == quote { sync_state }) {\n        panic(\n            \"User-defined 'sync_state' is not allowed. Use AztecConfig::custom_sync_state() to customize sync behavior.\",\n        );\n    }\n\n    let custom_sync_handler = if config.custom_sync_state.is_some() {\n        let handler = config.custom_sync_state.unwrap();\n        Option::some(quote { $handler })\n    } else {\n        Option::none()\n    };\n\n    let sync_state_fn_and_abi_export = generate_sync_state(\n        process_custom_message_option,\n        offchain_inbox_sync_option,\n        custom_sync_handler,\n    );\n\n    if m.functions().any(|f| f.name() == quote { offchain_receive }) {\n        panic(\n            \"User-defined 'offchain_receive' is not allowed. The function is auto-injected by the #[aztec] macro. See https://docs.aztec.network/errors/7\",\n        );\n    }\n    let offchain_receive_fn_and_abi_export = generate_offchain_receive();\n\n    let (has_public_init_nullifier_fn, emit_public_init_nullifier_fn_body) = generate_emit_public_init_nullifier(m);\n    let public_dispatch = generate_public_dispatch(m, has_public_init_nullifier_fn);\n\n    quote {\n        $interface\n        $self_call_structs\n        $call_internal_struct\n        $functions\n        $fn_abi_exports\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_state_fn_and_abi_export\n        $emit_public_init_nullifier_fn_body\n        $offchain_receive_fn_and_abi_export\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let calls = generate_external_function_calls(m);\n\n    let module_name = m.name();\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: aztec::protocol::address::AztecAddress\n        }\n\n        impl $module_name {\n            $calls\n\n            pub fn at(\n                addr: aztec::protocol::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates the `sync_state` utility function that performs message discovery.\ncomptime fn generate_sync_state(\n    process_custom_message_option: Quoted,\n    offchain_inbox_sync_option: Quoted,\n    custom_sync_handler: Option<Quoted>,\n) -> Quoted {\n    let body = if custom_sync_handler.is_some() {\n        let handler = custom_sync_handler.unwrap();\n        quote {\n            $handler(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    } else {\n        quote {\n            aztec::messages::discovery::do_sync_state(\n                address,\n                _compute_note_hash,\n                _compute_note_nullifier,\n                $process_custom_message_option,\n                $offchain_inbox_sync_option,\n                scope,\n            );\n        }\n    };\n\n    quote {\n        pub struct sync_state_parameters {\n            pub scope: aztec::protocol::address::AztecAddress,\n        }\n\n        #[abi(functions)]\n        pub struct sync_state_abi {\n            parameters: sync_state_parameters,\n        }\n\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn sync_state(scope: aztec::protocol::address::AztecAddress) {\n            aztec::oracle::version::assert_compatible_oracle_version();\n            let address = aztec::context::UtilityContext::new().this_address();\n            $body\n        }\n    }\n}\n\n/// Generates an `offchain_receive` utility function that lets callers add messages to the offchain message inbox.\n///\n/// For more details, see `aztec::messages::processing::offchain::receive`.\ncomptime fn generate_offchain_receive() -> Quoted {\n    let param_type = offchain_receive_param_type(quote { aztec });\n    let parameters_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_parameters\".quoted_contents();\n    let abi_struct_name = f\"{OFFCHAIN_RECEIVE_FN_NAME}_abi\".quoted_contents();\n\n    quote {\n        pub struct $parameters_struct_name {\n            pub $OFFCHAIN_RECEIVE_PARAM_NAME: $param_type,\n        }\n\n        #[abi(functions)]\n        pub struct $abi_struct_name {\n            parameters: $parameters_struct_name,\n        }\n\n        /// Receives offchain messages into this contract's offchain inbox for subsequent processing.\n        ///\n        /// Each message is routed to the inbox scoped to its `recipient` field.\n        ///\n        /// For more details, see `aztec::messages::processing::offchain::receive`.\n        ///\n        /// This function is automatically injected by the `#[aztec]` macro.\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_utility]\n        unconstrained fn $OFFCHAIN_RECEIVE_FN_NAME($OFFCHAIN_RECEIVE_PARAM_NAME: $param_type) -> $OFFCHAIN_RECEIVE_RETURN_TYPE {\n            aztec::oracle::version::assert_compatible_oracle_version();\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"
     },
-    "121": {
+    "122": {
       "function_locations": [
         {
           "name": "generate_private_external",
@@ -180,7 +180,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/private.nr",
       "source": "use crate::macros::{\n    functions::initialization_utils::has_public_init_checked_functions,\n    internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},\n    utils::{\n        fn_has_allow_phase_change, fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self,\n        is_fn_view, module_has_initializer, module_has_storage,\n    },\n};\nuse crate::protocol::meta::utils::derive_serialization_quotes;\nuse std::meta::type_of;\n\npub(crate) comptime fn generate_private_external(f: FunctionDefinition) -> Quoted {\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to\n    // the Private Kernel Circuit. First we change the function signature so that it also receives\n    // `PrivateContextInputs`, which contain information about the execution context (e.g. the caller).\n    let original_params = f.parameters().map(|param| (param.name(), param.typ()));\n\n    let original_params_quotes =\n        original_params.map(|(param_name, param_type)| quote { $param_name: $param_type }).join(quote {, });\n\n    let params = quote { inputs: aztec::context::inputs::PrivateContextInputs, $original_params_quotes };\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    let (args_serialization, _, serialized_args_name) = derive_serialization_quotes(original_params, false);\n\n    let storage_init = if module_has_storage {\n        // Contract has Storage defined so we initialize it.\n        quote {\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        // Contract does not have Storage defined, so we set storage to the unit type `()`. ContractSelfPrivate\n        // requires a storage struct in its constructor. Using an Option type would lead to worse developer experience\n        // and higher constraint counts so we use the unit type `()` instead.\n        quote {\n            let storage = ();\n        }\n    };\n\n    let contract_self_creation = quote {\n        #[allow(unused_variables)]\n        let mut self = {\n            $args_serialization\n            let args_hash = aztec::hash::hash_args($serialized_args_name);\n            let mut context = aztec::context::PrivateContext::new(inputs, args_hash);\n            $storage_init\n            let self_address = context.this_address();\n            let call_self: CallSelf<&mut aztec::context::PrivateContext> = CallSelf { address: self_address, context: &mut context };\n            let enqueue_self: EnqueueSelf<&mut aztec::context::PrivateContext> = EnqueueSelf { address: self_address, context: &mut context };\n            let call_self_static: CallSelfStatic<&mut aztec::context::PrivateContext> = CallSelfStatic { address: self_address, context: &mut context };\n            let enqueue_self_static: EnqueueSelfStatic<&mut aztec::context::PrivateContext> = EnqueueSelfStatic { address: self_address, context: &mut context };\n            let internal: CallInternal<&mut aztec::context::PrivateContext> = CallInternal { context: &mut context };\n            let call_self_utility = CallSelfUtility { address: self_address };\n            let utility: aztec::contract_self::PrivateUtilityCalls<CallSelfUtility> = aztec::contract_self::PrivateUtilityCalls { call_self: call_self_utility };\n            aztec::contract_self::ContractSelfPrivate::new(&mut context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal, utility)\n        };\n    };\n\n    let original_function_name = f.name();\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_only_self(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called by the same contract\";\n        quote { assert(self.msg_sender() == self.address, $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        let assertion_message = f\"Function {original_function_name} can only be called statically\".as_quoted_str();\n        quote { assert(self.context.is_static_call(), $assertion_message); }\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        let has_public_fns_with_init_check = has_public_init_checked_functions(f.module());\n        (\n            quote {\n                aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_private(*self.context);\n            },\n            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_from_private_initializer(self.context, $has_public_fns_with_init_check); },\n        )\n    } else {\n        (quote {}, quote {})\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        quote { aztec::macros::functions::initialization_utils::assert_is_initialized_private(self.context); }\n    } else {\n        quote {}\n    };\n\n    // Phase checks are skipped in functions that request to manually handle phases\n    let initial_phase_store = if fn_has_allow_phase_change(f) {\n        quote {}\n    } else {\n        quote { let within_revertible_phase: bool = self.context.in_revertible_phase(); }\n    };\n\n    let no_phase_change_check = if fn_has_allow_phase_change(f) {\n        quote {}\n    } else {\n        quote {\n            assert_eq(\n                within_revertible_phase,\n                self.context.in_revertible_phase(),\n                f\"Phase change detected on function with phase check. If this is expected, use #[allow_phase_change]\",\n            );\n        }\n    };\n\n    // Inject the authwit check if the function is marked with #[authorize_once].\n    let authorize_once_check = if fn_has_authorize_once(f) {\n        create_authorize_once_check(f, true)\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is serialized and hashed before being passed to the context.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment = quote { let $return_value_var_name: $return_value_type = $return_value; };\n\n        let (return_serialization, _, serialized_return_name) =\n            derive_serialization_quotes([(return_value_var_name, return_value_type)], false);\n\n        body = body_without_return;\n\n        quote {\n            $return_value_assignment\n            $return_serialization\n            self.context.set_return_hash($serialized_return_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(quote { let $unused_return_value_name = $last_body_expr; }\n                .as_expr()\n                .unwrap());\n        }\n        quote {}\n    };\n\n    let context_finish = quote { self.context.finish() };\n\n    // Preserve all attributes that are relevant to the function's ABI.\n    let abi_relevant_attributes = get_abi_relevant_attributes(f);\n\n    let fn_name = f\"__aztec_nr_internals__{original_function_name}\".quoted_contents();\n\n    let to_prepend = quote {\n        aztec::oracle::version::assert_compatible_oracle_version();\n        $contract_self_creation\n        $initial_phase_store\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $authorize_once_check\n    };\n\n    let body_quote = body.map(|expr| expr.quoted()).join(quote { });\n\n    // `mark_as_initialized` is placed after the user's function body. If it ran at the beginning, the contract\n    // would appear initialized while the initializer is still running, allowing contracts called by the initializer\n    // to re-enter into a half-initialized contract.\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $no_phase_change_check\n        $context_finish\n    };\n\n    // `PrivateCircuitPublicInputs` is a fixed protocol ABI: some of its fields are constant for a given function (e.g.\n    // the `is_static_call` flag of a non-static function), and the compiler flags those as constants that could be\n    // dropped from the return value. They cannot be dropped without changing the ABI, so silence the lint here rather\n    // than letting it defeat `--deny-warnings` for every contract.\n    quote {\n        #[allow(constant_return)]\n        #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n        $abi_relevant_attributes\n        fn $fn_name($params) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n            $to_prepend\n            $body_quote\n            $to_append\n        }\n    }\n}\n"
     },
-    "129": {
+    "130": {
       "function_locations": [
         {
           "name": "get_next_note_type_id",
@@ -214,7 +214,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/macros/notes.nr",
       "source": "use std::collections::bounded_vec::BoundedVec;\n\n/// Maximum number of note types within 1 contract.\ncomptime global MAX_NOTE_TYPES: u32 = 128;\n\n/// A BoundedVec containing all the note types within this contract.\npub comptime mut global NOTES: BoundedVec<Type, MAX_NOTE_TYPES> = BoundedVec::new();\n\ncomptime mut global NOTE_TYPE_ID_COUNTER: u32 = 0;\n\n/// The note type id is set by enumerating the note types.\ncomptime fn get_next_note_type_id() -> Field {\n    // We assert that the note type id fits within 7 bits\n    assert(\n        NOTE_TYPE_ID_COUNTER < MAX_NOTE_TYPES,\n        f\"A contract can contain at most {MAX_NOTE_TYPES} different note types\",\n    );\n\n    let note_type_id = NOTE_TYPE_ID_COUNTER as Field;\n    NOTE_TYPE_ID_COUNTER += 1;\n    note_type_id\n}\n\n/// Generates default `NoteType` implementation for a given note struct `s` and returns it as a quote.\n///\n/// ```noir\n/// impl NoteType for NoteStruct {\n///     fn get_id() -> Field {\n///         ...\n///     }\n/// }\n/// ```\ncomptime fn generate_note_type_impl(s: TypeDefinition, note_type_id: Field) -> Quoted {\n    let name = s.name();\n    let typ = s.as_type();\n    let note_type_name: str<_> = f\"{name}\".as_quoted_str!();\n    let max_note_packed_len = crate::messages::logs::note::MAX_NOTE_PACKED_LEN;\n\n    quote {\n        impl aztec::note::note_interface::NoteType for $name {\n            fn get_id() -> Field {\n                // This static assertion ensures the note's packed length doesn't exceed the maximum allowed size.\n                // While this check would ideally live in the Packable trait implementation, we place it here since\n                // this function is always generated by our macros and the Packable trait implementation is not.\n                //\n                // Note: We set the note type name and max packed length as local variables because injecting them\n                // directly into the error message doesn't work.\n                let note_type_name = $note_type_name;\n                let max_note_packed_len: u32 = $max_note_packed_len; // Casting to u32 to avoid the value to be printed in hex.\n                let note_packed_len = <$typ as aztec::protocol::traits::Packable>::N;\n                std::static_assert(note_packed_len <= $max_note_packed_len, f\"{note_type_name} has a packed length of {note_packed_len} fields, which exceeds the maximum allowed length of {max_note_packed_len} fields. See https://docs.aztec.network/errors/4\");\n\n                $note_type_id\n            }\n        }\n    }\n}\n\n/// Generates default `NoteHash` trait implementation for a given note struct `s` and returns it as a quote.\n///\n/// # Generated Implementation\n///\n/// ```noir\n/// impl NoteHash for NoteStruct {\n///     fn compute_note_hash(self, owner: AztecAddress, storage_slot: Field, randomness: Field) -> Field { ... }\n///\n///     fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullification: Field, owner:\n/// AztecAddress) -> Field { ... }\n///\n///     unconstrained fn compute_nullifier_unconstrained(note_hash_for_nullification: Field, owner: AztecAddress) ->\n/// Field { ... }\n/// }\n/// ```\ncomptime fn generate_note_hash_trait_impl(s: TypeDefinition) -> Quoted {\n    let name = s.name();\n\n    quote {\n        impl aztec::note::note_interface::NoteHash for $name {\n            fn compute_note_hash(self, owner: aztec::protocol::address::AztecAddress, storage_slot: Field, randomness: Field) -> Field {\n                let data = aztec::protocol::traits::Packable::pack(self).concat([aztec::protocol::traits::ToField::to_field(owner), randomness]);\n                aztec::note::utils::compute_note_hash(storage_slot, data)\n            }\n\n            fn compute_nullifier(\n                self,\n                context: &mut aztec::context::PrivateContext,\n                owner: aztec::protocol::address::AztecAddress,\n                note_hash_for_nullification: Field,\n            ) -> Field {\n                let owner_npk_m_hash = aztec::keys::getters::get_public_keys(owner).npk_m_hash;\n                let secret = context.request_nhk_app(owner_npk_m_hash);\n                aztec::note::utils::compute_note_nullifier(note_hash_for_nullification, [secret])\n            }\n\n            unconstrained fn compute_nullifier_unconstrained(\n                self,\n                owner: aztec::protocol::address::AztecAddress,\n                note_hash_for_nullification: Field,\n            ) -> Option<Field> {\n                // Note: In the current PXE implementation, if public keys are available then the nullifier\n                // hiding key (nhk) is also available, so we don't need to handle get_nhk_app potentially\n                // failing. The Option is only needed for the try_get_public_keys call.\n                aztec::keys::getters::try_get_public_keys(owner).map(|public_keys| {\n                    let owner_npk_m_hash = public_keys.npk_m_hash;\n                    let secret = aztec::keys::getters::get_nhk_app(owner_npk_m_hash);\n                    aztec::note::utils::compute_note_nullifier(note_hash_for_nullification, [secret])\n                })\n            }\n        }\n    }\n}\n\n/// Generates note properties struct for a given note struct `s`.\n///\n/// Each selector's `index` is the field's offset in the note's packed representation, assuming the field-by-field\n/// layout of `#[derive(Packable)]`.\n///\n/// Example, for a note whose first field packs to two fields (`Point` packs to `[x, y]`), placing the fields after\n/// it at packed indices 2 and 3:\n/// ```\n/// struct OwnedNoteProperties {\n///     owner_pubkey: aztec::note::note_getter_options::PropertySelector<Point>,\n///     value: aztec::note::note_getter_options::PropertySelector<Field>,\n///     randomness: aztec::note::note_getter_options::PropertySelector<Field>\n/// }\n///\n/// impl aztec::note::note_interface::NoteProperties<OwnedNoteProperties> for OwnedNote {\n///     fn properties() -> OwnedNoteProperties {\n///         OwnedNoteProperties {\n///             owner_pubkey: aztec::note::note_getter_options::PropertySelector { index: 0, offset: 0, length: 32 },\n///             value: aztec::note::note_getter_options::PropertySelector { index: 2, offset: 0, length: 32 },\n///             randomness: aztec::note::note_getter_options::PropertySelector { index: 3, offset: 0, length: 32 }\n///         }\n///     }\n/// }\n/// ```\n///\n/// WARNING: a hand-written `Packable` implementation can lay fields out differently, making that assumption wrong.\n/// `properties()` statically asserts that the note's packed length equals the sum of its field packed lengths, which\n/// rejects most custom layouts. However, a custom layout that packs to the same total length but re-orders the fields\n/// is not detectable: its generated selectors point at the wrong packed fields.\ncomptime fn generate_note_properties(s: TypeDefinition) -> Quoted {\n    let name = s.name();\n    let typ = s.as_type();\n    let note_type_name = f\"{name}\".as_quoted_str!();\n\n    let struct_name = f\"{name}Properties\".quoted_contents();\n\n    let note_fields = s.fields_as_written();\n\n    let properties_types = note_fields\n        .map(|field| {\n            let name = field.name();\n            let typ = field.typ();\n            quote { pub $name: aztec::note::note_getter_options::PropertySelector<$typ> }\n        })\n        .join(quote {,});\n\n    let mut properties_list = @[];\n    // The packed offset of the field being processed, i.e. the sum of the packed lengths of all preceding fields.\n    let mut accumulated_offset = quote { 0 };\n    for i in 0..note_fields.len() {\n        let name = note_fields[i].name();\n        let field_type = note_fields[i].typ();\n        properties_list = properties_list.push_back(\n            quote {\n                $name: aztec::note::note_getter_options::PropertySelector {\n                    index: ($accumulated_offset) as u8,\n                    offset: 0,\n                    length: 32,\n                }\n            },\n        );\n        // If a \"No matching impl found for `<type>: Packable`\" error points here, a note struct has a field whose\n        // type does not implement Packable. Every note field type must, even when the note's own Packable\n        // implementation is hand-written, because the note's auto-generated property selectors locate each field by\n        // its packed offset. Derive or implement Packable on the field's type, or, when the type belongs to another\n        // crate (implementing Packable for it there is not possible), wrap it in a local struct that implements it.\n        accumulated_offset = quote { $accumulated_offset + <$field_type as aztec::protocol::traits::Packable>::N };\n    }\n\n    let properties = properties_list.join(quote {,});\n\n    quote {\n        pub struct $struct_name {\n            $properties_types\n        }\n\n        impl aztec::note::note_interface::NoteProperties<$struct_name> for $name {\n            fn properties() -> $struct_name {\n                let note_type_name = $note_type_name;\n                let fields_packed_len: u32 = $accumulated_offset;\n                let note_packed_len: u32 = <$typ as aztec::protocol::traits::Packable>::N;\n                // We only reject custom Packable layouts whose total packed length differs from the derived\n                // layout's. A hand-written pack() that keeps the same total length but reorders same-width fields\n                // is deliberately not caught: the selectors are computed from declared field order and would\n                // silently point at the wrong packed slot. Detecting it would require knowing whether Packable was\n                // derived or hand-written, which comptime cannot currently tell us. Custom layouts must define their\n                // PropertySelectors manually.\n                std::static_assert(\n                    fields_packed_len == note_packed_len,\n                    f\"{note_type_name}'s auto-generated note properties assume the #[derive(Packable)] layout ({fields_packed_len} fields), but its hand-written Packable packs to {note_packed_len}. Derive Packable, or define property selectors manually for the custom layout. See https://docs.aztec.network/errors/15\",\n                );\n\n                $struct_name {\n                    $properties\n                }\n            }\n        }\n    }\n}\n\n/// Generates the core note functionality for a struct:\n///\n/// - NoteTypeProperties: Defines the structure and properties of note fields\n/// - NoteType trait implementation: Provides the note type ID\n/// - NoteHash trait implementation: Handles note hash and nullifier computation\n///\n/// # Requirements\n///\n/// The note struct must:\n/// - Implement the `Packable` trait\n/// - Not exceed `MAX_NOTE_PACKED_LEN` when packed\n///\n/// # Registration\n///\n/// Registers the note in the global `NOTES` BoundedVec to enable note processing functionality.\n///\n/// # Generated Code\n///\n/// For detailed documentation on the generated implementations, see:\n/// - `generate_note_properties()`\n/// - `generate_note_type_impl()`\n/// - `generate_note_hash_trait_impl()`\npub comptime fn note(s: TypeDefinition) -> Quoted {\n    assert_has_packable(s);\n\n    // We register the note in the global `NOTES` BoundedVec because we need that information inside the #[aztec] macro\n    // to generate note processing functionality.\n    NOTES.push(s.as_type());\n\n    let note_properties = generate_note_properties(s);\n    let note_type_id = get_next_note_type_id();\n    let note_type_impl = generate_note_type_impl(s, note_type_id);\n    let note_hash_impl = generate_note_hash_trait_impl(s);\n\n    quote {\n        $note_properties\n        $note_type_impl\n        $note_hash_impl\n    }\n}\n\n/// Generates code for a custom note implementation that requires specialized note hash or nullifier computation.\n///\n/// # Generated Code\n/// - NoteTypeProperties: Defines the structure and properties of note fields\n/// - NoteType trait implementation: Provides the note type ID\n///\n/// # Requirements\n///\n/// The note struct must:\n/// - Implement the `Packable` trait\n/// - Not exceed `MAX_NOTE_PACKED_LEN` when packed\n///\n/// # Registration\n///\n/// Registers the note in the global `NOTES` BoundedVec to enable note processing functionality.\n///\n/// # Use Cases\n///\n/// Use this macro when implementing a note that needs custom:\n/// - Note hash computation logic\n/// - Nullifier computation logic\n///\n/// The macro omits generating default NoteHash trait implementation, allowing you to provide your own.\n///\n/// # Example\n/// ```\n/// #[custom_note]\n/// pub struct CustomNote {\n///     value: Field,\n///     metadata: Field\n/// }\n///\n/// impl NoteHash for CustomNote {\n///     // Custom note hash computation...\n///     fn compute_note_hash(...) -> Field { ... }\n///\n///     // Custom nullifier computation...\n///     fn compute_nullifier(...) -> Field { ... }\n///     fn compute_nullifier_unconstrained(...) -> Field { ... }\n/// }\n/// ```\npub comptime fn custom_note(s: TypeDefinition) -> Quoted {\n    assert_has_packable(s);\n\n    // We register the note in the global `NOTES` BoundedVec because we need that information inside the #[aztec] macro\n    // to generate note processing functionality.\n    NOTES.push(s.as_type());\n\n    let note_type_id = get_next_note_type_id();\n    let note_properties = generate_note_properties(s);\n    let note_type_impl = generate_note_type_impl(s, note_type_id);\n\n    quote {\n        $note_properties\n        $note_type_impl\n    }\n}\n\n/// Asserts that the given note implements the [`Packable`](crate::protocol::traits::Packable) trait.\n///\n/// We require that notes have the `Packable` trait implemented because it is used when emitting a note in a log or as\n/// an offchain message.\ncomptime fn assert_has_packable(note: TypeDefinition) {\n    let packable_constraint = quote { crate::protocol::traits::Packable }.as_trait_constraint();\n    let note_name = note.name();\n\n    assert(\n        note.as_type().implements(packable_constraint),\n        f\"{note_name} does not implement Packable trait. Either implement it manually or place #[derive(Packable)] on the note struct before #[note] macro invocation.\",\n    );\n}\n"
     },
-    "136": {
+    "137": {
       "function_locations": [
         {
           "name": "protect_from_forgery",
@@ -510,7 +510,7 @@
       "path": "std/embedded_curve_ops.nr",
       "source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Create a new point using the provided (x, y) pair\n    pub fn new(x: Field, y: Field) -> Self {\n        EmbeddedCurvePoint { x, y }\n    }\n\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0 }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n        }\n    }\n\n    /// True if this point is the point at infinity\n    pub fn is_infinite(self) -> bool {\n        (self.x == 0) & (self.y == 0)\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.x == b.x) & (self.y == b.y)\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.x.hash(state);\n        self.y.hash(state);\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    /// Create a new scalar using the provided (lo, hi) pair\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    /// Create a scalar from the given bn254 field value\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n/// Computes a multi scalar multiplication over the embedded curve.\n/// For bn254, We have Grumpkin.\n///\n/// The embedded curve being used is decided by the\n/// underlying proof system.\n///\n/// IMPORTANT: Prefer `multi_scalar_mul()` over repeated `embedded_curve_add()`\n/// for adding multiple points. This is significantly more efficient.\n/// For adding exactly 2 points, use `embedded_curve_add()` directly.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// Elliptic curve addition\n/// IMPORTANT: this function is expected to perform a full addition in order to handle all corner cases:\n/// - points on the curve\n/// - point doubling\n/// - point at infinity\n/// As a result, you may not get optimal performance, depending on the assumptions of your inputs.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::default::Default;\n    use crate::embedded_curve_ops::{\n        embedded_curve_add, EmbeddedCurvePoint, EmbeddedCurveScalar, fixed_base_scalar_mul,\n        multi_scalar_mul,\n    };\n    use crate::field::bn254::TWO_POW_128;\n    use crate::hash::Hash;\n    use crate::hash::Hasher;\n    use crate::hash::poseidon2::Poseidon2Hasher;\n\n    fn hash_point(p: EmbeddedCurvePoint) -> Field {\n        let mut hasher: Poseidon2Hasher = Default::default();\n        p.hash(&mut hasher);\n        hasher.finish()\n    }\n\n    fn hash_scalar(s: EmbeddedCurveScalar) -> Field {\n        let mut hasher: Poseidon2Hasher = Default::default();\n        s.hash(&mut hasher);\n        hasher.finish()\n    }\n\n    #[test]\n    fn point_new_sets_coordinates() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        assert_eq(p.x, 3);\n        assert_eq(p.y, 5);\n    }\n\n    #[test]\n    fn point_at_infinity_is_origin() {\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(inf.x, 0);\n        assert_eq(inf.y, 0);\n    }\n\n    #[test]\n    fn generator_has_documented_coordinates() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(g.x, 1);\n        assert_eq(g.y, 17631683881184975370165255887551781615748388533673675138860);\n    }\n\n    #[test]\n    fn is_infinite_only_true_for_origin() {\n        assert(EmbeddedCurvePoint::point_at_infinity().is_infinite());\n        assert(!EmbeddedCurvePoint::generator().is_infinite());\n        assert(!EmbeddedCurvePoint::new(1, 0).is_infinite());\n        assert(!EmbeddedCurvePoint::new(0, 1).is_infinite());\n    }\n\n    #[test]\n    fn points_with_same_coords_are_equal() {\n        let p = EmbeddedCurvePoint::new(7, 11);\n        let q = EmbeddedCurvePoint::new(7, 11);\n        assert_eq(p, q);\n    }\n\n    #[test]\n    fn points_with_different_coords_are_unequal() {\n        let p = EmbeddedCurvePoint::new(7, 11);\n        assert(p != EmbeddedCurvePoint::new(7, 12));\n        assert(p != EmbeddedCurvePoint::new(8, 11));\n        assert(p != EmbeddedCurvePoint::new(8, 12));\n    }\n\n    #[test]\n    fn neg_negates_y_coordinate() {\n        let g = EmbeddedCurvePoint::generator();\n        let neg_g = -g;\n        assert_eq(neg_g.x, g.x);\n        assert_eq(neg_g.y, -g.y);\n    }\n\n    #[test]\n    fn neg_is_involution() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(--g, g);\n    }\n\n    #[test]\n    fn add_with_point_at_infinity_is_identity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(g + inf, g);\n        assert_eq(inf + g, g);\n    }\n\n    #[test]\n    fn add_of_two_infinities_is_infinity() {\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert((inf + inf).is_infinite());\n    }\n\n    #[test]\n    fn add_with_negation_is_point_at_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        assert((g + (-g)).is_infinite());\n    }\n\n    #[test]\n    fn add_is_commutative() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq(g + g2, g2 + g);\n    }\n\n    #[test]\n    fn add_is_associative() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        let g3 = g + g2;\n        assert_eq((g + g2) + g3, g + (g2 + g3));\n    }\n\n    #[test]\n    fn sub_of_a_point_with_itself_is_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        assert((g - g).is_infinite());\n    }\n\n    #[test]\n    fn sub_with_point_at_infinity_is_identity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(g - inf, g);\n    }\n\n    #[test]\n    fn sub_inverts_add() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq((g + g2) - g2, g);\n        assert_eq((g + g2) - g, g2);\n    }\n\n    #[test]\n    fn double_equals_self_plus_self() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(g.double(), g + g);\n    }\n\n    #[test]\n    fn double_of_point_at_infinity_is_infinity() {\n        assert(EmbeddedCurvePoint::point_at_infinity().double().is_infinite());\n    }\n\n    #[test]\n    fn embedded_curve_add_matches_add_operator() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq(embedded_curve_add(g, g2), g + g2);\n    }\n\n    #[test]\n    fn point_hash_is_consistent_for_equal_points() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        let q = EmbeddedCurvePoint::new(3, 5);\n        assert_eq(hash_point(p), hash_point(q));\n    }\n\n    #[test]\n    fn point_hash_differs_for_distinct_points() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(3, 7)));\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(4, 5)));\n        // Distinguishes (x, y) from (y, x) - order of writes matters.\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(5, 3)));\n    }\n\n    #[test]\n    fn scalar_new_sets_limbs() {\n        let s = EmbeddedCurveScalar::new(3, 5);\n        assert_eq(s.lo, 3);\n        assert_eq(s.hi, 5);\n    }\n\n    #[test]\n    fn scalars_with_same_limbs_are_equal() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        let t = EmbeddedCurveScalar::new(7, 11);\n        assert_eq(s, t);\n    }\n\n    #[test]\n    fn scalars_with_different_limbs_are_unequal() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        assert(s != EmbeddedCurveScalar::new(7, 12));\n        assert(s != EmbeddedCurveScalar::new(8, 11));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_zero() {\n        assert_eq(EmbeddedCurveScalar::from_field(0), EmbeddedCurveScalar::new(0, 0));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_small_value() {\n        let s = EmbeddedCurveScalar::from_field(0x1234567890);\n        assert_eq(s, EmbeddedCurveScalar::new(0x1234567890, 0));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_two_pow_128() {\n        let s = EmbeddedCurveScalar::from_field(TWO_POW_128);\n        assert_eq(s, EmbeddedCurveScalar::new(0, 1));\n    }\n\n    #[test]\n    fn scalar_hash_is_consistent_for_equal_scalars() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        let t = EmbeddedCurveScalar::new(7, 11);\n        assert_eq(hash_scalar(s), hash_scalar(t));\n    }\n\n    #[test]\n    fn scalar_hash_differs_for_distinct_scalars() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(7, 12)));\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(8, 11)));\n        // Distinguishes (lo, hi) from (hi, lo) - limb order matters.\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(11, 7)));\n    }\n\n    #[test]\n    fn msm_with_scalar_one_returns_point() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([g], [one]), g);\n    }\n\n    #[test]\n    fn msm_with_scalar_zero_returns_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert(multi_scalar_mul([g], [zero]).is_infinite());\n    }\n\n    #[test]\n    fn msm_with_scalar_two_doubles_point() {\n        let g = EmbeddedCurvePoint::generator();\n        let two = EmbeddedCurveScalar::new(2, 0);\n        assert_eq(multi_scalar_mul([g], [two]), g.double());\n    }\n\n    #[test]\n    fn msm_sums_terms() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([g, g], [one, one]), g.double());\n    }\n\n    #[test]\n    fn msm_with_opposite_terms_cancels() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert(multi_scalar_mul([g, -g], [one, one]).is_infinite());\n    }\n\n    #[test]\n    fn msm_skips_point_at_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([inf, g], [one, one]), g);\n    }\n\n    #[test]\n    fn msm_skips_zero_scalar() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert_eq(multi_scalar_mul([g, g], [zero, one]), g);\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_with_one_returns_generator() {\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(fixed_base_scalar_mul(one), EmbeddedCurvePoint::generator());\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_with_zero_returns_infinity() {\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert(fixed_base_scalar_mul(zero).is_infinite());\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_matches_msm_on_generator() {\n        let s = EmbeddedCurveScalar::new(2, 0);\n        assert_eq(\n            fixed_base_scalar_mul(s),\n            multi_scalar_mul([EmbeddedCurvePoint::generator()], [s]),\n        );\n    }\n}\n"
     },
-    "143": {
+    "144": {
       "function_locations": [
         {
           "name": "do_sync_state",
@@ -544,7 +544,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::logging::{aztecnr_debug_log, aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::messages::{\n    delivery::handshake::{get_handshake_secrets, PROVIDED_SECRETS_ARRAY_BASE_SLOT},\n    processing::provided_secret::ProvidedSecret,\n};\nuse crate::partial_notes;\nuse crate::protocol::address::AztecAddress;\n\npub(crate) mod nonce_discovery;\npub(crate) mod private_events;\npub mod private_notes;\npub mod process_message;\n\nuse crate::{\n    messages::{\n        discovery::process_message::process_message_ciphertext,\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{\n            offchain::OffchainInboxSync, OffchainMessageWithTx, pending_tagged_log::PendingTaggedLog, ResolvedTx,\n            validate_and_store_enqueued_notes_and_events,\n        },\n    },\n    oracle::message_processing,\n    utils::array,\n};\n\npub struct NoteHashAndNullifier {\n    /// The result of [`crate::note::note_interface::NoteHash::compute_note_hash`].\n    pub note_hash: Field,\n    /// The result of [`crate::note::note_interface::NoteHash::compute_nullifier_unconstrained`].\n    ///\n    /// This value is unconstrained, as all of message discovery is unconstrained. It is `None` if the nullifier\n    /// cannot be computed (e.g. because the nullifier hiding key is not available).\n    pub inner_nullifier: Option<Field>,\n}\n\n/// A contract's way of computing note hashes.\n///\n/// Each contract in the network is free to compute their note's hash as they see fit - the hash function itself is not\n/// enshrined or standardized. Some aztec-nr functions however do need to know the details of this computation (e.g.\n/// when finding new notes), which is what this type represents.\n///\n/// This function takes a note's packed content, storage slot, note type ID, address of the emitting contract and\n/// randomness, and attempts to compute its inner note hash (not siloed by address nor uniqued by nonce).\n///\n/// ## Transient Notes\n///\n/// This function is meant to always be used on **settled** notes, i.e. those that have been inserted into the trees\n/// and for which the nonce is known. It is never invoked in the context of a transient note, as those are not involved\n/// in message processing.\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract by inspecting all note types in use and the storage layout. This injected function is a\n/// `#[contract_library_method]` called `_compute_note_hash`, and it looks something like this:\n///\n/// ```noir\n/// |packed_note, owner, storage_slot, note_type_id, _contract_address, randomness| {\n///     if note_type_id == MyNoteType::get_id() {\n///         if packed_note.len() != MY_NOTE_TYPE_SERIALIZATION_LENGTH {\n///             Option::none()\n///         } else {\n///             let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///             Option::some(note.compute_note_hash(owner, storage_slot, randomness))\n///         }\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\npub type ComputeNoteHash = unconstrained fn(/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /*\n owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /*\nrandomness */ Field) -> Option<Field>;\n\n/// A contract's way of computing note nullifiers.\n///\n/// Like [`ComputeNoteHash`], each contract is free to derive nullifiers as they see fit. This function takes the\n/// unique note hash (used as the note hash for nullification for settled notes), plus the note's packed content and\n/// metadata, and attempts to compute the inner nullifier (not siloed by address).\n///\n/// ## Automatic Implementation\n///\n/// The [`[#aztec]`](crate::macros::aztec::aztec) macro automatically creates a correct implementation of this function\n/// for each contract called `_compute_note_nullifier`. It dispatches on `note_type_id` similarly to\n/// [`ComputeNoteHash`], then calls the note's\n/// [`compute_nullifier_unconstrained`](crate::note::note_interface::NoteHash::compute_nullifier_unconstrained) method.\npub type ComputeNoteNullifier = unconstrained fn(/* unique_note_hash */Field, /* packed_note */ BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/* randomness */ Field) -> Option<Field>;\n\n/// Deprecated: use [`ComputeNoteHash`] and [`ComputeNoteNullifier`] instead.\npub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n/* owner */ AztecAddress, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress,\n/*randomness */ Field, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// A handler for custom messages.\n///\n/// Contracts that emit custom messages (i.e. any with a message type that is not in [`crate::messages::msg_type`])\n/// need to use [`crate::macros::AztecConfig::custom_message_handler`] with a function of this type in order to\n/// process them. They will otherwise be **silently ignored**.\npub type CustomMessageHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* msg_type_id */ u64,\n/* msg_metadata */ u64,\n/* msg_content */ BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n/* resolved_tx */ ResolvedTx,\n/* scope */ AztecAddress);\n\n/// Custom state synchronization handler.\n///\n/// When set via [`crate::macros::AztecConfig::custom_sync_state`], the generated `sync_state` function will call\n/// this handler instead of [`do_sync_state`]. It receives all of the same parameters, so it can run custom logic\n/// (e.g. fetching and decrypting custom logs) before, after, or instead of calling [`do_sync_state`].\npub type CustomSyncHandler = unconstrained fn(\n/* contract_address */AztecAddress,\n/* compute_note_hash */ ComputeNoteHash,\n/* compute_note_nullifier */ ComputeNoteNullifier,\n/* process_custom_message */ Option<CustomMessageHandler>,\n/* offchain_inbox_sync */ Option<OffchainInboxSync>,\n/* scope */ AztecAddress);\n\n/// Synchronizes the contract's private state with the network.\n///\n/// As blocks are mined, it is possible for a contract's private state to change (e.g. with new notes being created),\n/// but because these changes are private they will be invisible to most actors. This is the function that processes\n/// new transactions in order to discover new notes, events, and other kinds of private state changes.\n///\n/// The private state will be synchronized up to the block that will be used for private transactions (i.e. the anchor\n/// block. This will typically be close to the tip of the chain.\npub unconstrained fn do_sync_state(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n) {\n    let provided_secrets = get_handshake_secrets(contract_address, scope);\n    sync_state_with_secrets(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        process_custom_message,\n        offchain_inbox_sync,\n        scope,\n        provided_secrets,\n    );\n}\n\n/// Variant of [`do_sync_state`] that skips handshake secret discovery. Used by the HandshakeRegistry to avoid\n/// infinite recursion (the registry discovers handshakes for other contracts, not for itself).\npub unconstrained fn do_sync_state_without_handshake_discovery(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n) {\n    let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);\n    sync_state_with_secrets(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        process_custom_message,\n        offchain_inbox_sync,\n        scope,\n        provided_secrets,\n    );\n}\n\n/// A [`CustomSyncHandler`] that skips state synchronization entirely.\n///\n/// For contracts that hold no private state and emit no messages, there is nothing to discover: syncing would only\n/// perform unnecessary RPC calls.\npub unconstrained fn do_sync_state_no_op(\n    _contract_address: AztecAddress,\n    _compute_note_hash: ComputeNoteHash,\n    _compute_note_nullifier: ComputeNoteNullifier,\n    _process_custom_message: Option<CustomMessageHandler>,\n    _offchain_inbox_sync: Option<OffchainInboxSync>,\n    _scope: AztecAddress,\n) {}\n\nunconstrained fn sync_state_with_secrets(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    offchain_inbox_sync: Option<OffchainInboxSync>,\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) {\n    aztecnr_debug_log!(\"Performing state synchronization\");\n\n    let logs = message_processing::get_pending_tagged_logs(scope, provided_secrets);\n    logs.for_each(|_i, pending_tagged_log: PendingTaggedLog| {\n        if pending_tagged_log.log.len() == 0 {\n            aztecnr_warn_log_format!(\"Skipping empty log from tx {0}\")([pending_tagged_log.context.tx_hash]);\n        } else {\n            aztecnr_debug_log_format!(\"Processing log with tag {0}\")([pending_tagged_log.log.get(0)]);\n\n            // We remove the tag from the pending tagged log and process the message ciphertext contained in it.\n            let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                message_ciphertext,\n                pending_tagged_log.context,\n                scope,\n            );\n        }\n    });\n\n    if offchain_inbox_sync.is_some() {\n        let msgs = offchain_inbox_sync.unwrap()(contract_address, scope);\n        msgs.for_each(|_i, msg: OffchainMessageWithTx| {\n            process_message_ciphertext(\n                contract_address,\n                compute_note_hash,\n                compute_note_nullifier,\n                process_custom_message,\n                msg.message_ciphertext,\n                msg.resolved_tx,\n                scope,\n            );\n        });\n    }\n\n    // Then we process all pending partial notes, regardless of whether they were found in the current or previous\n    // executions.\n    partial_notes::sync(\n        contract_address,\n        compute_note_hash,\n        compute_note_nullifier,\n        scope,\n    );\n\n    // Finally we validate all notes and events that were found as part of the previous processes, resulting in them\n    // being added to PXE's database and retrievable via oracles (get_notes) and our TS API (PXE::getPrivateEvents).\n    validate_and_store_enqueued_notes_and_events(scope);\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::{\n        delivery::handshake::HandshakePage,\n        discovery::{CustomMessageHandler, do_sync_state},\n        logs::note::MAX_NOTE_PACKED_LEN,\n        processing::{offchain::OffchainInboxSync, pending_tagged_log::PendingTaggedLog},\n    };\n    use crate::protocol::{address::AztecAddress, traits::Serialize};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn do_sync_state_does_not_panic_on_empty_logs() {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n\n        let contract_address = AztecAddress { inner: 0xdeadbeef };\n\n        env.utility_context_at(contract_address, |_| {\n            // get_handshake_secrets calls the HandshakeRegistry during sync; return an empty page so\n            // no tagging secrets are produced.\n            let empty_page = HandshakePage { items: BoundedVec::new(), total_count: 0 };\n            let _ = OracleMock::mock(\"aztec_utl_callUtilityFunction\").returns(empty_page.serialize());\n\n            // Mock the oracle call to return a known base slot, then populate an ephemeral\n            // array at that slot so do_sync_state processes a non-empty log list.\n            let base_slot = 42;\n            let mock = std::test::OracleMock::mock(\"aztec_utl_getPendingTaggedLogsV2\");\n            let _ = mock.returns(base_slot);\n\n            let logs: EphemeralArray<PendingTaggedLog> = EphemeralArray::at(base_slot);\n            logs.push(PendingTaggedLog { log: BoundedVec::new(), context: std::mem::zeroed() });\n            assert_eq(logs.len(), 1);\n\n            let no_handler: Option<CustomMessageHandler> = Option::none();\n            let no_inbox_sync: Option<OffchainInboxSync> = Option::none();\n            do_sync_state(\n                contract_address,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n                no_handler,\n                no_inbox_sync,\n                scope,\n            );\n\n            // Guards against the mocked oracle name going stale: if sync stops calling it, the crafted empty log\n            // above is never consumed and the test silently stops covering the empty-payload path.\n            assert_eq(mock.times_called(), 1);\n        });\n    }\n\n    unconstrained fn dummy_compute_note_hash(\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n\n    unconstrained fn dummy_compute_note_nullifier(\n        _unique_note_hash: Field,\n        _packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n        _owner: AztecAddress,\n        _storage_slot: Field,\n        _note_type_id: Field,\n        _contract_address: AztecAddress,\n        _randomness: Field,\n    ) -> Option<Field> {\n        Option::none()\n    }\n}\n"
     },
-    "144": {
+    "145": {
       "function_locations": [
         {
           "name": "attempt_note_nonce_discovery",
@@ -602,7 +602,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "145": {
+    "146": {
       "function_locations": [
         {
           "name": "process_private_event_msg",
@@ -612,7 +612,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "146": {
+    "147": {
       "function_locations": [
         {
           "name": "process_private_note_msg",
@@ -626,7 +626,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/discovery/private_notes.nr",
       "source": "use crate::{\n    logging::{aztecnr_debug_log_format, aztecnr_warn_log_format},\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::note::{decode_private_note_message, MAX_NOTE_PACKED_LEN},\n        processing::enqueue_note_for_validation,\n    },\n    protocol::{address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, traits::ToField},\n};\n\n/// Processes a private note message, attempting to discover and enqueue any notes it contains.\n///\n/// For each note recovered from the message whose computed note hash matches a unique note hash in the transaction,\n/// a [`NoteValidationRequest`](crate::messages::processing::NoteValidationRequest) is pushed onto the ephemeral array\n/// at `NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT` via\n/// [`enqueue_note_for_validation`](crate::messages::processing::enqueue_note_for_validation). PXE later drains this\n/// array during `validate_and_store_enqueued_notes_and_events`, after which the notes are retrievable via `get_notes`.\n///\n/// Messages that fail to decode, or whose computed note hash matches nothing in the transaction, are discarded\n/// (with a debug or warning log respectively) and produce no validation requests. Decode failures are not treated\n/// as errors since messages may originate from malicious senders and we don't want them to be able to brick message\n/// processing.\n///\n/// ## Use Cases\n///\n/// This function is invoked automatically by aztec-nr when handling messages with the built-in private note type id,\n/// so contracts do not normally need to call it directly. It is exposed for use by custom message handlers (see\n/// [`CustomMessageHandler`](crate::messages::discovery::CustomMessageHandler)) that might want to use the standard\n/// note message processing pipeline while extending it with custom logic.\npub unconstrained fn process_private_note_msg(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) {\n    let decoded = decode_private_note_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (note_type_id, owner, storage_slot, randomness, packed_note) = decoded.unwrap();\n\n        attempt_note_discovery(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            compute_note_hash,\n            compute_note_nullifier,\n            owner,\n            storage_slot,\n            randomness,\n            note_type_id,\n            packed_note,\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode private note message from tx {0}, ignoring\",\n        )(\n            [tx_hash],\n        );\n    }\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is suspected the\n/// note was created.\nunconstrained fn attempt_note_discovery(\n    contract_address: AztecAddress,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_type_id: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) {\n    let discovered_notes = attempt_note_nonce_discovery(\n        unique_note_hashes_in_tx,\n        first_nullifier_in_tx,\n        compute_note_hash,\n        compute_note_nullifier,\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_type_id,\n        packed_note,\n    );\n\n    if discovered_notes.len() == 0 {\n        // A private note message that results in no discovered notes means none of the computed note hashes matched\n        // any unique note hash in the transaction. This could indicate a malformed or malicious message (e.g. a sender\n        // providing bogus note content).\n        aztecnr_warn_log_format!(\n            \"Discarding private note message from tx {0} for contract {1}: no matching note hash found in the tx\",\n        )(\n            [tx_hash, contract_address.to_field()],\n        );\n    } else {\n        aztecnr_debug_log_format!(\n            \"Discovered {0} notes from a private message for contract {1}\",\n        )(\n            [discovered_notes.len() as Field, contract_address.to_field()],\n        );\n    }\n\n    discovered_notes.for_each(|discovered_note| {\n        enqueue_note_for_validation(\n            contract_address,\n            owner,\n            storage_slot,\n            randomness,\n            discovered_note.note_nonce,\n            packed_note,\n            discovered_note.note_hash,\n            discovered_note.inner_nullifier,\n            tx_hash,\n        );\n    });\n}\n"
     },
-    "147": {
+    "148": {
       "function_locations": [
         {
           "name": "process_message_ciphertext",
@@ -640,7 +640,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr",
       "source": "use crate::messages::{\n    discovery::{\n        ComputeNoteHash, ComputeNoteNullifier, CustomMessageHandler, private_events::process_private_event_msg,\n        private_notes::process_private_note_msg,\n    },\n    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN},\n    encryption::{aes128::AES128, message_encryption::MessageEncryption},\n    msg_type::{\n        MIN_CUSTOM_MSG_TYPE_ID, PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    processing::ResolvedTx,\n};\n\nuse crate::logging::{aztecnr_debug_log, aztecnr_warn_log_format};\nuse crate::partial_notes::process_partial_note_private_msg;\nuse crate::protocol::address::AztecAddress;\n\n/// Processes a message that can contain notes, partial notes, or events.\n///\n/// Notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash\n/// in which the notes would've been created (typically the same transaction in which the log was emitted), along with\n/// the list of unique note hashes in said transaction and the `compute_note_hash` and `compute_note_nullifier`\n/// functions. Once discovered, the notes are enqueued for validation.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved\n/// to search for the note's completion public log.\n///\n/// Events are processed by computing an event commitment from the serialized event data and its randomness field, then\n/// enqueueing the event data and commitment for validation.\npub unconstrained fn process_message_ciphertext(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    resolved_tx: ResolvedTx,\n    recipient: AztecAddress,\n) {\n    let message_plaintext_option = AES128::decrypt(message_ciphertext, recipient, contract_address);\n\n    if message_plaintext_option.is_some() {\n        process_message_plaintext(\n            contract_address,\n            compute_note_hash,\n            compute_note_nullifier,\n            process_custom_message,\n            message_plaintext_option.unwrap(),\n            resolved_tx,\n            recipient,\n        );\n    } else {\n        aztecnr_warn_log_format!(\"Could not decrypt message ciphertext from tx {0}, ignoring\")([resolved_tx.tx_hash]);\n    }\n}\n\npub(crate) unconstrained fn process_message_plaintext(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    process_custom_message: Option<CustomMessageHandler>,\n    message_plaintext: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,\n    resolved_tx: ResolvedTx,\n    recipient: AztecAddress,\n) {\n    // The first thing to do after decrypting the message is to determine what type of message we're processing. We\n    // have 3 message types: private notes, partial notes and events.\n\n    // We decode the message to obtain the message type id, metadata and content.\n    let decoded = decode_message(message_plaintext);\n\n    if decoded.is_some() {\n        let (msg_type_id, msg_metadata, msg_content) = decoded.unwrap();\n\n        if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private note msg\");\n\n            process_private_note_msg(\n                contract_address,\n                resolved_tx.tx_hash,\n                resolved_tx.unique_note_hashes_in_tx,\n                resolved_tx.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                msg_metadata,\n                msg_content,\n            );\n        } else if msg_type_id == PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing partial note private msg\");\n\n            process_partial_note_private_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                resolved_tx,\n                recipient,\n            );\n        } else if msg_type_id == PRIVATE_EVENT_MSG_TYPE_ID {\n            aztecnr_debug_log!(\"Processing private event msg\");\n\n            process_private_event_msg(\n                contract_address,\n                msg_metadata,\n                msg_content,\n                resolved_tx.tx_hash,\n            );\n        } else if msg_type_id < MIN_CUSTOM_MSG_TYPE_ID {\n            // The message type ID falls in the range reserved for aztec.nr built-in types but wasn't matched above.\n            // This most likely means the message is malformed or a custom message was incorrectly assigned a reserved\n            // ID. Custom message types must use IDs allocated via `custom_msg_type_id`.\n            aztecnr_warn_log_format!(\n                \"Message type ID {0} is in the reserved range but is not recognized, ignoring. See https://docs.aztec.network/errors/3\",\n            )(\n                [msg_type_id as Field],\n            );\n        } else if process_custom_message.is_some() {\n            process_custom_message.unwrap()(\n                contract_address,\n                msg_type_id,\n                msg_metadata,\n                msg_content,\n                resolved_tx,\n                recipient,\n            );\n        } else {\n            // A custom message was received but no handler is configured. This likely means the contract emits custom\n            // messages but forgot to register a handler via `AztecConfig::custom_message_handler`.\n            aztecnr_warn_log_format!(\n                \"Received custom message with type id {0} but no handler is configured, ignoring. See https://docs.aztec.network/errors/2\",\n            )(\n                [msg_type_id as Field],\n            );\n        }\n    } else {\n        aztecnr_warn_log_format!(\"Could not decode message plaintext from tx {0}, ignoring\")([resolved_tx.tx_hash]);\n    }\n}\n"
     },
-    "148": {
+    "149": {
       "function_locations": [
         {
           "name": "encode_message",
@@ -702,7 +702,77 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "149": {
+    "15": {
+      "function_locations": [
+        {
+          "name": "compute_decomposition",
+          "start": 456
+        },
+        {
+          "name": "decompose_hint",
+          "start": 818
+        },
+        {
+          "name": "lte_hint",
+          "start": 906
+        },
+        {
+          "name": "assert_gt_limbs",
+          "start": 1116
+        },
+        {
+          "name": "decompose",
+          "start": 1725
+        },
+        {
+          "name": "assert_gt",
+          "start": 2431
+        },
+        {
+          "name": "assert_lt",
+          "start": 2837
+        },
+        {
+          "name": "gt",
+          "start": 2901
+        },
+        {
+          "name": "lt",
+          "start": 3405
+        },
+        {
+          "name": "tests::check_decompose",
+          "start": 3678
+        },
+        {
+          "name": "tests::check_lte_hint",
+          "start": 3928
+        },
+        {
+          "name": "tests::check_gt",
+          "start": 4261
+        },
+        {
+          "name": "tests::check_plo_phi",
+          "start": 4591
+        },
+        {
+          "name": "tests::check_decompose_edge_cases",
+          "start": 5086
+        },
+        {
+          "name": "tests::check_decompose_large_values",
+          "start": 5446
+        },
+        {
+          "name": "tests::check_lt_comprehensive",
+          "start": 5807
+        }
+      ],
+      "path": "std/field/bn254.nr",
+      "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n    use crate::internal::test_unconstrained;\n    use super::assert_lt;\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    #[test_unconstrained]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert_lt(0, 1);\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
+    },
+    "150": {
       "function_locations": [
         {
           "name": "extract_many_close_to_uniformly_random_256_bits_using_poseidon2",
@@ -788,77 +858,7 @@
       "path": "/home/aztec-dev/aztec-node/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    /* The output of this function needs to be 32 random bytes.\n     * A single field won't give us 32 bytes of entropy. So we compute two \"random\" fields, by poseidon-hashing\n    * with two different indices. We then extract the last 16 (big endian) bytes of each \"random\" field.\n    * Note: we use to_be_bytes because it's slightly more efficient. But we have to be careful not to take bytes\n    * from the \"big end\", because the \"big\" byte is not uniformly random over the byte: it only has < 6 bits of\n    * randomness, because it's the big end of a 254-bit field element.\n    */\n\n    let mut all_bytes: [[u8; 32]; N] = std::mem::zeroed();\n    std::static_assert(N < 256, \"N too large\");\n    for k in 0..N {\n        let rand1: Field = derive_shared_secret_subkey(s_app, 2 * k);\n        let rand2: Field = derive_shared_secret_subkey(s_app, 2 * k + 1);\n\n        let rand1_bytes: [u8; 32] = rand1.to_be_bytes();\n        let rand2_bytes: [u8; 32] = rand2.to_be_bytes();\n\n        let mut bytes: [u8; 32] = [0; 32];\n        for i in 0..16 {\n            // We take bytes from the \"little end\" of the be-bytes arrays:\n            let j = 32 - i - 1;\n            bytes[i] = rand1_bytes[j];\n            bytes[16 + i] = rand2_bytes[j];\n        }\n\n        all_bytes[k] = bytes;\n    }\n\n    all_bytes\n}\n\nfn derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits<let N: u32>(\n    many_random_256_bits: [[u8; 32]; N],\n) -> [([u8; 16], [u8; 16]); N] {\n    // Many (sym_key, iv) pairs:\n    let mut many_pairs: [([u8; 16], [u8; 16]); N] = std::mem::zeroed();\n    for k in 0..N {\n        let random_256_bits = many_random_256_bits[k];\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n        for i in 0..16 {\n            sym_key[i] = random_256_bits[i];\n            iv[i] = random_256_bits[i + 16];\n        }\n        many_pairs[k] = (sym_key, iv);\n    }\n\n    many_pairs\n}\n\npub fn derive_aes_symmetric_key_and_iv_from_shared_secret<let N: u32>(s_app: Field) -> [([u8; 16], [u8; 16]); N] {\n    let many_random_256_bits: [[u8; 32]; N] = extract_many_close_to_uniformly_random_256_bits_using_poseidon2(s_app);\n\n    derive_aes_symmetric_key_and_iv_from_uniformly_random_256_bits(many_random_256_bits)\n}\n\npub struct AES128 {}\n\nimpl MessageEncryption for AES128 {\n\n    /// AES128-CBC encryption for Aztec protocol messages.\n    ///\n    /// ## Overview\n    ///\n    /// The plaintext is an array of up to `MESSAGE_PLAINTEXT_LEN` (12) fields. The output is always exactly\n    /// `MESSAGE_CIPHERTEXT_LEN` (15) fields, regardless of plaintext size. All output fields except the\n    /// ephemeral public key are uniformly random `Field` values to any observer without knowledge of the\n    /// shared secret, making all encrypted messages indistinguishable by size or content.\n    ///\n    /// ## PKCS#7 Padding\n    ///\n    /// AES operates on 16-byte blocks, so the plaintext must be padded to a multiple of 16. PKCS#7 padding always\n    /// adds at least 1 byte (so the receiver can always detect and strip it), which means:\n    /// - 1 B plaintext  -> 15 B padding -> 16 B total\n    /// - 15 B plaintext ->  1 B padding -> 16 B total\n    /// - 16 B plaintext -> 16 B padding -> 32 B total (full extra block)\n    ///\n    /// In general: if the plaintext is already a multiple of 16, a full 16-byte padding block is appended.\n    ///\n    /// ## Encryption Steps\n    ///\n    /// **1. Body encryption.** The plaintext fields are serialized to bytes (32 bytes per field) and AES-128-CBC\n    /// encrypted. Since 32 is a multiple of 16, PKCS#7 always adds a full 16-byte padding block (see above):\n    ///\n    /// ```text\n    /// +---------------------------------------------+\n    /// |                   body ct                    |\n    /// |            PlaintextLen*32 + 16 B            |\n    /// +-------------------------------+--------------+\n    /// | encrypted plaintext fields    | PKCS#7 (16B) |\n    /// | (serialized at 32 B each)     |              |\n    /// +-------------------------------+--------------+\n    /// ```\n    ///\n    /// **2. Header encryption.** The byte length of `body_ct` is stored as a 2-byte big-endian integer. This 2-byte\n    /// header plaintext is then AES-encrypted; PKCS#7 pads the remaining 14 bytes to fill one 16-byte AES block,\n    /// producing a 16-byte header ciphertext:\n    ///\n    /// ```text\n    /// +---------------------------+\n    /// |         header ct         |\n    /// |            16 B           |\n    /// +--------+------------------+\n    /// | body ct| PKCS#7 (14B)     |\n    /// | length |                  |\n    /// | (2 B)  |                  |\n    /// +--------+------------------+\n    /// ```\n    ///\n    /// ## Wire Format\n    ///\n    /// Messages are transmitted as fields, not bytes. A field is ~254 bits and can safely store 31 whole bytes, so\n    /// we need to pack our byte data into 31-byte chunks. This packing drives the wire format.\n    ///\n    /// **Step 1 -- Assemble bytes.** The ciphertexts are laid out in a byte array, padded with zero bytes to a\n    /// multiple of 31 so it divides evenly into fields:\n    ///\n    /// ```text\n    /// +------------+-------------------------+---------+\n    /// | header ct  |        body ct          | byte pad|\n    /// |   16 B     | PlaintextLen*32 + 16 B  | (zeros) |\n    /// +------------+-------------------------+---------+\n    /// |<-------- padded to a multiple of 31 B -------->|\n    /// ```\n    ///\n    /// **Step 2 -- Pack and mask.** The byte array is split into 31-byte chunks, each stored in one field. A\n    /// Poseidon2-derived mask (see `derive_shared_secret_field_mask`) is added to each so that the resulting\n    /// fields appear as uniformly random `Field` values to any observer without knowledge of the shared secret,\n    /// hiding the fact that the underlying ciphertext consists of 128-bit AES blocks.\n    ///\n    /// **Step 3 -- Assemble ciphertext.** The ephemeral public key x-coordinate is prepended and random field padding\n    /// is appended to fill to 15 fields:\n    ///\n    /// ```text\n    /// +----------+-------------------------+-------------------+\n    /// | eph_pk.x |  masked message fields   | random field pad  |\n    /// |          | (packed 31 B per field)  |  (fills to 15)    |\n    /// +----------+-------------------------+-------------------+\n    /// |<---------- MESSAGE_CIPHERTEXT_LEN = 15 fields -------->|\n    /// ```\n    ///\n    /// ## Key Derivation\n    ///\n    /// The raw ECDH shared secret point is first app-siloed into a scalar `s_app` by hashing with the contract\n    /// address (see\n    /// [`compute_app_siloed_shared_secret`](crate::keys::ecdh_shared_secret::compute_app_siloed_shared_secret)).\n    /// Two (key, IV) pairs are then derived from `s_app` via indexed Poseidon2 hashing: one pair for the body\n    /// ciphertext and one for the header ciphertext.\n    fn encrypt<let PlaintextLen: u32>(\n        plaintext: [Field; PlaintextLen],\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> [Field; MESSAGE_CIPHERTEXT_LEN] {\n        std::static_assert(\n            PlaintextLen <= MESSAGE_PLAINTEXT_LEN,\n            \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\",\n        );\n\n        // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes. (This process is then\n        // reversed when processing the message in `process_message_ciphertext`)\n        let plaintext_bytes = encode_fields_as_bytes(plaintext);\n\n        // Derive ECDH shared secret with recipient using a fresh ephemeral keypair.\n        let (eph_sk, eph_pk) = generate_positive_ephemeral_key_pair();\n\n        let raw_shared_secret = derive_ecdh_shared_secret(\n            eph_sk,\n            recipient\n                .to_address_point()\n                .unwrap_or_else(|| {\n                    aztecnr_warn_log_format!(\n                        \"Attempted to encrypt message for an invalid recipient ({0})\",\n                    )(\n                        [recipient.to_field()],\n                    );\n\n                    // Safety: if the recipient is an invalid address, then it is not possible to encrypt a message for\n                    // them because we cannot establish a shared secret. This is never expected to occur during normal\n                    // operation. However, it is technically possible for us to receive an invalid address, and we must\n                    // therefore handle it. We could simply fail, but that'd introduce a potential security issue in\n                    // which an attacker forces a contract to encrypt a message for an invalid address, resulting in an\n                    // impossible transaction - this is sometimes called a 'king of the hill' attack. We choose instead\n                    // to not fail and encrypt the plaintext regardless using the shared secret that results from a\n                    // random valid address. The sender is free to choose this address and hence shared secret, but\n                    // this has no security implications as they already know not only the full plaintext but also the\n                    // ephemeral private key anyway.\n                    unsafe {\n                        random_address_point()\n                    }\n                })\n                .inner,\n        );\n\n        let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n        // It is safe to derive AES keys from `s_app` using Poseidon2 because `s_app` was derived from an ECDH shared\n        // secret using an AztecAddress (the recipient). See the block comment in\n        // `extract_many_close_to_uniformly_random_256_bits_using_poseidon2` for more info.\n        let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n        let (body_sym_key, body_iv) = pairs[0];\n        let (header_sym_key, header_iv) = pairs[1];\n\n        let ciphertext_bytes = aes128_encrypt(plaintext_bytes, body_iv, body_sym_key);\n\n        // Each plaintext field is 32 bytes (a multiple of the 16-byte AES block\n        // size), so PKCS#7 always appends a full 16-byte padding block:\n        //   |ciphertext| = PlaintextLen*32 + 16 = 16 * (1 + PlaintextLen*32 / 16)\n        std::static_assert(\n            ciphertext_bytes.len() == 16 * (1 + (PlaintextLen * 32) / 16),\n            \"unexpected ciphertext length\",\n        );\n\n        // Encrypt a 2-byte header containing the body ciphertext length.\n        let header_plaintext = encode_header(ciphertext_bytes.len());\n\n        // Note: the aes128_encrypt builtin fn automatically appends bytes to the input, according to pkcs#7; hence why\n        // the output `header_ciphertext_bytes` is 16 bytes larger than the input in this case.\n        let header_ciphertext_bytes = aes128_encrypt(header_plaintext, header_iv, header_sym_key);\n        // Verify expected header ciphertext size at compile time.\n        std::static_assert(\n            header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n            \"unexpected ciphertext header length\",\n        );\n\n        // Assemble the message byte array:\n        //  [header_ct (16B)] [body_ct] [padding to mult of 31]\n        let message_bytes_padding_to_mult_31 = get_arr_of_size__message_bytes_padding__from_PT::<PlaintextLen * 32>();\n\n        let mut message_bytes = get_arr_of_size__message_bytes__from_PT::<PlaintextLen * 32>();\n\n        std::static_assert(\n            message_bytes.len() % 31 == 0,\n            \"Unexpected error: message_bytes.len() should be divisible by 31, by construction.\",\n        );\n\n        let mut offset = 0;\n        for i in 0..header_ciphertext_bytes.len() {\n            message_bytes[offset + i] = header_ciphertext_bytes[i];\n        }\n        offset += header_ciphertext_bytes.len();\n\n        for i in 0..ciphertext_bytes.len() {\n            message_bytes[offset + i] = ciphertext_bytes[i];\n        }\n        offset += ciphertext_bytes.len();\n\n        for i in 0..message_bytes_padding_to_mult_31.len() {\n            message_bytes[offset + i] = message_bytes_padding_to_mult_31[i];\n        }\n        offset += message_bytes_padding_to_mult_31.len();\n\n        // Ideally we would be able to have a static assert where we check that the offset would be such that we've\n        // written to the entire log_bytes array, but we cannot since Noir does not treat the offset as a comptime\n        // value (despite the values that it goes through being known at each stage). We instead check that the\n        // computation used to obtain the offset computes the expected value (which we _can_ do in a static check), and\n        // then add a cheap runtime check to also validate that the offset matches this.\n        std::static_assert(\n            header_ciphertext_bytes.len() + ciphertext_bytes.len() + message_bytes_padding_to_mult_31.len()\n                == message_bytes.len(),\n            \"unexpected message length\",\n        );\n        assert(offset == message_bytes.len(), \"unexpected encrypted message length\");\n\n        // Pack message bytes into fields (31 bytes per field) and prepend eph_pk.x.\n        let message_bytes_as_fields = encode_bytes_as_fields(message_bytes);\n\n        let mut ciphertext: [Field; MESSAGE_CIPHERTEXT_LEN] = [0; MESSAGE_CIPHERTEXT_LEN];\n\n        ciphertext[0] = eph_pk.x;\n\n        // Mask each content field with a Poseidon2-derived value, so that they appear as uniformly random `Field`\n        // values\n        let mut offset = 1;\n        for i in 0..message_bytes_as_fields.len() {\n            let mask = derive_shared_secret_field_mask(s_app, i as u32);\n            ciphertext[offset + i] = message_bytes_as_fields[i] + mask;\n        }\n        offset += message_bytes_as_fields.len();\n\n        // Pad with random fields so that padding is indistinguishable from masked data fields.\n        for i in offset..MESSAGE_CIPHERTEXT_LEN {\n            // Safety: we assume that the sender wants for the message to be private - a malicious one could simply\n            // reveal its contents publicly. It is therefore fine to trust the sender to provide random padding.\n            ciphertext[i] = unsafe { random() };\n        }\n\n        ciphertext\n    }\n\n    unconstrained fn decrypt(\n        ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n        recipient: AztecAddress,\n        contract_address: AztecAddress,\n    ) -> Option<BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>> {\n        // Extract the ephemeral public key x-coordinate and masked fields, returning None for empty ciphertext.\n        if ciphertext.len() > 0 {\n            let masked_fields: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS> =\n                array::subbvec(ciphertext, EPH_PK_X_SIZE_IN_FIELDS);\n            Option::some((ciphertext.get(0), masked_fields))\n        } else {\n            Option::none()\n        }\n            .and_then(|(eph_pk_x, masked_fields)| {\n                // With the x-coordinate of the ephemeral public key we can reconstruct the point as we know that the\n                // y-coordinate must be positive. This may fail however, as not all x-coordinates are on the curve. In\n                // that case, we simply return `Option::none`. Secret derivation may also fail when the PXE does not\n                // hold the recipient's keys (e.g. when syncing the scope of an address we don't control), in which\n                // case the message is undecryptable and equally skipped.\n                point_from_x_coord_and_sign(eph_pk_x, true)\n                    .and_then(|eph_pk| get_shared_secret(recipient, eph_pk, contract_address))\n                    .and_then(|s_app| {\n                        let unmasked_fields = masked_fields.mapi(|i, field| {\n                            let unmasked = unmask_field(s_app, i, field);\n                            // If we failed to unmask the field, we are dealing with the random padding. We'll ignore it\n                            // later, so we can simply set it to 0\n                            unmasked.unwrap_or(0)\n                        });\n                        let ciphertext_without_eph_pk_x = decode_bytes_from_fields(unmasked_fields);\n\n                        // Derive symmetric keys:\n                        let pairs = derive_aes_symmetric_key_and_iv_from_shared_secret::<2>(s_app);\n                        let (body_sym_key, body_iv) = pairs[0];\n                        let (header_sym_key, header_iv) = pairs[1];\n\n                        // Extract the header ciphertext\n                        let header_start = 0;\n                        let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n                            array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n                        // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's\n                        // designed to work with messages with unknown length at compile time. This would not be\n                        // necessary here as the header ciphertext length is fixed. But we do it anyway to not have to\n                        // have duplicate oracles.\n                        let header_ciphertext_bvec =\n                            BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(header_ciphertext);\n\n                        try_aes128_decrypt(header_ciphertext_bvec, header_iv, header_sym_key)\n                        // Extract ciphertext length from header (2 bytes, big-endian)\n                        .and_then(|header_plaintext| extract_ciphertext_length(header_plaintext))\n                            .filter(|ciphertext_length| ciphertext_length <= MESSAGE_PLAINTEXT_SIZE_IN_BYTES)\n                            .map(|ciphertext_length| {\n                                // Extract and decrypt main ciphertext\n                                let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n                                let ciphertext_with_padding: [u8; MESSAGE_PLAINTEXT_SIZE_IN_BYTES] =\n                                    array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n                                BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length)\n                            })\n                            // Decrypt main ciphertext and return it\n                            .and_then(|ciphertext| try_aes128_decrypt(ciphertext, body_iv, body_sym_key))\n                            // Convert bytes back to fields (32 bytes per field). Returns None if the actual bytes are\n                            // not valid.\n                            .and_then(|plaintext_bytes| try_decode_fields_from_bytes(plaintext_bytes))\n                    })\n            })\n    }\n}\n\n/// Encodes the body ciphertext length into a 2-byte big-endian header.\nfn encode_header(ciphertext_length: u32) -> [u8; 2] {\n    [(ciphertext_length >> 8) as u8, ciphertext_length as u8]\n}\n\n/// Extracts the body ciphertext length from a decrypted header as a 2-byte big-endian integer.\n///\n/// Returns `Option::none()` if the header has fewer than 2 bytes.\nunconstrained fn extract_ciphertext_length<let N: u32>(header: BoundedVec<u8, N>) -> Option<u32> {\n    if header.len() >= 2 {\n        Option::some(((header.get(0) as u32) << 8) | (header.get(1) as u32))\n    } else {\n        Option::none()\n    }\n}\n\n/// 2^248: upper bound for values that fit in 31 bytes\nglobal TWO_POW_248: Field = 2.pow_32(248);\n\n/// Removes the Poseidon2-derived mask from a ciphertext field. Returns the unmasked value if it fits in 31 bytes\n/// (a content field), or `None` if it doesn't (random padding). Unconstrained to prevent accidental use in\n/// constrained context.\nunconstrained fn unmask_field(s_app: Field, index: u32, masked: Field) -> Option<Field> {\n    let unmasked = masked - derive_shared_secret_field_mask(s_app, index);\n    if unmasked.lt(TWO_POW_248) {\n        Option::some(unmasked)\n    } else {\n        Option::none()\n    }\n}\n\n/// Produces a random valid address point, i.e. one that is on the curve. This is equivalent to calling\n/// [`AztecAddress::to_address_point`] on a random valid address.\nunconstrained fn random_address_point() -> AddressPoint {\n    let mut result = std::mem::zeroed();\n\n    loop {\n        // We simply produce random x coordinates until we find one that is on the curve. About half of the x\n        // coordinates fulfill this condition, so this should only take a few iterations at most.\n        let x_coord = random();\n        let point = point_from_x_coord_and_sign(x_coord, true);\n        if point.is_some() {\n            result = AddressPoint { inner: point.unwrap() };\n            break;\n        }\n    }\n\n    result\n}\n\nmod test {\n    use crate::{\n        ephemeral::EphemeralArray,\n        keys::ecdh_shared_secret::{compute_app_siloed_shared_secret, derive_ecdh_shared_secret},\n        messages::{\n            encoding::{HEADER_CIPHERTEXT_SIZE_IN_BYTES, MESSAGE_PLAINTEXT_LEN, MESSAGE_PLAINTEXT_SIZE_IN_BYTES},\n            encryption::message_encryption::MessageEncryption,\n        },\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use super::{AES128, encode_header, random_address_point};\n    use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n    #[test]\n    unconstrained fn encrypt_decrypt_deterministic() {\n        let env = TestEnvironment::new();\n\n        // Message decryption requires oracles that are only available during private execution\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n\n            let recipient = AztecAddress::from_field(\n                0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n            );\n\n            // Mock random values for deterministic test\n            let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n            let _ = OracleMock::mock(\"aztec_misc_getRandomField\").returns(eph_sk).times(1);\n\n            let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n            let _ = OracleMock::mock(\"aztec_misc_getRandomField\").returns(randomness).times(1000000);\n\n            // Encrypt the message\n            let encrypted_message = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            // Compute the same app-siloed shared secret that the oracle would return\n            let raw_shared_secret = derive_ecdh_shared_secret(\n                EmbeddedCurveScalar::from_field(eph_sk),\n                recipient.to_address_point().unwrap().inner,\n            );\n            let s_app = compute_app_siloed_shared_secret(raw_shared_secret, contract_address);\n\n            // The shared-secrets oracle is batched: it returns a slot pointing at an EphemeralArray\n            // populated with the per-key results. Set up that array with the single expected `s_app`\n            // and mock the oracle to return its slot.\n            let response_slot: Field = 99;\n            let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n            response_array.push(s_app);\n            let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n\n            // Decrypt the message\n            let decrypted = AES128::decrypt(encrypted_message, recipient, contract_address).unwrap();\n\n            // The decryption function spits out a BoundedVec because it's designed to work with messages with unknown\n            // length at compile time. For this reason we need to convert the original input to a BoundedVec.\n            let plaintext_bvec = BoundedVec::<Field, MESSAGE_PLAINTEXT_LEN>::from_array(plaintext);\n\n            // Verify decryption matches original plaintext\n            assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n            // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n            // static methods of the struct).\n            let _ = AES128 {};\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_random() {\n        // Same as `encrypt_decrypt_deterministic`, except we don't mock any of the oracles and rely on\n        // `TestEnvironment` instead.\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn encrypt_to_invalid_address() {\n        // x = 3 is a non-residue for this curve, resulting in an invalid address\n        let invalid_address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n\n        let _ = AES128::encrypt([1, 2, 3, 4], invalid_address, contract_address);\n    }\n\n    // Documents the PKCS#7 padding behavior that `encrypt` relies on (see its static_assert).\n    #[test]\n    fn pkcs7_padding_always_adds_at_least_one_byte() {\n        let key = [0 as u8; 16];\n        let iv = [0 as u8; 16];\n\n        // 1 byte input + 15 bytes padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 1], iv, key).len(), 16);\n\n        // 15 bytes input + 1 byte padding = 16 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 15], iv, key).len(), 16);\n\n        // 16 bytes input (block-aligned) + full 16-byte padding block = 32 bytes\n        assert_eq(std::aes128::aes128_encrypt([0; 16], iv, key).len(), 32);\n    }\n\n    #[test]\n    unconstrained fn encrypt_decrypt_max_size_plaintext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let mut plaintext = [0; MESSAGE_PLAINTEXT_LEN];\n            for i in 0..MESSAGE_PLAINTEXT_LEN {\n                plaintext[i] = i as Field;\n            }\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            assert_eq(\n                AES128::decrypt(\n                    BoundedVec::from_array(ciphertext),\n                    recipient,\n                    contract_address,\n                )\n                    .unwrap(),\n                BoundedVec::from_array(plaintext),\n            );\n        });\n    }\n\n    #[test(should_fail_with = \"Plaintext length exceeds MESSAGE_PLAINTEXT_LEN\")]\n    unconstrained fn encrypt_oversized_plaintext() {\n        let address = AztecAddress { inner: 3 };\n        let contract_address = AztecAddress { inner: 42 };\n        let plaintext: [Field; MESSAGE_PLAINTEXT_LEN + 1] = [0; MESSAGE_PLAINTEXT_LEN + 1];\n        let _ = AES128::encrypt(plaintext, address, contract_address);\n    }\n\n    #[test]\n    unconstrained fn random_address_point_produces_valid_points() {\n        // About half of random addresses are invalid, so testing just a couple gives us high confidence that\n        // `random_address_point` is indeed producing valid addresses.\n        for _ in 0..10 {\n            let random_address = AztecAddress { inner: random_address_point().inner.x };\n            assert(random_address.to_address_point().is_some());\n        }\n    }\n\n    #[test]\n    unconstrained fn decrypt_invalid_ephemeral_public_key() {\n        let mut env = TestEnvironment::new();\n\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3, 4];\n            let ciphertext = AES128::encrypt(plaintext, recipient, contract_address);\n\n            // The first field of the ciphertext is the x-coordinate of the ephemeral public key. We set it to a known\n            // non-residue (3), causing `decrypt` to fail to produce a decryption shared secret.\n            let mut bad_ciphertext = BoundedVec::from_array(ciphertext);\n            bad_ciphertext.set(0, 3);\n\n            assert(AES128::decrypt(bad_ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_ciphertext() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            assert(AES128::decrypt(BoundedVec::new(), recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header AES decrypt oracle to return an empty result. The TS oracle never throws on invalid\n    // input: it decrypts to garbage bytes or returns empty\n    #[test]\n    unconstrained fn decrypt_returns_none_on_empty_header() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let empty_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::new();\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(empty_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n    // Mocks the header oracle to return a 2-byte header that decodes to a ciphertext_length one past the maximum\n    // allowed value, verifying the edge case is handled correctly.\n    #[test]\n    unconstrained fn decrypt_returns_none_on_oversized_ciphertext_length() {\n        let mut env = TestEnvironment::new();\n        let recipient = env.create_light_account();\n\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let plaintext = [1, 2, 3];\n            let ciphertext = BoundedVec::from_array(AES128::encrypt(plaintext, recipient, contract_address));\n\n            let bad_header = BoundedVec::<u8, HEADER_CIPHERTEXT_SIZE_IN_BYTES>::from_array(encode_header(\n                MESSAGE_PLAINTEXT_SIZE_IN_BYTES + 1,\n            ));\n            let _ = OracleMock::mock(\"aztec_utl_decryptAes128\").returns(Option::some(bad_header)).times(1);\n\n            assert(AES128::decrypt(ciphertext, recipient, contract_address).is_none());\n        });\n    }\n\n}\n"
     },
-    "15": {
-      "function_locations": [
-        {
-          "name": "compute_decomposition",
-          "start": 456
-        },
-        {
-          "name": "decompose_hint",
-          "start": 818
-        },
-        {
-          "name": "lte_hint",
-          "start": 906
-        },
-        {
-          "name": "assert_gt_limbs",
-          "start": 1116
-        },
-        {
-          "name": "decompose",
-          "start": 1725
-        },
-        {
-          "name": "assert_gt",
-          "start": 2431
-        },
-        {
-          "name": "assert_lt",
-          "start": 2837
-        },
-        {
-          "name": "gt",
-          "start": 2901
-        },
-        {
-          "name": "lt",
-          "start": 3405
-        },
-        {
-          "name": "tests::check_decompose",
-          "start": 3678
-        },
-        {
-          "name": "tests::check_lte_hint",
-          "start": 3928
-        },
-        {
-          "name": "tests::check_gt",
-          "start": 4261
-        },
-        {
-          "name": "tests::check_plo_phi",
-          "start": 4591
-        },
-        {
-          "name": "tests::check_decompose_edge_cases",
-          "start": 5086
-        },
-        {
-          "name": "tests::check_decompose_large_values",
-          "start": 5446
-        },
-        {
-          "name": "tests::check_lt_comprehensive",
-          "start": 5807
-        }
-      ],
-      "path": "std/field/bn254.nr",
-      "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n    use crate::internal::test_unconstrained;\n    use super::assert_lt;\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    #[test_unconstrained]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert_lt(0, 1);\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
-    },
-    "154": {
+    "155": {
       "function_locations": [
         {
           "name": "encode_private_event_message",
@@ -892,7 +892,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/logs/event.nr",
       "source": "use crate::{\n    event::{event_interface::EventInterface, EventSelector},\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n    },\n    utils::array,\n};\nuse crate::protocol::traits::{FromField, Serialize, ToField};\n\n/// The number of fields in a private event message content that are not the event's serialized representation (1 field\n/// for randomness).\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 1;\npub(crate) global PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 0;\n\n/// The maximum length of the packed representation of an event's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, randomness, etc.).\npub global MAX_EVENT_SERIALIZED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_event_message`].\npub fn encode_private_event_message<Event>(\n    event: Event,\n    randomness: Field,\n) -> [Field; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Event: EventInterface + Serialize,\n{\n    std::static_assert(\n        <Event as Serialize>::N <= MAX_EVENT_SERIALIZED_LEN,\n        \"event's serialized length exceeds the maximum allowed for private events\",\n    );\n\n    // We use `Serialize` because we want for events to be processable by off-chain actors, e.g. block explorers,\n    // wallets and apps, without having to rely on contract invocation. If we used `Packable` we'd need to call utility\n    // functions in order to unpack events, which would introduce a level of complexity we don't currently think is\n    // worth the savings in DA (for public events) and proving time (when encrypting private event messages).\n    let serialized_event = event.serialize();\n\n    // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n        \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_plaintext = [0; PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Event as Serialize>::N];\n    msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n\n    for i in 0..serialized_event.len() {\n        msg_plaintext[PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = serialized_event[i];\n    }\n\n    // The event type id is stored in the message metadata\n    encode_message(\n        PRIVATE_EVENT_MSG_TYPE_ID,\n        Event::get_event_type_id().to_field() as u64,\n        msg_plaintext,\n    )\n}\n\n/// Decodes the plaintext from a private event message (i.e. one of type [`PRIVATE_EVENT_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` is too short to contain the reserved fields. This plaintext is meant to have\n/// originated from [`encode_private_event_message`].\n///\n/// Note that while [`encode_private_event_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_event_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(EventSelector, Field, BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>)> {\n    if msg_content.len() < PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let event_type_id = EventSelector::from_field(msg_metadata as Field);\n\n        // If PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // destructuring of the private event message encoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 1,\n            \"unexpected value for PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let randomness = msg_content.get(PRIVATE_EVENT_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let serialized_event = array::subbvec(msg_content, PRIVATE_EVENT_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((event_type_id, randomness, serialized_event))\n    }\n}\n\nmod test {\n    use crate::{\n        event::{event_interface::EventInterface, EventSelector},\n        messages::{\n            encoding::decode_message,\n            logs::event::{decode_private_event_message, encode_private_event_message},\n            msg_type::PRIVATE_EVENT_MSG_TYPE_ID,\n        },\n    };\n    use crate::protocol::traits::{FromField, Serialize};\n    use crate::test::mocks::mock_event::MockEvent;\n\n    global VALUE: Field = 7;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let event = MockEvent::new(VALUE).build_event();\n\n        let message_plaintext = encode_private_event_message(event, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_EVENT_MSG_TYPE_ID);\n\n        let (event_type_id, randomness, serialized_event) =\n            decode_private_event_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(event_type_id, MockEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event, BoundedVec::from_array(event.serialize()));\n    }\n\n    #[derive(Serialize)]\n    struct EmptyEvent {}\n\n    impl EventInterface for EmptyEvent {\n        fn get_event_type_id() -> EventSelector {\n            EventSelector::from_field(90)\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_empty_event() {\n        let message_plaintext = encode_private_event_message(EmptyEvent {}, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_EVENT_MSG_TYPE_ID);\n\n        let (event_type_id, randomness, serialized_event) =\n            decode_private_event_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(event_type_id, EmptyEvent::get_event_type_id());\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_event_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([RANDOMNESS]);\n\n        let (_, randomness, serialized_event) = decode_private_event_message(0, content).unwrap();\n\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(serialized_event.len(), 0);\n    }\n}\n"
     },
-    "156": {
+    "157": {
       "function_locations": [
         {
           "name": "encode_private_note_message_with_msg_type_id",
@@ -950,7 +950,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/logs/note.nr",
       "source": "use crate::{\n    messages::{\n        encoding::{encode_message, MAX_MESSAGE_CONTENT_LEN, MESSAGE_EXPANDED_METADATA_LEN},\n        msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n    },\n    note::note_interface::NoteType,\n    utils::array,\n};\nuse crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n\n/// The number of fields in a private note message content that are not the note's packed representation.\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN: u32 = 3;\n\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX: u32 = 0;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX: u32 = 1;\npub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 2;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the message (e.g. message type id, storage slot, randomness, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;\n\n/// Creates the plaintext for a private note message with the given `msg_type_id`.\n///\n/// Shared encoder used by [`encode_private_note_message`] and by custom message handlers that use the same format as\n/// standard private note message but perform additional validation logic.\npub fn encode_private_note_message_with_msg_type_id<Note>(\n    msg_type_id: u64,\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    let packed_note = note.pack();\n\n    // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n    // encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n        \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n    );\n\n    let mut msg_content = [0; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N];\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX] = owner.to_field();\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX] = storage_slot;\n    msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX] = randomness;\n    for i in 0..packed_note.len() {\n        msg_content[PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + i] = packed_note[i];\n    }\n\n    // Notes use the note type id for metadata\n    encode_message(msg_type_id, Note::get_id() as u64, msg_content)\n}\n\n/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// This plaintext is meant to be decoded via [`decode_private_note_message`].\npub fn encode_private_note_message<Note>(\n    note: Note,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]\nwhere\n    Note: NoteType + Packable,\n{\n    encode_private_note_message_with_msg_type_id(\n        PRIVATE_NOTE_MSG_TYPE_ID,\n        note,\n        owner,\n        storage_slot,\n        randomness,\n    )\n}\n\n/// Decodes the plaintext from a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).\n///\n/// Returns `None` if `msg_content` is too short to contain the reserved fields. This plaintext is meant to have\n/// originated from [`encode_private_note_message`].\n///\n/// Note that while [`encode_private_note_message`] returns a fixed-size array, this function takes a [`BoundedVec`]\n/// instead. This is because when decoding we're typically processing runtime-sized plaintexts, more specifically,\n/// those that originate from [`crate::messages::encryption::message_encryption::MessageEncryption::decrypt`].\npub(crate) unconstrained fn decode_private_note_message(\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n) -> Option<(Field, AztecAddress, Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>)> {\n    if msg_content.len() < PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN {\n        Option::none()\n    } else {\n        let note_type_id = msg_metadata as Field; // TODO: make note type id not be a full field\n\n        // If PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN is changed, causing the assertion below to fail, then the\n        // decoding below must be updated as well.\n        std::static_assert(\n            PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN == 3,\n            \"unexpected value for PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN\",\n        );\n\n        let owner = AztecAddress::from_field(msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_OWNER_INDEX));\n        let storage_slot = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_STORAGE_SLOT_INDEX);\n        let randomness = msg_content.get(PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX);\n        let packed_note = array::subbvec(msg_content, PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN);\n\n        Option::some((note_type_id, owner, storage_slot, randomness, packed_note))\n    }\n}\n\nmod test {\n    use crate::{\n        messages::{\n            encoding::decode_message,\n            logs::note::{decode_private_note_message, encode_private_note_message, MAX_NOTE_PACKED_LEN},\n            msg_type::PRIVATE_NOTE_MSG_TYPE_ID,\n        },\n        note::note_interface::NoteType,\n    };\n    use crate::protocol::{address::AztecAddress, traits::{FromField, Packable, ToField}};\n    use crate::test::mocks::mock_note::MockNote;\n\n    global VALUE: Field = 7;\n    global OWNER: AztecAddress = AztecAddress::from_field(8);\n    global STORAGE_SLOT: Field = 9;\n    global RANDOMNESS: Field = 10;\n\n    #[test]\n    unconstrained fn encode_decode() {\n        let note = MockNote::new(VALUE).build_note();\n\n        let message_plaintext = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n\n        let (msg_type_id, msg_metadata, msg_content) =\n            decode_message(BoundedVec::from_array(message_plaintext)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MockNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(note.pack()));\n    }\n\n    #[derive(Packable)]\n    struct MaxSizeNote {\n        data: [Field; MAX_NOTE_PACKED_LEN],\n    }\n\n    impl NoteType for MaxSizeNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_max_size_note() {\n        let mut data = [0; MAX_NOTE_PACKED_LEN];\n        for i in 0..MAX_NOTE_PACKED_LEN {\n            data[i] = i as Field;\n        }\n        let note = MaxSizeNote { data };\n\n        let encoded = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n        let (msg_type_id, msg_metadata, msg_content) = decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, MaxSizeNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note, BoundedVec::from_array(data));\n    }\n\n    #[derive(Packable)]\n    struct OversizedNote {\n        data: [Field; MAX_NOTE_PACKED_LEN + 1],\n    }\n\n    impl NoteType for OversizedNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test(should_fail_with = \"Invalid message content: it must have a length of at most MAX_MESSAGE_CONTENT_LEN\")]\n    fn encode_oversized_note_fails() {\n        let note = OversizedNote { data: [0; MAX_NOTE_PACKED_LEN + 1] };\n        let _ = encode_private_note_message(note, OWNER, STORAGE_SLOT, RANDOMNESS);\n    }\n\n    #[derive(Packable)]\n    struct EmptyNote {}\n\n    impl NoteType for EmptyNote {\n        fn get_id() -> Field {\n            0\n        }\n    }\n\n    #[test]\n    unconstrained fn encode_decode_empty_note() {\n        let encoded = encode_private_note_message(EmptyNote {}, OWNER, STORAGE_SLOT, RANDOMNESS);\n        let (msg_type_id, msg_metadata, msg_content) = decode_message(BoundedVec::from_array(encoded)).unwrap();\n\n        assert_eq(msg_type_id, PRIVATE_NOTE_MSG_TYPE_ID);\n\n        let (note_type_id, owner, storage_slot, randomness, packed_note) =\n            decode_private_note_message(msg_metadata, msg_content).unwrap();\n\n        assert_eq(note_type_id, EmptyNote::get_id());\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn decode_empty_content_returns_none() {\n        let empty = BoundedVec::new();\n        assert(decode_private_note_message(0, empty).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_with_fewer_than_reserved_fields_returns_none() {\n        let content = BoundedVec::from_array([0, 0]);\n        assert(decode_private_note_message(0, content).is_none());\n    }\n\n    #[test]\n    unconstrained fn decode_succeeds_with_only_reserved_fields() {\n        let content = BoundedVec::from_array([OWNER.to_field(), STORAGE_SLOT, RANDOMNESS]);\n\n        let (_, owner, storage_slot, randomness, packed_note) = decode_private_note_message(0, content).unwrap();\n\n        assert_eq(owner, OWNER);\n        assert_eq(storage_slot, STORAGE_SLOT);\n        assert_eq(randomness, RANDOMNESS);\n        assert_eq(packed_note.len(), 0);\n    }\n}\n"
     },
-    "157": {
+    "158": {
       "function_locations": [
         {
           "name": "encode_partial_note_private_message",
@@ -1250,7 +1250,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    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_le_bytes\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_be_bytes\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes\n        static_assert(\n            N <= modulus_be_bytes().len(),\n            \"N must be less than or equal to modulus_be_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a little endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_le_bytes_checked\n    pub fn from_le_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes_checked\n        let p = modulus_le_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[N - 1 - i] != p[N - 1 - i] {\n                    assert(\n                        bytes[N - 1 - i] < p[N - 1 - i],\n                        \"input bytes are not a canonical field representation\",\n                    );\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_le_bytes(bytes)\n    }\n\n    /// Convert a big endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_be_bytes_checked\n    pub fn from_be_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes_checked\n        let p = modulus_be_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[i] != p[i] {\n                    assert(bytes[i] < p[i], \"input bytes are not a canonical field representation\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_be_bytes(bytes)\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_be_bits();\n        assert_eq(bits, [false, false, false, false, false, false, true, false]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_le_bits();\n        assert_eq(bits, [false, true, false, false, false, false, false, false]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_le_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_be_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_be_bytes();\n    }\n\n    #[test]\n    unconstrained fn zero_field_to_bytes_zero_limbs_unconstrained() {\n        assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n    }\n\n    #[test]\n    fn zero_field_to_bytes_zero_limbs_constrained() {\n        assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n    }\n\n    #[test]\n    fn zero_field_to_bytes_zero_limbs_comptime() {\n        let _: [u8; 0] = comptime { (0 as Field).to_le_bytes() };\n        let _: [u8; 0] = comptime { (0 as Field).to_be_bytes() };\n        let _: [bool; 0] = comptime { (0 as Field).to_le_bits() };\n        let _: [bool; 0] = comptime { (0 as Field).to_be_bits() };\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n            let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n            let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n            let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n            let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_bytes_checked_small_n() {\n        // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n        // variants behave identically to the unchecked ones.\n        let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n        assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n        let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n        assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn max_bit_size_too_large() {\n        let x: Field = 0x010000;\n        x.assert_max_bit_size::<16>();\n    }\n\n}\n"
     },
-    "164": {
+    "165": {
       "function_locations": [
         {
           "name": "enqueue_note_for_validation",
@@ -1276,7 +1276,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/processing/mod.nr",
       "source": "pub(crate) mod event_validation_request;\npub mod offchain;\n\npub use crate::oracle::tx_resolution::ResolvedTx;\n\nmod note_validation_request;\npub(crate) use note_validation_request::NoteValidationRequest;\n\npub mod log_retrieval_request;\npub mod log_retrieval_response;\npub(crate) mod pending_tagged_log;\npub(crate) mod provided_secret;\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    event::EventSelector,\n    messages::{\n        encoding::MESSAGE_CIPHERTEXT_LEN,\n        logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},\n        processing::{log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse},\n    },\n    oracle::message_processing,\n    partial_notes::DeliveredPendingPartialNote,\n};\nuse crate::note::partial_note::DOM_SEP__NOTE_COMPLETION_LOG_TAG;\nuse crate::protocol::{\n    address::AztecAddress,\n    hash::{compute_log_tag, sha256_to_field},\n    traits::{Deserialize, Serialize},\n};\nuse event_validation_request::EventValidationRequest;\n\nglobal NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\nglobal LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT: Field = sha256_to_field(\n    \"AZTEC_NR::LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT\".as_bytes(),\n);\n\n/// An offchain-delivered message with resolved context, ready for processing during sync.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessageWithTx {\n    pub message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    pub resolved_tx: ResolvedTx,\n}\n\n/// Enqueues a note for validation and storage by PXE.\n///\n/// The caller must guarantee that every enqueued note's unique hash is actually included in\n/// `tx_hash`'s effects; enqueuing one that is absent bricks sync for that contract. The built-in discovery paths\n/// guarantee this by running nonce discovery first (see\n/// [`process_private_note_msg`](crate::messages::discovery::private_notes)), which is why this is not exposed to\n/// contracts.\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(crate) unconstrained fn enqueue_note_for_validation(\n    contract_address: AztecAddress,\n    owner: AztecAddress,\n    storage_slot: Field,\n    randomness: Field,\n    note_nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(NoteValidationRequest::new(\n        contract_address,\n        owner,\n        storage_slot,\n        randomness,\n        note_nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n    ))\n}\n\n/// The note validation requests enqueued so far in the current context via [`enqueue_note_for_validation`], before\n/// [`validate_and_store_enqueued_notes_and_events`] drains them. Exists so tests can inspect the pending queue;\n/// production code should not read requests back once enqueued.\npub(crate) unconstrained fn get_enqueued_note_validation_requests() -> EphemeralArray<NoteValidationRequest> {\n    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT)\n}\n\n/// Enqueues an event for validation and storage by PXE.\n///\n/// This is the primary way for custom message handlers (registered via\n/// [`crate::macros::AztecConfig::custom_message_handler`]) to deliver reassembled events back to PXE after processing\n/// application-specific message formats.\n///\n/// In order for the event validation and insertion to occur, `validate_and_store_enqueued_notes_and_events` must be\n/// later called. For optimal performance, accumulate as many event validation requests as possible and then validate\n/// them all at the end (which results in PXE minimizing the number of network round-trips).\n///\n/// Note that `validate_and_store_enqueued_notes_and_events` is called by Aztec.nr after processing messages, so custom\n/// message processors do not need to be concerned with this.\npub unconstrained fn enqueue_event_for_validation(\n    contract_address: AztecAddress,\n    event_type_id: EventSelector,\n    randomness: Field,\n    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,\n    event_commitment: Field,\n    tx_hash: Field,\n) {\n    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(EventValidationRequest::new(\n        contract_address,\n        event_type_id,\n        randomness,\n        serialized_event,\n        event_commitment,\n        tx_hash,\n    ))\n}\n\n/// Validates and stores all enqueued notes and events.\n///\n/// Processes all requests enqueued via [`enqueue_note_for_validation`] and [`enqueue_event_for_validation`], inserting\n/// them into the note database and event store respectively, making them queryable via `get_notes` oracle and our TS\n/// API (PXE::getPrivateEvents).\npub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAddress) {\n    message_processing::validate_and_store_enqueued_notes_and_events(\n        EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),\n        scope,\n    );\n\n    // Defensive clearing: purge the queues after processing to prevent double-processing if this function is called\n    // more than once in the same call frame. It is currently defensive because we only call this once per sync run.\n    let _ = EphemeralArray::<NoteValidationRequest>::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n    let _ = EphemeralArray::<EventValidationRequest>::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).clear();\n}\n\n/// Efficiently queries the node for logs that result in the completion of all `DeliveredPendingPartialNote`s in an\n/// `EphemeralArray` by performing all node communication concurrently. Returns a nested `EphemeralArray`, one inner\n/// array per pending partial note, each containing all matching `LogRetrievalResponse`s (which may be empty if no\n/// logs were found).\npub(crate) unconstrained fn get_pending_partial_notes_completion_logs(\n    contract_address: AztecAddress,\n    pending_partial_notes: EphemeralArray<DeliveredPendingPartialNote>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    let log_retrieval_requests = EphemeralArray::at(LOG_RETRIEVAL_REQUESTS_ARRAY_BASE_SLOT);\n\n    pending_partial_notes.for_each(|_i, pending_partial_note| {\n        // Partial note completion logs are emitted with a domain-separated tag. To find matching logs, we apply the\n        // same domain separation to the stored raw tag.\n        let log_tag = compute_log_tag(\n            pending_partial_note.note_completion_log_tag,\n            DOM_SEP__NOTE_COMPLETION_LOG_TAG,\n        );\n        log_retrieval_requests.push(LogRetrievalRequest::new(contract_address, log_tag));\n    });\n\n    let responses = message_processing::get_logs_by_tag(log_retrieval_requests);\n\n    // Defensive clearing: prevent stale requests if this function is called more than once in the same call frame.\n    let _ = log_retrieval_requests.clear();\n\n    responses\n}\n"
     },
-    "166": {
+    "167": {
       "function_locations": [
         {
           "name": "receive",
@@ -1326,95 +1326,95 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/mod.nr",
       "source": "use crate::{\n    context::UtilityContext,\n    ephemeral::EphemeralArray,\n    messages::{encoding::MESSAGE_CIPHERTEXT_LEN, processing::OffchainMessageWithTx},\n    oracle::{contract_sync::set_contract_sync_cache_invalid, tx_resolution::get_resolved_txs},\n    protocol::{address::AztecAddress, traits::{Deserialize, Serialize}},\n};\n\nmod reception;\nuse reception::{MAX_ANCHOR_FUTURE_SKEW, OffchainReception};\n\n/// Maximum number of offchain messages accepted by `offchain_receive` in a single call.\npub global MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL: u32 = 16;\n\n/// A function that manages offchain-delivered messages for processing during sync.\n///\n/// Offchain messages are messages that are not broadcasted via onchain logs. They are instead delivered to the\n/// recipient by calling the `offchain_receive` utility function (injected by the `#[aztec]` macro). Message transport\n/// is the app's responsibility. Typical examples of transport methods are: messaging apps, email, QR codes, etc.\n///\n/// Once offchain messages are delivered to the recipient's private environment via `offchain_receive`, messages are\n/// locally stored in a persistent inbox.\n///\n/// This function determines when each message in said inbox is ready for processing, when it can be safely disposed\n/// of, etc.\n///\n/// The only current implementation of an [`OffchainInboxSync`] is [`sync_inbox`], which manages an inbox with\n/// expiration and finality-based eviction and automatic transaction context resolution.\npub type OffchainInboxSync = unconstrained fn(\n/* contract_address */AztecAddress, /* scope */ AztecAddress) -> EphemeralArray<OffchainMessageWithTx>;\n\n/// Delivers offchain messages to the given contract's offchain inbox for subsequent processing.\n///\n/// Offchain messages are transaction effects that are not broadcasted via onchain logs. Instead, the sender shares the\n/// message to the recipient through an external channel (e.g. a URL accessible by the recipient). The recipient then\n/// calls this function to hand the messages to the contract so they can be processed through the same mechanisms as\n/// onchain messages.\n///\n/// Messages are processed when their originating transaction is found onchain (providing the context needed to\n/// validate resulting notes and events).\n///\n/// Messages are eventually removed from the inbox: an unprocessed message once its TTL (`anchor_block_timestamp +\n/// MAX_MSG_TTL`) elapses, and a processed message once the block its transaction was found in finalizes.\n///\n/// Processing order is not guaranteed.\npub unconstrained fn receive(\n    contract_address: AztecAddress,\n    messages: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL>,\n) {\n    // Offchain reception facts are scoped to the recipient. Note that because offchain messages have no integrity or\n    // authenticity checks it is not possible to verify that this is indeed the intended recipient. In this case we're\n    // assuming a cooperative environment, which is on par with other offchain delivery expectations.\n    //\n    // The sender-supplied anchor timestamp is the one field we bound: a message claiming to originate implausibly far\n    // in our future (see MAX_ANCHOR_FUTURE_SKEW) cannot be genuine, and accepting it would let a malicious anchor evade\n    // the TTL-based inbox eviction. We reject such a batch by panicking instead of silently dropping the message, so\n    // the calling wallet can react to it (e.g. surface the error or distrust the sender).\n    let now = UtilityContext::new().timestamp();\n    messages.for_each(|msg| {\n        assert(\n            msg.anchor_block_timestamp <= now + MAX_ANCHOR_FUTURE_SKEW,\n            \"offchain message anchor timestamp is implausibly far in the future\",\n        );\n    });\n\n    messages.for_each(|msg| OffchainReception::init(contract_address, msg));\n\n    // Clear cache for message recipients so the next sync runs.\n    set_contract_sync_cache_invalid(contract_address, messages.map(|msg| msg.recipient));\n}\n\n/// Returns offchain-delivered messages to process during sync.\npub unconstrained fn sync_inbox(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n) -> EphemeralArray<OffchainMessageWithTx> {\n    let active_receptions = OffchainReception::load_all(contract_address, scope);\n\n    // Ask PXE to resolve each message's originating tx. We pass the tx hashes in reception order, so the resolved txs\n    // come back aligned with the reception indices and can be matched back positionally.\n    let resolved_txs = get_resolved_txs(active_receptions.map(|reception: OffchainReception| {\n        reception.read_message().tx_hash.unwrap_or(0)\n    }));\n\n    let processable_messages: EphemeralArray<OffchainMessageWithTx> = EphemeralArray::empty();\n    let now = UtilityContext::new().timestamp();\n\n    active_receptions.for_each(|i, reception| {\n        let maybe_message = reception.step(resolved_txs.get(i), now);\n        if maybe_message.is_some() {\n            processable_messages.push(maybe_message.unwrap());\n        }\n    });\n\n    processable_messages\n}\n\n/// A message delivered via the `offchain_receive` utility function.\n#[derive(Serialize, Deserialize)]\npub struct OffchainMessage {\n    /// The encrypted message payload.\n    pub ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,\n    /// The intended recipient of the message.\n    pub recipient: AztecAddress,\n    /// The hash of the transaction that produced this message. `Option::none` indicates a tx-less message.\n    pub tx_hash: Option<Field>,\n    /// Anchor block timestamp at message emission.\n    pub anchor_block_timestamp: u64,\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        protocol::{address::AztecAddress, constants::MAX_TX_LIFETIME},\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL, OffchainMessage, receive, sync_inbox};\n    use super::reception::{MAX_ANCHOR_FUTURE_SKEW, MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Advances the TXE block timestamp by `offset` seconds and returns the resulting timestamp.\n    unconstrained fn advance_by(env: TestEnvironment, offset: u64) -> u64 {\n        env.advance_next_block_timestamp_by(offset);\n        env.mine_block();\n        env.last_block_timestamp()\n    }\n\n    #[test]\n    unconstrained fn empty_inbox_returns_empty_result() {\n        let (env, scope) = setup();\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n\n            assert_eq(result.len(), 0);\n            assert_eq(OffchainReception::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn multiple_messages_mixed_expiration() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n\n        let expired_a_tx_hash = random();\n        let survivor_tx_hash = random();\n\n        let expired_a = make_msg(scope, Option::some(expired_a_tx_hash), 0);\n        let survivor = make_msg(scope, Option::some(survivor_tx_hash), anchor_ts);\n        let expired_b = make_msg(scope, Option::none(), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let mut msgs: BoundedVec<OffchainMessage, MAX_OFFCHAIN_MESSAGES_PER_RECEIVE_CALL> = BoundedVec::new();\n            // Message 0: tx-bound, anchor=0 so it expires quickly.\n            msgs.push(expired_a);\n            // Message 1: tx-bound, anchor_ts is recent so it survives.\n            msgs.push(survivor);\n            // Message 2: tx-less, anchor=0 so it also expires.\n            msgs.push(expired_b);\n            receive(address, msgs);\n        });\n\n        // Advance past MAX_MSG_TTL for anchor=0, but not for anchor_ts.\n        let _now = advance_by(env, MAX_MSG_TTL);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            let result = sync_inbox(address, scope);\n\n            assert_eq(result.len(), 0); // all contexts are None\n            assert(\n                !OffchainReception::is_active(address, scope, expired_a),\n                \"expired tx-bound reception should be terminated\",\n            );\n            assert(\n                !OffchainReception::is_active(address, scope, expired_b),\n                \"expired tx-less reception should be terminated\",\n            );\n            assert(OffchainReception::is_active(address, scope, survivor), \"survivor reception should stay active\");\n            assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn accepts_messages_within_the_tolerated_future_skew() {\n        let (env, scope) = setup();\n        let now = advance_by(env, 10);\n\n        // A present-dated anchor and a 24h-future one both fall within the tolerated skew. The latter models a genuine\n        // message whose sender anchored ahead of our lagging PXE, and must still be accepted.\n        let present = make_msg(scope, Option::some(random()), now);\n        let lagged = make_msg(scope, Option::some(random()), now + MAX_TX_LIFETIME);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([present, lagged]));\n\n            assert(OffchainReception::is_active(address, scope, present));\n            assert(OffchainReception::is_active(address, scope, lagged));\n            assert_eq(OffchainReception::load_all(address, scope).len(), 2);\n        });\n    }\n\n    #[test(should_fail_with = \"offchain message anchor timestamp is implausibly far in the future\")]\n    unconstrained fn rejects_batch_with_implausible_future_anchor() {\n        let (env, scope) = setup();\n        let now = advance_by(env, 10);\n\n        // Beyond `now + MAX_ANCHOR_FUTURE_SKEW`: our view would trail the tip by more than a tx lifetime, so this\n        // cannot be genuine. Reception panics so the wallet can react rather than accept it.\n        let too_future = make_msg(\n            scope,\n            Option::some(random()),\n            now + MAX_ANCHOR_FUTURE_SKEW + 7200,\n        );\n\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([too_future])); });\n    }\n\n    // -- Idempotent re-delivery (first-write-wins fact recording) ---------\n\n    #[test]\n    unconstrained fn redelivery_is_idempotent() {\n        let (env, scope) = setup();\n        let anchor_ts = advance_by(env, 10);\n        let msg = make_msg(scope, Option::some(random()), anchor_ts);\n\n        // First delivery, committed as its own job.\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n        // Re-delivering the same content-addressed message must not panic and must not create a second reception.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([msg]));\n\n            assert(OffchainReception::is_active(address, scope, msg), \"reception should be active\");\n            assert_eq(OffchainReception::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn redelivery_after_processing_keeps_processed_guard() {\n        let (env, scope) = setup();\n        let known_tx_hash: Field = 1;\n        let anchor_ts = advance_by(env, 10);\n        let msg = make_msg(scope, Option::some(known_tx_hash), anchor_ts);\n\n        env.utility_context(|context| { receive(context.this_address(), BoundedVec::from_array([msg])); });\n\n        let _now = advance_by(env, 100);\n\n        // First sync resolves the message and marks it as processed.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            assert_eq(sync_inbox(address, scope).len(), 1);\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n\n        // Re-deliver the same message. The next sync recognizes it as already processed and does not re-push it.\n        env.utility_context(|context| {\n            let address = context.this_address();\n            receive(address, BoundedVec::from_array([msg]));\n\n            assert(\n                OffchainReception::is_processed(address, scope, msg),\n                \"re-delivery must preserve the processed guard\",\n            );\n            assert_eq(sync_inbox(address, scope).len(), 0);\n        });\n    }\n}\n"
     },
-    "167": {
+    "168": {
       "function_locations": [
         {
           "name": "OffchainReception::init",
-          "start": 9701
+          "start": 9712
         },
         {
           "name": "OffchainReception::load_all",
-          "start": 10219
+          "start": 10250
         },
         {
           "name": "OffchainReception::read_message",
-          "start": 10568
+          "start": 10666
         },
         {
           "name": "OffchainReception::id_for",
-          "start": 11269
+          "start": 11367
         },
         {
           "name": "OffchainReception::is_active",
-          "start": 11588
+          "start": 11686
         },
         {
           "name": "OffchainReception::step",
-          "start": 12243
+          "start": 12361
         },
         {
           "name": "OffchainReception::is_processed",
-          "start": 13848
+          "start": 13966
         },
         {
           "name": "OffchainReception::mark_processed",
-          "start": 14416
+          "start": 14554
         },
         {
           "name": "OffchainReception::terminate",
-          "start": 14987
+          "start": 15125
         },
         {
           "name": "to_payload",
-          "start": 15361
+          "start": 15499
         },
         {
           "name": "test::setup",
-          "start": 15784
+          "start": 15922
         },
         {
           "name": "test::make_msg",
-          "start": 16114
+          "start": 16252
         },
         {
           "name": "test::resolved_tx_at_block",
-          "start": 16398
+          "start": 16536
         },
         {
           "name": "test::resolved_tx",
-          "start": 16789
+          "start": 16927
         },
         {
           "name": "test::expired_reception_is_terminated",
-          "start": 16906
+          "start": 17044
         },
         {
           "name": "test::unresolved_reception_stays_active",
-          "start": 17588
+          "start": 17726
         },
         {
           "name": "test::resolved_reception_is_ready_to_process",
-          "start": 18383
+          "start": 18521
         },
         {
           "name": "test::already_processed_reception_is_not_re_pushed",
-          "start": 19429
+          "start": 19567
         },
         {
           "name": "test::processed_reception_terminates_once_its_origin_block_finalizes",
-          "start": 20803
+          "start": 20941
         },
         {
           "name": "test::unfinalized_processed_reception_survives_past_the_ttl",
-          "start": 22028
+          "start": 22166
         },
         {
           "name": "test::expired_reception_is_still_processed_when_its_tx_resolves",
-          "start": 23418
+          "start": 23556
         }
       ],
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/messages/processing/offchain/reception.nr",
-      "source": "//! The state machine of a single offchain message reception process.\n//!\n//! Offchain processing needs to handle some complexity, including the possibility of reorgs reverting message effects,\n//! and the need to reprocess messages in that case. The state chart below summarizes the current behavior.\n//!\n//! ```text\n//!                   offchain_receive() (process starts)\n//!                         |\n//!                         v\n//!                     +-----------+     tx found onchain        +-----------+\n//!                ---- |           | --------------------------> |           |\n//!  tx not found  |    |           |                             |           |     discover notes,\n//!                |--> | RECEIVED  |                             | PROCESSED | ~~> events, etc\n//!                     |           | <-------------------------- |           |\n//!                     |           |   tx block re-orged         |           |\n//!                     +-----------+                             +-----------+\n//!                         |                                         |\n//!                         |  TTL expired                            |  tx block finalized\n//!                         v                                         v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Received**: the message is stored but its originating transaction has not been found onchain yet (or the\n//!   message is tx-less; see below). While the reception process is in this state, it keeps looking for the\n//    transaction onchain.\n//! - **Processed**: the message has been handed off for processing. If there weren't reorgs, reaching this state would\n//!   be equivalent to terminating the reception process. Since reorgs are a possibility, this state is not terminal\n//!   until the block the originating transaction was found in finalizes.\n//! - **Terminated**: nothing else can be done with the message, either because its originating transaction never\n//!   appeared within the TTL, or because the block it was processed in has finalized. This is the terminal state of\n//!   this process.\n//!\n//! ## Transitions (each evaluated by [`OffchainReception::step`])\n//!\n//! - **Received -> Processed**: the originating transaction is found onchain. The message (packaged with its\n//!   transaction context) is queued to have its actual contents processed (which can lead for example to the discovery\n//!   of notes and events).\n//! - **Processed -> Received**: the block where the message transaction was originally found is re-orged out.\n//! - **Received -> Terminated**: the message TTL has elapsed (see below), so the originating transaction can no longer\n//!   appear and the message is no longer processable.\n//! - **Processed -> Terminated**: the block the originating transaction was found in has finalized, so the effects of\n//!   its processing are permanent and reorg-proof.\n//!\n//! # Message reception lifecycle and the TTL\n//!\n//! A reception expires once `now > anchor_block_timestamp + MAX_MSG_TTL`, where `MAX_MSG_TTL = MAX_TX_LIFETIME + 2h`.\n//! A transaction anchored at a given block can only be mined within\n//! [`MAX_TX_LIFETIME`](crate::protocol::constants::MAX_TX_LIFETIME) of that block, so once that\n//! window (plus a safety margin of 2 hours) has elapsed the originating transaction can no longer appear, and it is\n//! safe to stop looking for it.\n//!\n//! The TTL only matters for unprocessed messages. Already-processed message receptions complete when the block that\n//! included the originating transaction finalizes, which is exactly when the processing becomes reorg-proof.\n//!\n//! # Current limitations, future plans\n//!\n//! - Tx-less messages never reach `Processed` and are only ever removed by expiry. This will be supported in the\n//!   future.\n//!\n//! # Implementation\n//!\n//! [`OffchainReception::init`] creates a [fact collection](crate::facts::FactCollection) of type\n//! `OFFCHAIN_RECEPTION_TYPE_ID`. The fact collection is identified by a hash of the `OffchainMessage` it tracks, which\n//! makes duplicate calls to `init` idempotent.\n//!\n//! Upon reception, an `OFFCHAIN_MESSAGE_RECEIVED` [non-retractable fact](crate::facts::record_non_retractable_fact) is\n//! recorded. The fact's payload is the `OffchainMessage` itself, which persists it to be subsequently processed.\n//! A fact collection with just an `OFFCHAIN_MESSAGE_RECEIVED` fact represents an active reception process in the\n//! RECEIVED state from our state chart above.\n//!\n//! The message reception state machine is driven externally, advancing one step at a time each time\n//! [`OffchainReception::step`] is invoked. [`OffchainReception::step`] implements the rest of the reception state\n//! machine described above.\n//!\n//! When stepping, if the transaction to the message is found onchain, an `OFFCHAIN_MESSAGE_PROCESSED`\n//! [retractable fact](crate::facts::record_retractable_fact) associated to the block where the transaction was found is\n//! recorded.\n//! Note that since this fact is retractable, a reorg dropping said block would result in the fact being automatically\n//! removed by PXE, effectively pushing the reception process back to `RECEIVED` state.\n//!\n//! To determine in which state of the reception process we are we just analyze the recorded facts:\n//!\n//! - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state. Once that fact's origin block has\n//!   finalized the processing is reorg-proof, so the [fact collection](crate::facts::FactCollection) can (and should)\n//!   be deleted; until then there is nothing to do.\n//! - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we check if the message\n//!   transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition. Otherwise, once the\n//!   TTL has elapsed the originating transaction can no longer appear and the collection can (and should) be deleted.\n//!\n//! The PROCESSED->RECEIVED transition is transparently handled by PXE: if a re-org caused the message transaction to\n//! fall off the chain, the `OFFCHAIN_MESSAGE_PROCESSED` fact disappears, taking us back to the RECEIVED state.\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    facts::{\n        delete_fact_collection, Fact, FactCollection, get_fact_collection, get_fact_collections_by_type,\n        record_non_retractable_fact, record_retractable_fact,\n    },\n    messages::processing::OffchainMessageWithTx,\n    oracle::{block_reference::BlockReference, tx_resolution::ResolvedTx},\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::{poseidon2_hash, sha256_to_field},\n        traits::{Deserialize, Serialize},\n    },\n};\nuse super::OffchainMessage;\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\n/// (7200 == 2 hours)\npub(crate) global MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Maximum amount by which a received message's `anchor_block_timestamp` may exceed our current timestamp.\n///\n/// A message's anchor is the timestamp of the block the sender anchored its originating tx to, so for a genuine\n/// message it is at or before our own anchor timestamp. Our PXE may lag the chain tip though, which can make a\n/// legitimate anchor appear to be in our future, so we tolerate a forward skew of `MAX_TX_LIFETIME` (the longest a tx\n/// can wait to be mined after its anchor) plus a 2h margin. A larger skew would mean our view trails the tip by more\n/// than a tx lifetime -- so far behind that we could not even build a tx that wouldn't be immediately expired -- so\n/// such a message cannot be genuine and is rejected on reception. Bounding the anchor this way also keeps accepted\n/// values near the present, which prevents the `anchor_block_timestamp + MAX_MSG_TTL` eviction check from overflowing.\n/// (7200 == 2 hours)\npub(crate) global MAX_ANCHOR_FUTURE_SKEW: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Fact type id of the fact that stores the offchain message body inside a reception collection.\nglobal OFFCHAIN_MESSAGE_RECEIVED: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_RECEIVED\".as_bytes());\n\n/// Fact type id to mark an offchain message as processed.\n///\n/// A reception is in \"processed state\" exactly when its collection carries a fact of this type.\npub(crate) global OFFCHAIN_MESSAGE_PROCESSED: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_PROCESSED\".as_bytes());\n\n/// Fact-collection type id shared by every offchain message reception in the [fact store](crate::facts).\npub(crate) global OFFCHAIN_RECEPTION_TYPE_ID: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_RECEPTION_TYPE_ID\".as_bytes());\n\n/// A single offchain message reception machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n///\n/// Wraps the fact collection that tracks one message's progress through the reception state machine (see the\n/// [module documentation](super)); the [`OffchainMessage`] it carries is decoded on demand.\n#[derive(Deserialize, Serialize)]\npub(crate) struct OffchainReception {\n    collection: FactCollection,\n}\n\nimpl OffchainReception {\n    /// Initializes a new reception for a freshly received message, in the `Received` state.\n    ///\n    /// Re-initializing the same message is a no-op, which makes redelivery idempotent.\n    pub(crate) unconstrained fn init(contract_address: AztecAddress, message: OffchainMessage) {\n        record_non_retractable_fact(\n            contract_address,\n            message.recipient,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n            OFFCHAIN_MESSAGE_RECEIVED,\n            to_payload(message),\n        );\n    }\n\n    /// Loads every active reception for the given contract and scope, decoding each message body.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<OffchainReception> {\n        get_fact_collections_by_type(contract_address, scope, OFFCHAIN_RECEPTION_TYPE_ID)\n            .map(|collection: FactCollection| OffchainReception { collection })\n    }\n\n    /// Reads and returns the message this reception carries, decoding it from its fact collection.\n    pub(crate) unconstrained fn read_message(self) -> OffchainMessage {\n        let message_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_RECEIVED).unwrap();\n        let n = <OffchainMessage as Deserialize>::N;\n        let mut fields = [0; <OffchainMessage as Deserialize>::N];\n        for i in 0..n {\n            fields[i] = message_fact.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Computes the fact-collection id that identifies a message's reception machine in the [fact store](crate::facts).\n    ///\n    /// The id is a hash of the message, which makes duplicate receptions of the same message collapse onto a single\n    /// reception.\n    pub(crate) fn id_for(message: OffchainMessage) -> Field {\n        poseidon2_hash(message.serialize())\n    }\n\n    /// Returns `true` if a reception for `message` is currently active for the given contract and scope.\n    pub(crate) unconstrained fn is_active(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        get_fact_collection(\n            contract_address,\n            scope,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        )\n            .is_some()\n    }\n\n    /// Advances this reception by one step of its state machine. See the [module documentation](super) for the\n    /// states, transitions, and expiry rules.\n    ///\n    /// Returns `Some` with the message and its resolved context when this step determines the message is ready to be\n    /// processed.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_resolved_tx: Option<ResolvedTx>,\n        now: u64,\n    ) -> Option<OffchainMessageWithTx> {\n        let message = self.read_message();\n        let processed_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n        if processed_fact.is_none() & maybe_resolved_tx.is_some() {\n            // Received -> Processed: the originating tx is onchain.\n            let resolved = maybe_resolved_tx.unwrap();\n            self.mark_processed(resolved.block_number, resolved.block_hash);\n            Option::some(\n                OffchainMessageWithTx { message_ciphertext: message.ciphertext, resolved_tx: resolved },\n            )\n        } else if processed_fact.is_some() {\n            if processed_fact.unwrap().origin_block.unwrap().block_state.is_finalized() {\n                // Processed -> Terminated: once the marker's origin block finalizes, the processing is reorg-proof and\n                // the reception is complete. Until then we wait: a reorg dropping that block removes the retractable\n                // marker and PXE pushes us back to Received.\n                self.terminate();\n            }\n            Option::none()\n        } else {\n            // Received -> Terminated: the TTL caps how long we keep looking for the originating tx.\n            if now > message.anchor_block_timestamp + MAX_MSG_TTL {\n                self.terminate();\n            }\n            Option::none()\n        }\n    }\n\n    /// Returns `true` if the reception for `message` has been marked processed.\n    pub(crate) unconstrained fn is_processed(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        let maybe_collection = get_fact_collection(\n            contract_address,\n            scope,\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        );\n        if maybe_collection.is_some() {\n            maybe_collection.unwrap().facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED)\n        } else {\n            false\n        }\n    }\n\n    /// Records the retractable processed marker for this reception, originated at the resolved block.\n    unconstrained fn mark_processed(self, block_number: u32, block_hash: Field) {\n        let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n        record_retractable_fact(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n            OFFCHAIN_MESSAGE_PROCESSED,\n            empty_payload,\n            BlockReference { block_number, block_hash },\n        );\n    }\n\n    /// Terminates this reception by deleting its [fact collection](crate::facts::FactCollection).\n    unconstrained fn terminate(self) {\n        delete_fact_collection(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n        );\n    }\n}\n\n/// Serializes an [`OffchainMessage`] into a fact payload.\nunconstrained fn to_payload(message: OffchainMessage) -> EphemeralArray<Field> {\n    EphemeralArray::from_array(message.serialize())\n}\n\nmod test {\n    use crate::{\n        messages::processing::offchain::OffchainMessage,\n        oracle::{random::random, tx_resolution::ResolvedTx},\n        protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Builds the resolved-tx context PXE would return for `tx_hash`, found in `block_number`.\n    fn resolved_tx_at_block(tx_hash: Field, block_number: u32) -> ResolvedTx {\n        ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: BoundedVec::new(),\n            first_nullifier_in_tx: 0,\n            block_number,\n            block_hash: 0,\n        }\n    }\n\n    /// Builds a resolved-tx context found in a low block, which TXE (proven == finalized == latest) reports as\n    /// `Finalized`.\n    fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n        resolved_tx_at_block(tx_hash, 1)\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_terminated() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Past the TTL with no resolved tx: the reception is terminated.\n            assert(reception.step(Option::none(), MAX_MSG_TTL + 1).is_none());\n            assert(!OffchainReception::is_active(address, scope, msg), \"expired reception should be terminated\");\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_reception_stays_active() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Within the TTL with no resolved tx: nothing to process, the reception stays.\n            assert(reception.step(Option::none(), 100).is_none());\n            assert(OffchainReception::is_active(address, scope, msg), \"unresolved reception should stay active\");\n            assert(!OffchainReception::is_processed(address, scope, msg), \"should still be unprocessed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn resolved_reception_is_ready_to_process() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // A resolved tx within the TTL: the message is handed off with its tx context attached.\n            let processable = reception.step(Option::some(resolved_tx(tx_hash)), 100);\n            assert(processable.is_some());\n            assert_eq(processable.unwrap().resolved_tx.tx_hash, tx_hash);\n\n            // It stays active for reorg safety and is now marked processed.\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should stay active\");\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn already_processed_reception_is_not_re_pushed() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n        // A future origin block stays unfinalized, so the reception lingers in Processed across steps.\n        let future_block = env.last_block_number() + 100;\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // First step processes the message.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Second step (still resolved, not finalized) recognizes it as processed and does not re-push it.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(\n                reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_none(),\n                \"already processed\",\n            );\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n        });\n    }\n\n    #[test]\n    unconstrained fn processed_reception_terminates_once_its_origin_block_finalizes() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // Process the message against a finalized block.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Next step, still well within the TTL: a finalized origin block makes the processing reorg-proof, so the\n            // reception terminates regardless of the TTL.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none());\n            assert(\n                !OffchainReception::is_active(address, scope, msg),\n                \"finalized processed reception should be terminated\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn unfinalized_processed_reception_survives_past_the_ttl() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n        // A future origin block never finalizes here, so the reception must not be terminated by the TTL.\n        let future_block = env.last_block_number() + 100;\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Past the TTL, but the origin block has not finalized: the reception stays active. The TTL no longer\n            // governs an already-processed reception.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), MAX_MSG_TTL + 1).is_none());\n            assert(\n                OffchainReception::is_active(address, scope, msg),\n                \"unfinalized processed reception should survive past the TTL\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_still_processed_when_its_tx_resolves() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // Even past the TTL, a freshly resolved tx is still handed off: expiry only caps the search for the\n            // originating tx, it does not pre-empt processing once that tx is found.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n            assert(OffchainReception::is_active(address, scope, msg), \"just-processed reception should stay active\");\n        });\n    }\n}\n"
+      "source": "//! The state machine of a single offchain message reception process.\n//!\n//! Offchain processing needs to handle some complexity, including the possibility of reorgs reverting message effects,\n//! and the need to reprocess messages in that case. The state chart below summarizes the current behavior.\n//!\n//! ```text\n//!                   offchain_receive() (process starts)\n//!                         |\n//!                         v\n//!                     +-----------+     tx found onchain        +-----------+\n//!                ---- |           | --------------------------> |           |\n//!  tx not found  |    |           |                             |           |     discover notes,\n//!                |--> | RECEIVED  |                             | PROCESSED | ~~> events, etc\n//!                     |           | <-------------------------- |           |\n//!                     |           |   tx block re-orged         |           |\n//!                     +-----------+                             +-----------+\n//!                         |                                         |\n//!                         |  TTL expired                            |  tx block finalized\n//!                         v                                         v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Received**: the message is stored but its originating transaction has not been found onchain yet (or the\n//!   message is tx-less; see below). While the reception process is in this state, it keeps looking for the\n//    transaction onchain.\n//! - **Processed**: the message has been handed off for processing. If there weren't reorgs, reaching this state would\n//!   be equivalent to terminating the reception process. Since reorgs are a possibility, this state is not terminal\n//!   until the block the originating transaction was found in finalizes.\n//! - **Terminated**: nothing else can be done with the message, either because its originating transaction never\n//!   appeared within the TTL, or because the block it was processed in has finalized. This is the terminal state of\n//!   this process.\n//!\n//! ## Transitions (each evaluated by [`OffchainReception::step`])\n//!\n//! - **Received -> Processed**: the originating transaction is found onchain. The message (packaged with its\n//!   transaction context) is queued to have its actual contents processed (which can lead for example to the discovery\n//!   of notes and events).\n//! - **Processed -> Received**: the block where the message transaction was originally found is re-orged out.\n//! - **Received -> Terminated**: the message TTL has elapsed (see below), so the originating transaction can no longer\n//!   appear and the message is no longer processable.\n//! - **Processed -> Terminated**: the block the originating transaction was found in has finalized, so the effects of\n//!   its processing are permanent and reorg-proof.\n//!\n//! # Message reception lifecycle and the TTL\n//!\n//! A reception expires once `now > anchor_block_timestamp + MAX_MSG_TTL`, where `MAX_MSG_TTL = MAX_TX_LIFETIME + 2h`.\n//! A transaction anchored at a given block can only be mined within\n//! [`MAX_TX_LIFETIME`](crate::protocol::constants::MAX_TX_LIFETIME) of that block, so once that\n//! window (plus a safety margin of 2 hours) has elapsed the originating transaction can no longer appear, and it is\n//! safe to stop looking for it.\n//!\n//! The TTL only matters for unprocessed messages. Already-processed message receptions complete when the block that\n//! included the originating transaction finalizes, which is exactly when the processing becomes reorg-proof.\n//!\n//! # Current limitations, future plans\n//!\n//! - Tx-less messages never reach `Processed` and are only ever removed by expiry. This will be supported in the\n//!   future.\n//!\n//! # Implementation\n//!\n//! [`OffchainReception::init`] creates a [fact collection](crate::facts::FactCollection) of type\n//! `OFFCHAIN_RECEPTION_TYPE_ID`. The fact collection is identified by a hash of the `OffchainMessage` it tracks, which\n//! makes duplicate calls to `init` idempotent.\n//!\n//! Upon reception, an `OFFCHAIN_MESSAGE_RECEIVED` [non-retractable fact](crate::facts::record_non_retractable_fact) is\n//! recorded. The fact's payload is the `OffchainMessage` itself, which persists it to be subsequently processed.\n//! A fact collection with just an `OFFCHAIN_MESSAGE_RECEIVED` fact represents an active reception process in the\n//! RECEIVED state from our state chart above.\n//!\n//! The message reception state machine is driven externally, advancing one step at a time each time\n//! [`OffchainReception::step`] is invoked. [`OffchainReception::step`] implements the rest of the reception state\n//! machine described above.\n//!\n//! When stepping, if the transaction to the message is found onchain, an `OFFCHAIN_MESSAGE_PROCESSED`\n//! [retractable fact](crate::facts::record_retractable_fact) associated to the block where the transaction was found is\n//! recorded.\n//! Note that since this fact is retractable, a reorg dropping said block would result in the fact being automatically\n//! removed by PXE, effectively pushing the reception process back to `RECEIVED` state.\n//!\n//! To determine in which state of the reception process we are we just analyze the recorded facts:\n//!\n//! - If there is an `OFFCHAIN_MESSAGE_PROCESSED` fact we are in PROCESSED state. Once that fact's origin block has\n//!   finalized the processing is reorg-proof, so the [fact collection](crate::facts::FactCollection) can (and should)\n//!   be deleted; until then there is nothing to do.\n//! - If there is only an `OFFCHAIN_MESSAGE_RECEIVED` fact we are in RECEIVED state, so we check if the message\n//!   transaction is now available onchain, and if so, exercise the RECEIVED->PROCESSED transition. Otherwise, once the\n//!   TTL has elapsed the originating transaction can no longer appear and the collection can (and should) be deleted.\n//!\n//! The PROCESSED->RECEIVED transition is transparently handled by PXE: if a re-org caused the message transaction to\n//! fall off the chain, the `OFFCHAIN_MESSAGE_PROCESSED` fact disappears, taking us back to the RECEIVED state.\n\nuse crate::{\n    ephemeral::EphemeralArray,\n    facts::{\n        delete_fact_collection, Fact, FactCollection, FactScope, get_fact_collection, get_fact_collections_by_type,\n        record_non_retractable_fact, record_retractable_fact,\n    },\n    messages::processing::OffchainMessageWithTx,\n    oracle::{block_reference::BlockReference, tx_resolution::ResolvedTx},\n    protocol::{\n        address::AztecAddress,\n        constants::MAX_TX_LIFETIME,\n        hash::{poseidon2_hash, sha256_to_field},\n        traits::{Deserialize, Serialize},\n    },\n};\nuse super::OffchainMessage;\n\n/// Maximum time-to-live for a tx-bound offchain message.\n///\n/// After `anchor_block_timestamp + MAX_MSG_TTL`, the message is evicted from the inbox.\n/// (7200 == 2 hours)\npub(crate) global MAX_MSG_TTL: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Maximum amount by which a received message's `anchor_block_timestamp` may exceed our current timestamp.\n///\n/// A message's anchor is the timestamp of the block the sender anchored its originating tx to, so for a genuine\n/// message it is at or before our own anchor timestamp. Our PXE may lag the chain tip though, which can make a\n/// legitimate anchor appear to be in our future, so we tolerate a forward skew of `MAX_TX_LIFETIME` (the longest a tx\n/// can wait to be mined after its anchor) plus a 2h margin. A larger skew would mean our view trails the tip by more\n/// than a tx lifetime -- so far behind that we could not even build a tx that wouldn't be immediately expired -- so\n/// such a message cannot be genuine and is rejected on reception. Bounding the anchor this way also keeps accepted\n/// values near the present, which prevents the `anchor_block_timestamp + MAX_MSG_TTL` eviction check from overflowing.\n/// (7200 == 2 hours)\npub(crate) global MAX_ANCHOR_FUTURE_SKEW: u64 = MAX_TX_LIFETIME + 7200;\n\n/// Fact type id of the fact that stores the offchain message body inside a reception collection.\nglobal OFFCHAIN_MESSAGE_RECEIVED: Field = sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_RECEIVED\".as_bytes());\n\n/// Fact type id to mark an offchain message as processed.\n///\n/// A reception is in \"processed state\" exactly when its collection carries a fact of this type.\npub(crate) global OFFCHAIN_MESSAGE_PROCESSED: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_MESSAGE_PROCESSED\".as_bytes());\n\n/// Fact-collection type id shared by every offchain message reception in the [fact store](crate::facts).\npub(crate) global OFFCHAIN_RECEPTION_TYPE_ID: Field =\n    sha256_to_field(\"AZTEC_NR::OFFCHAIN_RECEPTION_TYPE_ID\".as_bytes());\n\n/// A single offchain message reception machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n///\n/// Wraps the fact collection that tracks one message's progress through the reception state machine (see the\n/// [module documentation](super)); the [`OffchainMessage`] it carries is decoded on demand.\n#[derive(Deserialize, Serialize)]\npub(crate) struct OffchainReception {\n    collection: FactCollection,\n}\n\nimpl OffchainReception {\n    /// Initializes a new reception for a freshly received message, in the `Received` state.\n    ///\n    /// Re-initializing the same message is a no-op, which makes redelivery idempotent.\n    pub(crate) unconstrained fn init(contract_address: AztecAddress, message: OffchainMessage) {\n        record_non_retractable_fact(\n            contract_address,\n            FactScope::account(message.recipient),\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n            OFFCHAIN_MESSAGE_RECEIVED,\n            to_payload(message),\n        );\n    }\n\n    /// Loads every active reception for the given contract and scope, decoding each message body.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<OffchainReception> {\n        get_fact_collections_by_type(\n            contract_address,\n            FactScope::account(scope),\n            OFFCHAIN_RECEPTION_TYPE_ID,\n        )\n            .map(|collection: FactCollection| OffchainReception { collection })\n    }\n\n    /// Reads and returns the message this reception carries, decoding it from its fact collection.\n    pub(crate) unconstrained fn read_message(self) -> OffchainMessage {\n        let message_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_RECEIVED).unwrap();\n        let n = <OffchainMessage as Deserialize>::N;\n        let mut fields = [0; <OffchainMessage as Deserialize>::N];\n        for i in 0..n {\n            fields[i] = message_fact.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Computes the fact-collection id that identifies a message's reception machine in the [fact store](crate::facts).\n    ///\n    /// The id is a hash of the message, which makes duplicate receptions of the same message collapse onto a single\n    /// reception.\n    pub(crate) fn id_for(message: OffchainMessage) -> Field {\n        poseidon2_hash(message.serialize())\n    }\n\n    /// Returns `true` if a reception for `message` is currently active for the given contract and scope.\n    pub(crate) unconstrained fn is_active(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        get_fact_collection(\n            contract_address,\n            FactScope::account(scope),\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        )\n            .is_some()\n    }\n\n    /// Advances this reception by one step of its state machine. See the [module documentation](super) for the\n    /// states, transitions, and expiry rules.\n    ///\n    /// Returns `Some` with the message and its resolved context when this step determines the message is ready to be\n    /// processed.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_resolved_tx: Option<ResolvedTx>,\n        now: u64,\n    ) -> Option<OffchainMessageWithTx> {\n        let message = self.read_message();\n        let processed_fact = self.collection.facts.find(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED);\n\n        if processed_fact.is_none() & maybe_resolved_tx.is_some() {\n            // Received -> Processed: the originating tx is onchain.\n            let resolved = maybe_resolved_tx.unwrap();\n            self.mark_processed(resolved.block_number, resolved.block_hash);\n            Option::some(\n                OffchainMessageWithTx { message_ciphertext: message.ciphertext, resolved_tx: resolved },\n            )\n        } else if processed_fact.is_some() {\n            if processed_fact.unwrap().origin_block.unwrap().block_state.is_finalized() {\n                // Processed -> Terminated: once the marker's origin block finalizes, the processing is reorg-proof and\n                // the reception is complete. Until then we wait: a reorg dropping that block removes the retractable\n                // marker and PXE pushes us back to Received.\n                self.terminate();\n            }\n            Option::none()\n        } else {\n            // Received -> Terminated: the TTL caps how long we keep looking for the originating tx.\n            if now > message.anchor_block_timestamp + MAX_MSG_TTL {\n                self.terminate();\n            }\n            Option::none()\n        }\n    }\n\n    /// Returns `true` if the reception for `message` has been marked processed.\n    pub(crate) unconstrained fn is_processed(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        message: OffchainMessage,\n    ) -> bool {\n        let maybe_collection = get_fact_collection(\n            contract_address,\n            FactScope::account(scope),\n            OFFCHAIN_RECEPTION_TYPE_ID,\n            Self::id_for(message),\n        );\n        if maybe_collection.is_some() {\n            maybe_collection.unwrap().facts.any(|f: Fact| f.fact_type_id == OFFCHAIN_MESSAGE_PROCESSED)\n        } else {\n            false\n        }\n    }\n\n    /// Records the retractable processed marker for this reception, originated at the resolved block.\n    unconstrained fn mark_processed(self, block_number: u32, block_hash: Field) {\n        let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n        record_retractable_fact(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n            OFFCHAIN_MESSAGE_PROCESSED,\n            empty_payload,\n            BlockReference { block_number, block_hash },\n        );\n    }\n\n    /// Terminates this reception by deleting its [fact collection](crate::facts::FactCollection).\n    unconstrained fn terminate(self) {\n        delete_fact_collection(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n        );\n    }\n}\n\n/// Serializes an [`OffchainMessage`] into a fact payload.\nunconstrained fn to_payload(message: OffchainMessage) -> EphemeralArray<Field> {\n    EphemeralArray::from_array(message.serialize())\n}\n\nmod test {\n    use crate::{\n        messages::processing::offchain::OffchainMessage,\n        oracle::{random::random, tx_resolution::ResolvedTx},\n        protocol::address::AztecAddress,\n        test::helpers::test_environment::TestEnvironment,\n    };\n    use super::{MAX_MSG_TTL, OffchainReception};\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// Creates an `OffchainMessage` with dummy ciphertext and the given scope as recipient.\n    fn make_msg(recipient: AztecAddress, tx_hash: Option<Field>, anchor_block_timestamp: u64) -> OffchainMessage {\n        OffchainMessage { ciphertext: BoundedVec::new(), recipient, tx_hash, anchor_block_timestamp }\n    }\n\n    /// Builds the resolved-tx context PXE would return for `tx_hash`, found in `block_number`.\n    fn resolved_tx_at_block(tx_hash: Field, block_number: u32) -> ResolvedTx {\n        ResolvedTx {\n            tx_hash,\n            unique_note_hashes_in_tx: BoundedVec::new(),\n            first_nullifier_in_tx: 0,\n            block_number,\n            block_hash: 0,\n        }\n    }\n\n    /// Builds a resolved-tx context found in a low block, which TXE (proven == finalized == latest) reports as\n    /// `Finalized`.\n    fn resolved_tx(tx_hash: Field) -> ResolvedTx {\n        resolved_tx_at_block(tx_hash, 1)\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_terminated() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Past the TTL with no resolved tx: the reception is terminated.\n            assert(reception.step(Option::none(), MAX_MSG_TTL + 1).is_none());\n            assert(!OffchainReception::is_active(address, scope, msg), \"expired reception should be terminated\");\n        });\n    }\n\n    #[test]\n    unconstrained fn unresolved_reception_stays_active() {\n        let (env, scope) = setup();\n        let msg = make_msg(scope, Option::some(random()), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // Within the TTL with no resolved tx: nothing to process, the reception stays.\n            assert(reception.step(Option::none(), 100).is_none());\n            assert(OffchainReception::is_active(address, scope, msg), \"unresolved reception should stay active\");\n            assert(!OffchainReception::is_processed(address, scope, msg), \"should still be unprocessed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn resolved_reception_is_ready_to_process() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n            let reception = OffchainReception::load_all(address, scope).get(0);\n\n            // A resolved tx within the TTL: the message is handed off with its tx context attached.\n            let processable = reception.step(Option::some(resolved_tx(tx_hash)), 100);\n            assert(processable.is_some());\n            assert_eq(processable.unwrap().resolved_tx.tx_hash, tx_hash);\n\n            // It stays active for reorg safety and is now marked processed.\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should stay active\");\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n        });\n    }\n\n    #[test]\n    unconstrained fn already_processed_reception_is_not_re_pushed() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n        // A future origin block stays unfinalized, so the reception lingers in Processed across steps.\n        let future_block = env.last_block_number() + 100;\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // First step processes the message.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Second step (still resolved, not finalized) recognizes it as processed and does not re-push it.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(\n                reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_none(),\n                \"already processed\",\n            );\n            assert(OffchainReception::is_active(address, scope, msg), \"processed reception should still be active\");\n        });\n    }\n\n    #[test]\n    unconstrained fn processed_reception_terminates_once_its_origin_block_finalizes() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // Process the message against a finalized block.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Next step, still well within the TTL: a finalized origin block makes the processing reorg-proof, so the\n            // reception terminates regardless of the TTL.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx(tx_hash)), 100).is_none());\n            assert(\n                !OffchainReception::is_active(address, scope, msg),\n                \"finalized processed reception should be terminated\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn unfinalized_processed_reception_survives_past_the_ttl() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n        // A future origin block never finalizes here, so the reception must not be terminated by the TTL.\n        let future_block = env.last_block_number() + 100;\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), 100).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n\n            // Past the TTL, but the origin block has not finalized: the reception stays active. The TTL no longer\n            // governs an already-processed reception.\n            let reloaded = OffchainReception::load_all(address, scope).get(0);\n            assert(reloaded.step(Option::some(resolved_tx_at_block(tx_hash, future_block)), MAX_MSG_TTL + 1).is_none());\n            assert(\n                OffchainReception::is_active(address, scope, msg),\n                \"unfinalized processed reception should survive past the TTL\",\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn expired_reception_is_still_processed_when_its_tx_resolves() {\n        let (env, scope) = setup();\n        let tx_hash = random();\n        let msg = make_msg(scope, Option::some(tx_hash), 0);\n\n        env.utility_context(|context| {\n            let address = context.this_address();\n            OffchainReception::init(address, msg);\n\n            // Even past the TTL, a freshly resolved tx is still handed off: expiry only caps the search for the\n            // originating tx, it does not pre-empt processing once that tx is found.\n            let reception = OffchainReception::load_all(address, scope).get(0);\n            assert(reception.step(Option::some(resolved_tx(tx_hash)), MAX_MSG_TTL + 1).is_some());\n            assert(OffchainReception::is_processed(address, scope, msg), \"should be processed\");\n            assert(OffchainReception::is_active(address, scope, msg), \"just-processed reception should stay active\");\n        });\n    }\n}\n"
     },
     "17": {
       "function_locations": [
@@ -1602,7 +1602,7 @@
       "path": "std/hash/mod.nr",
       "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A> Hash for (A,)\nwhere\n    A: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_> Hash for (A, B, C, D, E, F, G, H_)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I> Hash for (A, B, C, D, E, F, G, H_, I)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J> Hash for (A, B, C, D, E, F, G, H_, I, J)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K> Hash for (A, B, C, D, E, F, G, H_, I, J, K)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K, L> Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n    L: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n        self.11.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n        },\n    );\n}\n"
     },
-    "184": {
+    "185": {
       "function_locations": [
         {
           "name": "compute_note_hash",
@@ -1628,7 +1628,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/note/utils.nr",
       "source": "use crate::{context::NoteExistenceRequest, note::{ConfirmedNote, HintedNote, note_interface::NoteHash}};\n\nuse crate::protocol::{\n    constants::{DOM_SEP__NOTE_HASH, DOM_SEP__NOTE_NULLIFIER},\n    hash::{compute_siloed_note_hash, compute_unique_note_hash, poseidon2_hash_with_separator},\n};\n\n/// Computes a domain-separated note hash.\n///\n/// Receives the `storage_slot` of the [`crate::state_vars::StateVariable`] that holds the note, plus any arbitrary\n/// note `data`. This typically includes randomness, owner, and domain specific values (e.g. numeric amount, address,\n/// id, etc.).\n///\n/// Usage of this function guarantees that different state variables will never produce colliding note hashes, even if\n/// their underlying notes have different implementations.\npub fn compute_note_hash<let N: u32>(storage_slot: Field, data: [Field; N]) -> Field {\n    // All state variables have different storage slots, so by placing this at a fixed first position in the preimage\n    // we prevent collisions.\n    poseidon2_hash_with_separator([storage_slot].concat(data), DOM_SEP__NOTE_HASH)\n}\n\n/// Computes a domain-separated note nullifier.\n///\n/// Receives the `note_hash_for_nullification` of the note (usually returned by\n/// [`compute_confirmed_note_hash_for_nullification`]), plus any arbitrary note `data`. This typically includes\n/// secrets, such as the app-siloed nullifier hiding key of the note's owner.\n///\n/// Usage of this function guarantees that different state variables will never produce colliding note nullifiers, even\n/// if their underlying notes have different implementations.\npub fn compute_note_nullifier<let N: u32>(note_hash_for_nullification: Field, data: [Field; N]) -> Field {\n    // All notes have different note hashes for nullification (i.e. transient or settled), so by placing this at a\n    // fixed first position in the preimage we prevent collisions.\n    poseidon2_hash_with_separator(\n        [note_hash_for_nullification].concat(data),\n        DOM_SEP__NOTE_NULLIFIER,\n    )\n}\n\n/// Returns the [`NoteExistenceRequest`] used to prove a note exists.\npub fn compute_note_existence_request<Note>(hinted_note: HintedNote<Note>) -> NoteExistenceRequest\nwhere\n    Note: NoteHash,\n{\n    let note_hash =\n        hinted_note.note.compute_note_hash(hinted_note.owner, hinted_note.storage_slot, hinted_note.randomness);\n\n    if hinted_note.metadata.is_settled() {\n        // Settled notes are read by siloing with contract address and nonce (resulting in the final unique note hash,\n        // which is already in the note hash tree).\n        let siloed_note_hash = compute_siloed_note_hash(hinted_note.contract_address, note_hash);\n        NoteExistenceRequest::for_settled(compute_unique_note_hash(\n            hinted_note.metadata.to_settled().note_nonce(),\n            siloed_note_hash,\n        ))\n    } else {\n        // Pending notes (both same phase and previous phase ones) are read by their non-siloed hash (not even by\n        // contract address), which is what is stored in the new note hashes array (at the position hinted by note hash\n        // counter).\n        NoteExistenceRequest::for_pending(note_hash, hinted_note.contract_address)\n    }\n}\n\n/// Unconstrained variant of [`compute_confirmed_note_hash_for_nullification`].\npub unconstrained fn compute_note_hash_for_nullification<Note>(hinted_note: HintedNote<Note>) -> Field\nwhere\n    Note: NoteHash,\n{\n    // Creating a ConfirmedNote like we do here is typically unsafe, as we've not confirmed existence. We can do it\n    // here because this is an unconstrained function, so the returned value should not make its way to a constrained\n    // function. This lets us reuse the `compute_confirmed_note_hash_for_nullification` implementation.\n    compute_confirmed_note_hash_for_nullification(ConfirmedNote::new(\n        hinted_note,\n        compute_note_existence_request(hinted_note).note_hash(),\n    ))\n}\n\n/// Returns the note hash to use when computing its nullifier.\n///\n/// The `note_hash_for_nullification` parameter [`NoteHash::compute_nullifier`] takes depends on the note's stage, e.g.\n/// settled notes use the unique note hash, but pending notes cannot as they have no nonce. This function returns the\n/// correct note hash to use.\n///\n/// Use [`compute_note_hash_for_nullification`] when computing this value in unconstrained functions.\npub fn compute_confirmed_note_hash_for_nullification<Note>(confirmed_note: ConfirmedNote<Note>) -> Field {\n    // There is just one instance in which the note hash for nullification does not match the note hash used for a read\n    // request, which is when dealing with pending previous phase notes. These had their existence proven using their\n    // non-siloed note hash along with the note hash counter (like all pending notes), but since they will be\n    // unconditionally inserted in the note hash tree (since they cannot be squashed) they must be nullified using the\n    // *unique* note hash. If we didn't, it'd be possible to emit a second different nullifier for the same note in a\n    // follow up transaction, once the note is settled, resulting in a double spend.\n\n    if confirmed_note.metadata.is_pending_previous_phase() {\n        let siloed_note_hash = compute_siloed_note_hash(\n            confirmed_note.contract_address,\n            confirmed_note.proven_note_hash,\n        );\n        let note_nonce = confirmed_note.metadata.to_pending_previous_phase().note_nonce();\n\n        compute_unique_note_hash(note_nonce, siloed_note_hash)\n    } else {\n        confirmed_note.proven_note_hash\n    }\n}\n"
     },
-    "187": {
+    "188": {
       "function_locations": [
         {
           "name": "aes128_decrypt_oracle",
@@ -1650,7 +1650,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "192": {
+    "193": {
       "function_locations": [
         {
           "name": "call_private_function_oracle",
@@ -1664,7 +1664,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(aztec_prv_callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> (u32, Field) {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    )\n}\n"
     },
-    "193": {
+    "194": {
       "function_locations": [
         {
           "name": "call_utility_function_oracle",
@@ -1678,7 +1678,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/call_utility_function.nr",
       "source": "use crate::protocol::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(aztec_utl_callUtilityFunction)]\nunconstrained fn call_utility_function_oracle<let M: u32, let N: u32>(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args: [Field; M],\n) -> [Field; N] {}\n\npub unconstrained fn call_utility_function<let M: u32, let N: u32>(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args: [Field; M],\n) -> [Field; N] {\n    call_utility_function_oracle(contract_address, function_selector, args)\n}\n"
     },
-    "195": {
+    "196": {
       "function_locations": [
         {
           "name": "set_contract_sync_cache_invalid_oracle",
@@ -1692,7 +1692,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "197": {
+    "198": {
       "function_locations": [
         {
           "name": "get_utility_context_oracle",
@@ -1706,7 +1706,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use crate::context::UtilityContext;\nuse crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress};\n\n/// Wire shape of [`get_utility_context_oracle`]'s response. [`UtilityContext`] is built from it rather than returned\n/// directly so its fields stay private to its module.\n#[derive(Eq)]\npub(crate) struct UtilityContextData {\n    pub(crate) block_header: BlockHeader,\n    pub(crate) contract_address: AztecAddress,\n    pub(crate) msg_sender: AztecAddress,\n}\n\n#[oracle(aztec_utl_getUtilityContext)]\nunconstrained fn get_utility_context_oracle() -> UtilityContextData {}\n\n/// Returns a utility context built from the global variables of anchor block and the contract address of the function\n/// being executed.\npub unconstrained fn get_utility_context() -> UtilityContext {\n    UtilityContext::from(get_utility_context_oracle())\n}\n"
     },
-    "198": {
+    "199": {
       "function_locations": [
         {
           "name": "store",
@@ -1732,7 +1732,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\n// TODO(F-498): review naming consistency\npub fn store<let N: u32>(values: [Field; N], hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { set_hash_preimage_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn set_hash_preimage_oracle_wrapper<let N: u32>(values: [Field; N], hash: Field) {\n    set_hash_preimage_oracle(values, hash);\n}\n\n// TODO(F-498): review naming consistency\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    get_hash_preimage_oracle(hash)\n}\n\n#[oracle(aztec_prv_setHashPreimage)]\nunconstrained fn set_hash_preimage_oracle<let N: u32>(_values: [Field; N], _hash: Field) {}\n\n#[oracle(aztec_prv_getHashPreimage)]\nunconstrained fn get_hash_preimage_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "205": {
+    "206": {
       "function_locations": [
         {
           "name": "get_key_validation_request_oracle",
@@ -1746,7 +1746,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr",
       "source": "use crate::protocol::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(aztec_utl_getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(_pk_m_hash: Field, _key_index: Field) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(pk_m_hash: Field, key_index: Field) -> KeyValidationRequest {\n    get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n"
     },
-    "206": {
+    "207": {
       "function_locations": [
         {
           "name": "get_public_keys_and_partial_address",
@@ -1764,7 +1764,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/keys.nr",
       "source": "use crate::protocol::{address::{AztecAddress, PartialAddress}, public_keys::PublicKeys};\n\n// TODO(F-498): review naming consistency\npub unconstrained fn get_public_keys_and_partial_address(address: AztecAddress) -> (PublicKeys, PartialAddress) {\n    try_get_public_keys_and_partial_address(address).expect(f\"Public keys not registered for account {address}\")\n}\n\n/// Five of the six master public keys are exposed only as hashes; `ivpk_m` is sent as its affine coordinates because\n/// address derivation and encrypt-to-address require the point in-circuit. This point is assumed to be non-infinite.\n#[oracle(aztec_utl_getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(\n    _address: AztecAddress,\n) -> Option<(PublicKeys, PartialAddress)> {}\n\n// TODO(F-498): review naming consistency\npub unconstrained fn try_get_public_keys_and_partial_address(\n    address: AztecAddress,\n) -> Option<(PublicKeys, PartialAddress)> {\n    get_public_keys_and_partial_address_oracle(address)\n}\n"
     },
-    "208": {
+    "209": {
       "function_locations": [
         {
           "name": "get_pending_tagged_logs",
@@ -1810,7 +1810,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::messages::processing::{\n    event_validation_request::EventValidationRequest, log_retrieval_request::LogRetrievalRequest,\n    log_retrieval_response::LogRetrievalResponse, NoteValidationRequest, pending_tagged_log::PendingTaggedLog,\n    provided_secret::ProvidedSecret,\n};\nuse crate::protocol::address::AztecAddress;\nuse crate::protocol::blob_data::TxEffect;\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and\n/// returns them in an ephemeral array with an oracle-allocated base slot.\n///\n/// # Arguments\n///\n/// * `scope` - The account scope to search under.\n/// * `provided_secrets` - Tagging secrets the app supplies explicitly, searched alongside the secrets PXE manages\n///   internally. Used for secrets PXE cannot derive itself (e.g. handshake-derived ones).\npub(crate) unconstrained fn get_pending_tagged_logs(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {\n    get_pending_tagged_logs_oracle(scope, provided_secrets)\n}\n\n#[oracle(aztec_utl_getPendingTaggedLogsV2)]\nunconstrained fn get_pending_tagged_logs_oracle(\n    scope: AztecAddress,\n    provided_secrets: EphemeralArray<ProvidedSecret>,\n) -> EphemeralArray<PendingTaggedLog> {}\n\n/// Validates note/event requests stored in ephemeral arrays.\npub(crate) unconstrained fn validate_and_store_enqueued_notes_and_events(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {\n    validate_and_store_enqueued_notes_and_events_oracle(note_validation_requests, event_validation_requests, scope);\n}\n\n#[oracle(aztec_utl_validateAndStoreEnqueuedNotesAndEvents)]\nunconstrained fn validate_and_store_enqueued_notes_and_events_oracle(\n    note_validation_requests: EphemeralArray<NoteValidationRequest>,\n    event_validation_requests: EphemeralArray<EventValidationRequest>,\n    scope: AztecAddress,\n) {}\n\n/// Fetches all logs matching each request's tag and returns a nested ephemeral array.\n///\n/// Each element in the outer array is an inner `EphemeralArray<LogRetrievalResponse>` containing all matching logs for\n/// the request at the same index (which may be empty if no logs were found).\npub unconstrained fn get_logs_by_tag(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {\n    get_logs_by_tag_oracle(requests)\n}\n\n#[oracle(aztec_utl_getLogsByTagV2)]\nunconstrained fn get_logs_by_tag_oracle(\n    requests: EphemeralArray<LogRetrievalRequest>,\n) -> EphemeralArray<EphemeralArray<LogRetrievalResponse>> {}\n\n/// Fetches all effects of a settled transaction by its hash.\npub unconstrained fn get_tx_effect(tx_hash: Field) -> Option<TxEffect> {\n    get_tx_effect_oracle(tx_hash)\n}\n\n#[oracle(aztec_utl_getTxEffect)]\nunconstrained fn get_tx_effect_oracle(tx_hash: Field) -> Option<TxEffect> {}\n\n/// Fetches all effects of settled transactions by hash, preserving request order.\npub unconstrained fn get_tx_effects(tx_hashes: EphemeralArray<Field>) -> EphemeralArray<Option<TxEffect>> {\n    get_tx_effects_oracle(tx_hashes)\n}\n\n#[oracle(aztec_utl_getTxEffects)]\nunconstrained fn get_tx_effects_oracle(tx_hashes: EphemeralArray<Field>) -> EphemeralArray<Option<TxEffect>> {}\n"
     },
-    "211": {
+    "212": {
       "function_locations": [
         {
           "name": "notify_created_nullifier",
@@ -1844,7 +1844,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/nullifiers.nr",
       "source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::block_reference::BlockReference;\nuse crate::protocol::{address::aztec_address::AztecAddress, traits::Deserialize};\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns `true` if the nullifier has been emitted in the same transaction, i.e. if [`notify_created_nullifier`] has\n/// been\n/// called for this inner nullifier from the contract with the specified address.\n///\n/// Note that despite sharing pending transaction information with the app, this is not a privacy leak: anyone in the\n/// network can always determine in which transaction a inner nullifier was emitted by a given contract by simply\n/// inspecting transaction effects. What _would_ constitute a leak would be to share the list of inner pending\n/// nullifiers, as that would reveal their preimages.\npub unconstrained fn is_nullifier_pending(inner_nullifier: Field, contract_address: AztecAddress) -> bool {\n    is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(_inner_nullifier: Field, _contract_address: AztecAddress) -> bool {}\n\n/// The existence status of a nullifier.\n#[derive(Deserialize, Eq)]\npub struct NullifierStatus {\n    pub exists: bool,\n\n    /// The block the nullifier was included in.\n    ///\n    /// `None` if the nullifier does not exist, or if it is pending (emitted earlier in the current transaction and not\n    /// yet in any block).\n    pub origin_block: Option<BlockReference>,\n}\n\n/// Returns the existence status of multiple nullifiers.\n///\n/// Same guarantees as [`check_nullifier_exists`]: an existing nullifier can be constrained by proving its inclusion,\n/// but a non-existent one cannot be relied upon. Proving the `origin_block` however is fairly involved, as it'd require\n/// proving existence of the transaction in which the nullifier was emitted, inclusion of the transaction in the block,\n/// and ancestry of the block in the anchor block.\npub unconstrained fn get_nullifier_statuses(\n    inner_nullifiers: EphemeralArray<Field>,\n) -> EphemeralArray<NullifierStatus> {\n    get_nullifier_statuses_oracle(inner_nullifiers)\n}\n\n/// Returns `true` if the nullifier exists.\n///\n/// Note that a `true` value can be constrained by proving existence of the nullifier, but a `false` value should not be\n/// relied upon since other transactions may emit this nullifier before the current transaction is included in a block.\n/// While this might seem of little use at first, certain design patterns benefit from this abstraction (see e.g.\n/// `PrivateMutable`).\n// TODO(F-498): review naming consistency\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    get_nullifier_statuses(EphemeralArray::from_array([inner_nullifier])).get(0).exists\n}\n\n#[oracle(aztec_utl_getNullifierStatuses)]\nunconstrained fn get_nullifier_statuses_oracle(\n    _inner_nullifiers: EphemeralArray<Field>,\n) -> EphemeralArray<NullifierStatus> {}\n"
     },
-    "213": {
+    "214": {
       "function_locations": [
         {
           "name": "assert_valid_public_call_data",
@@ -1862,7 +1862,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/public_call.nr",
       "source": "/// Validates public calldata by checking that the preimage exists and the cumulative size is within limits.\n///\n/// The check is unconstrained and the only purpose of it is to fail early in case of calldata overflow or a bug in\n/// calldata hashing.\npub(crate) fn assert_valid_public_call_data(calldata_hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects (validating the calldata).\n    // It is therefore always safe to call.\n    unsafe {\n        assert_valid_public_call_data_oracle_wrapper(calldata_hash)\n    }\n}\n\nunconstrained fn assert_valid_public_call_data_oracle_wrapper(calldata_hash: Field) {\n    assert_valid_public_call_data_oracle(calldata_hash)\n}\n\n#[oracle(aztec_prv_assertValidPublicCalldata)]\nunconstrained fn assert_valid_public_call_data_oracle(_calldata_hash: Field) {}\n"
     },
-    "214": {
+    "215": {
       "function_locations": [
         {
           "name": "random",
@@ -1876,7 +1876,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
       "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values. In some applications this\n/// behavior might not be acceptable and other techniques might be more suitable, such as producing pseudo-random\n/// values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n    rand_oracle()\n}\n\n#[oracle(aztec_misc_getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
     },
-    "217": {
+    "218": {
       "function_locations": [
         {
           "name": "get_shared_secrets_oracle",
@@ -1922,7 +1922,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::protocol::{address::AztecAddress, hash::sha256_to_field, point::EmbeddedCurvePoint};\n\nglobal GET_SHARED_SECRET_SINGLE_SLOT: Field = sha256_to_field(\"AZTEC_NR::GET_SHARED_SECRET_SINGLE_SLOT\".as_bytes());\n\n#[oracle(aztec_utl_getSharedSecrets)]\nunconstrained fn get_shared_secrets_oracle(\n    address: AztecAddress,\n    eph_pks: EphemeralArray<EmbeddedCurvePoint>,\n    contract_address: AztecAddress,\n) -> EphemeralArray<Field> {}\n\n/// Convenience wrapper around [`get_shared_secrets`] for a single ephemeral public key.\n///\n/// Returns `none` when the PXE does not hold `address`'s keys and therefore cannot derive the secret.\npub unconstrained fn get_shared_secret(\n    address: AztecAddress,\n    eph_pk: EmbeddedCurvePoint,\n    contract_address: AztecAddress,\n) -> Option<Field> {\n    let eph_pks: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(GET_SHARED_SECRET_SINGLE_SLOT);\n    eph_pks.push(eph_pk);\n    let secrets = get_shared_secrets(address, eph_pks, contract_address);\n    if secrets.len() == 1 {\n        Option::some(secrets.get(0))\n    } else {\n        Option::none()\n    }\n}\n\n/// Returns app-siloed shared secrets between `address` and someone who knows the secret keys behind the given\n/// ephemeral public keys.\n///\n/// Each returned Field `s_app` is computed as:\n///\n/// ```text\n/// S     = address_secret * ephPk          (raw ECDH point)\n/// s_app = h(DOM_SEP, S.x, S.y, contract)  (app-siloed scalar)\n/// ```\n///\n/// where `contract` is the address of the calling contract. The oracle host validates this matches its execution\n/// context.\n///\n/// Without app-siloing, a malicious contract could call this oracle with public information (address, ephPk) and\n/// obtain the same raw secret as the legitimate contract, enabling cross-contract decryption. By including the\n/// contract address in the hash, each contract receives a different `s_app`, preventing this attack.\n///\n/// Callers derive indexed subkeys from `s_app` via\n/// [`derive_shared_secret_subkey`](crate::keys::ecdh_shared_secret::derive_shared_secret_subkey).\n///\n/// Returns an empty array when the PXE does not hold `address`'s keys and therefore cannot derive any secrets. This\n/// happens when syncing the scope of an address the PXE does not control, and is an expected outcome rather than an\n/// error. Any other response length mismatch is a malformed oracle response.\npub unconstrained fn get_shared_secrets(\n    address: AztecAddress,\n    eph_pks: EphemeralArray<EmbeddedCurvePoint>,\n    contract_address: AztecAddress,\n) -> EphemeralArray<Field> {\n    let response = get_shared_secrets_oracle(address, eph_pks, contract_address);\n    assert(\n        (response.len() == eph_pks.len()) | (response.len() == 0),\n        \"get_shared_secrets: response length does not match request length\",\n    );\n    response\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::oracle::shared_secret::{get_shared_secret, get_shared_secrets};\n    use crate::protocol::{address::AztecAddress, traits::FromField};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use crate::utils::point::point_from_x_coord;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn preserves_ephemeral_key_ordering() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([100, 200, 300]);\n\n            let pk_a = point_from_x_coord(1).unwrap();\n            let pk_b = point_from_x_coord(2).unwrap();\n            let pk_c = point_from_x_coord(8).unwrap();\n\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk_a);\n            eph_pks.push(pk_b);\n            eph_pks.push(pk_c);\n\n            let _: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(eph_pks.get(0), pk_a);\n            assert_eq(eph_pks.get(1), pk_b);\n            assert_eq(eph_pks.get(2), pk_c);\n        });\n    }\n\n    #[test]\n    unconstrained fn returns_secrets_in_order() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111, 222, 333]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk);\n            eph_pks.push(pk);\n            eph_pks.push(pk);\n\n            let results: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(results.get(0), 111);\n            assert_eq(results.get(1), 222);\n            assert_eq(results.get(2), 333);\n        });\n    }\n\n    #[test]\n    unconstrained fn returns_empty_when_pxe_does_not_hold_keys() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let empty: [Field; 0] = [];\n            let _ = mock_get_shared_secrets(empty);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk);\n\n            let results: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n\n            assert_eq(results.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn single_secret_returns_the_secret() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let secret = get_shared_secret(AztecAddress::from_field(1), pk, AztecAddress::from_field(2));\n\n            assert_eq(secret.unwrap(), 111);\n        });\n    }\n\n    #[test]\n    unconstrained fn single_secret_returns_none_when_pxe_does_not_hold_keys() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let empty: [Field; 0] = [];\n            let _ = mock_get_shared_secrets(empty);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let secret = get_shared_secret(AztecAddress::from_field(1), pk, AztecAddress::from_field(2));\n\n            assert(secret.is_none());\n        });\n    }\n\n    #[test(should_fail_with = \"response length does not match request length\")]\n    unconstrained fn cannot_return_mismatched_length() {\n        let env = TestEnvironment::new();\n        env.utility_context(|_| {\n            let _ = mock_get_shared_secrets([111, 222]);\n\n            let pk = point_from_x_coord(1).unwrap();\n            let eph_pks: EphemeralArray<_> = EphemeralArray::empty_at(200);\n            eph_pks.push(pk);\n\n            let _: EphemeralArray<Field> = get_shared_secrets(\n                AztecAddress::from_field(1),\n                eph_pks,\n                AztecAddress::from_field(2),\n            );\n        });\n    }\n\n    unconstrained fn mock_get_shared_secrets<let N: u32>(response_values: [Field; N]) -> Field {\n        let response_slot: Field = 99;\n        let response_array: EphemeralArray<Field> = EphemeralArray::at(response_slot);\n        for value in response_values {\n            response_array.push(value);\n        }\n        let _ = OracleMock::mock(\"aztec_utl_getSharedSecrets\").returns(response_slot);\n        response_slot\n    }\n}\n"
     },
-    "220": {
+    "221": {
       "function_locations": [
         {
           "name": "notify_revertible_phase_start",
@@ -1948,7 +1948,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/tx_phase.nr",
       "source": "/// Notifies PXE of the side effect counter at which the revertible phase begins.\n///\n/// PXE uses it to classify notes and nullifiers as revertible or non-revertible in its note cache. This information is\n/// then fed to kernels as hints.\npub(crate) fn notify_revertible_phase_start(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_revertible_phase_start_oracle_wrapper(counter) };\n}\n\n/// Returns whether a side effect counter falls in the revertible phase of the transaction.\npub(crate) unconstrained fn is_execution_in_revertible_phase(current_counter: u32) -> bool {\n    is_execution_in_revertible_phase_oracle(current_counter)\n}\n\nunconstrained fn notify_revertible_phase_start_oracle_wrapper(counter: u32) {\n    notify_revertible_phase_start_oracle(counter);\n}\n\n#[oracle(aztec_prv_notifyRevertiblePhaseStart)]\nunconstrained fn notify_revertible_phase_start_oracle(_counter: u32) {}\n\n#[oracle(aztec_prv_isExecutionInRevertiblePhase)]\nunconstrained fn is_execution_in_revertible_phase_oracle(current_counter: u32) -> bool {}\n"
     },
-    "221": {
+    "222": {
       "function_locations": [
         {
           "name": "get_resolved_txs",
@@ -1962,7 +1962,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/tx_resolution.nr",
       "source": "use crate::ephemeral::EphemeralArray;\nuse crate::protocol::{constants::MAX_NOTE_HASHES_PER_TX, traits::{Deserialize, Serialize}};\n\n/// The resolved on-chain context of a transaction.\n#[derive(Serialize, Deserialize, Eq)]\npub struct ResolvedTx {\n    pub tx_hash: Field,\n    pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    pub first_nullifier_in_tx: Field,\n    pub block_number: u32,\n    pub block_hash: Field,\n}\n\n/// Resolves the on-chain context of each tx hash.\npub(crate) unconstrained fn get_resolved_txs(requests: EphemeralArray<Field>) -> EphemeralArray<Option<ResolvedTx>> {\n    get_resolved_txs_oracle(requests)\n}\n\n#[oracle(aztec_utl_getResolvedTxs)]\nunconstrained fn get_resolved_txs_oracle(requests: EphemeralArray<Field>) -> EphemeralArray<Option<ResolvedTx>> {}\n"
     },
-    "222": {
+    "223": {
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
@@ -1986,155 +1986,155 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
-      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 32;\npub global ORACLE_VERSION_MINOR: Field = 2;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
+      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 33;\npub global ORACLE_VERSION_MINOR: Field = 0;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
     },
-    "223": {
+    "224": {
       "function_locations": [
         {
           "name": "PartialNoteFsm::init",
-          "start": 6368
+          "start": 6379
         },
         {
           "name": "PartialNoteFsm::load_all",
-          "start": 6873
+          "start": 6904
         },
         {
           "name": "PartialNoteFsm::id_for",
-          "start": 7182
+          "start": 7280
         },
         {
           "name": "PartialNoteFsm::read_pending_partial_note",
-          "start": 7403
+          "start": 7501
         },
         {
           "name": "PartialNoteFsm::is_completed",
-          "start": 7890
+          "start": 7988
         },
         {
           "name": "PartialNoteFsm::is_pending",
-          "start": 8137
+          "start": 8235
         },
         {
           "name": "PartialNoteFsm::completion_log_origin",
-          "start": 8328
+          "start": 8426
         },
         {
           "name": "PartialNoteFsm::mark_completed",
-          "start": 8749
+          "start": 8847
         },
         {
           "name": "PartialNoteFsm::terminate",
-          "start": 9228
+          "start": 9326
         },
         {
           "name": "PartialNoteFsm::step",
-          "start": 10008
+          "start": 10106
         },
         {
           "name": "PartialNoteFsm::step_pending",
-          "start": 10682
+          "start": 10780
         },
         {
           "name": "PartialNoteFsm::step_completed",
-          "start": 11904
+          "start": 12002
         },
         {
           "name": "PartialNoteFsm::complete_with_log",
-          "start": 12963
+          "start": 13061
         },
         {
           "name": "to_payload",
-          "start": 16595
+          "start": 16693
         },
         {
           "name": "test::setup",
-          "start": 17418
+          "start": 17516
         },
         {
           "name": "test::make_pending",
-          "start": 17688
+          "start": 17786
         },
         {
           "name": "test::finalized_block",
-          "start": 18057
+          "start": 18155
         },
         {
           "name": "test::init_creates_a_partial_note_fsm_in_pending_state",
-          "start": 18208
+          "start": 18306
         },
         {
           "name": "test::read_pending_round_trips_the_delivered_content",
-          "start": 18789
+          "start": 18887
         },
         {
           "name": "test::mark_completed_moves_to_completed",
-          "start": 19406
+          "start": 19504
         },
         {
           "name": "test::terminate_deletes_the_collection",
-          "start": 20063
+          "start": 20161
         },
         {
           "name": "test::re_init_is_idempotent",
-          "start": 20505
+          "start": 20603
         },
         {
           "name": "test::step_leaves_a_pending_reception_untouched_when_it_has_no_completion_log",
-          "start": 21014
+          "start": 21112
         },
         {
           "name": "test::complete_with_log_advances_a_pending_reception_whose_log_yields_no_notes",
-          "start": 22285
+          "start": 22383
         },
         {
           "name": "test::complete_with_log_advances_when_combined_content_exceeds_note_packed_len",
-          "start": 23362
+          "start": 23460
         },
         {
           "name": "test::complete_with_log_advances_when_the_log_payload_is_empty",
-          "start": 24989
+          "start": 25087
         },
         {
           "name": "test::complete_with_log_discovers_a_note_whose_combined_content_fills_note_packed_len",
-          "start": 26089
+          "start": 26187
         },
         {
           "name": "test::step_completes_once_when_multiple_completion_logs_are_found",
-          "start": 27988
+          "start": 28086
         },
         {
           "name": "test::step_terminates_a_completed_reception_once_its_block_is_finalized",
-          "start": 29417
+          "start": 29515
         },
         {
           "name": "test::step_keeps_a_completed_reception_while_its_block_is_unfinalized",
-          "start": 30290
+          "start": 30388
         },
         {
           "name": "test::enqueued_note_count",
-          "start": 31723
+          "start": 31821
         },
         {
           "name": "test::matching_completion_log",
-          "start": 32213
+          "start": 32311
         },
         {
           "name": "test::completion_log_with_unrelated_note_hashes",
-          "start": 33162
+          "start": 33260
         },
         {
           "name": "test::dummy_compute_note_hash",
-          "start": 33807
+          "start": 33905
         },
         {
           "name": "test::dummy_compute_note_nullifier",
-          "start": 34168
+          "start": 34266
         }
       ],
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/partial_notes/fsm.nr",
-      "source": "//! The finite state machine to process a single partial note.\n//!\n//! A partial note arrives in two parts: a private part (delivered first, carrying the owner, randomness, completion-log\n//! tag, note type, and packed private content) and a public *completion log* (storage slot + packed public content).\n//! The note can only be discovered and stored once both are combined. The state chart below summarizes how a single\n//! partial note's process unfolds, including how reorgs cause it to rewind.\n//!\n//! ```text\n//!                   init() (partial note delivery message, including tx and block data)\n//!                         |\n//!                         v\n//!                     +-----------+    completion log found         +-----------+\n//!                ---- |           | ------------------------------> |           |\n//!  log not found |    |           |                                 |           |     discover note(s),\n//!                |--> |  PENDING  |                                 | COMPLETED | ~~> enqueue for storage, etc\n//!                     |           | <------------------------------ |           |\n//!                     |           |  completion log block re-orged  |           |\n//!                     +-----------+                                 +-----------+\n//!                         |                                               |\n//!                         |  delivery message block re-orged              |  completion log block finalized\n//!                         v                                               v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Pending**: the private part has been received but the completion log has not been found yet. While in this\n//!   state, message discovery keeps searching for that log on each sync.\n//! - **Completed**: the completion log was found, so the note was completed and enqueued for storage. Because the\n//!   block containing the completion log can be dropped by a reorg, this state is not terminal until the block\n//!   finalizes: a reorg dropping it rewinds the FSM back to `Pending` state.\n//! - **Terminated**: nothing else can be done with the partial note, either because its delivery block was re-orged\n//!   away (so the delivery itself was reverted) or because its completion block has finalized (so the discovered note\n//!   is permanent and reorg-proof). This is the terminal state of this FSM.\n//!\n//! ## Transitions (each evaluated by [`step`](PartialNoteFsm::step))\n//!\n//! - **Pending -> Completed** ([`complete_with_log`](PartialNoteFsm::complete_with_log)): the completion log is\n//!   found. Its public content is combined with the delivered private content, the resulting note(s) are discovered\n//!   and enqueued for storage.\n//! - **Completed -> Pending**: the completion log block is re-orged out. The completion log is searched for again.\n//! - **Pending -> Terminated**: the delivery block is re-orged out, retracting the `delivered` birth fact. The\n//!   delivery was reverted, so there is nothing left to do.\n//! - **Completed -> Terminated**: the completion log block finalizes, making the discovered note reorg-proof, so the\n//!   reception is complete and its collection is deleted.\n//!\n//! ## Implementation\n//!\n//! Each pending partial note is tracked as a [fact collection](crate::facts::FactCollection) of type\n//! `PARTIAL_NOTE_RECEPTION_TYPE_ID`, identified by a hash of its [`DeliveredPendingPartialNote`] content (so\n//! re-delivery of the same partial note is idempotent). The collection holds:\n//!\n//! - a retractable `PARTIAL_NOTE_DELIVERED` birth fact tied to a delivery block (so a reorg of that block auto-prunes\n//!   the pending note), whose payload is the serialized [`DeliveredPendingPartialNote`];\n//! - once the completion log is found, a retractable `PARTIAL_NOTE_COMPLETED` fact tied to the completion log block.\n//!\n//! Status folds from the canonical fact set:\n//!     - `delivered` only ⇒ Pending\n//!     - `delivered` + `completed` ⇒ Completed\n//!\n//! A reorg retracting either fact folds the reception back accordingly.\nuse crate::ephemeral::EphemeralArray;\nuse crate::facts::{\n    delete_fact_collection, Fact, FactCollection, get_fact_collections_by_type, record_retractable_fact,\n    RetractableFactOrigin,\n};\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::messages::{\n    discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n    logs::note::MAX_NOTE_PACKED_LEN,\n    processing::{enqueue_note_for_validation, log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN}},\n};\nuse crate::oracle::block_reference::BlockReference;\nuse crate::protocol::{address::AztecAddress, hash::{poseidon2_hash, sha256_to_field}, traits::{Deserialize, Serialize}};\nuse crate::utils::array;\nuse super::DeliveredPendingPartialNote;\n\n/// Fact-collection type id shared by every partial-note reception in the [fact store](crate::facts).\nglobal PARTIAL_NOTE_RECEPTION_TYPE_ID: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_RECEPTION_TYPE_ID\".as_bytes());\n\n/// Fact type id of the birth fact carrying the delivered private partial note.\nglobal PARTIAL_NOTE_DELIVERED: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_DELIVERED\".as_bytes());\n\n/// Fact type id marking a partial note as completed (its note has been discovered and enqueued).\nglobal PARTIAL_NOTE_COMPLETED: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_COMPLETED\".as_bytes());\n\n/// A single partial note's finite state machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n#[derive(Deserialize, Serialize)]\npub(crate) struct PartialNoteFsm {\n    collection: FactCollection,\n}\n\nimpl PartialNoteFsm {\n    /// Initializes an FSM for a freshly discovered partial note.\n    ///\n    /// The FSM existence is tied to `origin_block`: if `origin_block` is dropped by a reorg, the FSM is transparently\n    /// deleted.\n    pub(crate) unconstrained fn init(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        pending: DeliveredPendingPartialNote,\n        origin_block: BlockReference,\n    ) {\n        record_retractable_fact(\n            contract_address,\n            scope,\n            PARTIAL_NOTE_RECEPTION_TYPE_ID,\n            Self::id_for(pending),\n            PARTIAL_NOTE_DELIVERED,\n            to_payload(pending),\n            origin_block,\n        );\n    }\n\n    /// Loads every active partial-note FSM for the given contract and scope.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<PartialNoteFsm> {\n        get_fact_collections_by_type(contract_address, scope, PARTIAL_NOTE_RECEPTION_TYPE_ID)\n            .map(|collection: FactCollection| PartialNoteFsm { collection })\n    }\n\n    /// The fact-collection id identifying a specific partial note.\n    fn id_for(pending: DeliveredPendingPartialNote) -> Field {\n        poseidon2_hash(pending.serialize())\n    }\n\n    /// Reads and decodes the delivered partial note this FSM processes.\n    pub(crate) unconstrained fn read_pending_partial_note(self) -> DeliveredPendingPartialNote {\n        let delivered = self.collection.facts.find(|f: Fact| f.fact_type_id == PARTIAL_NOTE_DELIVERED).unwrap();\n        let mut fields = [0; <DeliveredPendingPartialNote as Deserialize>::N];\n        for i in 0..fields.len() {\n            fields[i] = delivered.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Whether the partial note FSM is in `completed` state, i.e. its note was completed and stored.\n    unconstrained fn is_completed(self) -> bool {\n        self.collection.facts.any(|f: Fact| f.fact_type_id == PARTIAL_NOTE_COMPLETED)\n    }\n\n    /// Whether the partial note FSM is in `pending` state, i.e. it hasn't been completed yet.\n    pub(crate) unconstrained fn is_pending(self) -> bool {\n        !self.is_completed()\n    }\n\n    /// Origin block of the partial note completion log, if available.\n    unconstrained fn completion_log_origin(self) -> Option<RetractableFactOrigin> {\n        let maybe_completed = self.collection.facts.find(|f: Fact| f.fact_type_id == PARTIAL_NOTE_COMPLETED);\n        if maybe_completed.is_some() {\n            maybe_completed.unwrap().origin_block\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Transition the partial note FSM as `completed`, conditional to `origin_block`.\n    unconstrained fn mark_completed(self, origin_block: BlockReference) {\n        let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n        record_retractable_fact(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n            PARTIAL_NOTE_COMPLETED,\n            empty_payload,\n            origin_block,\n        );\n    }\n\n    /// Terminates this partial note FSM.\n    unconstrained fn terminate(self) {\n        delete_fact_collection(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n        );\n    }\n\n    /// Advances this partial-note FSM by one step.\n    ///\n    /// Partial notes can only be completed if completion logs have been found for them. Log discovery and\n    /// provisioning is responsibility of the caller.\n    ///\n    /// `compute_note_hash` and `compute_note_nullifier` are injected dependencies.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_completion_logs: Option<EphemeralArray<LogRetrievalResponse>>,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        if self.is_pending() {\n            self.step_pending(maybe_completion_logs, compute_note_hash, compute_note_nullifier);\n        } else {\n            self.step_completed();\n        }\n    }\n\n    /// Processes a partial note in pending state\n    ///\n    /// Completes the partial note if its completion log is given. If not, the partial note remains in pending state\n    /// and its completion log is searched for again on future syncs.\n    unconstrained fn step_pending(\n        self,\n        maybe_completion_logs: Option<EphemeralArray<LogRetrievalResponse>>,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        if maybe_completion_logs.is_some() {\n            let completion_logs = maybe_completion_logs.unwrap();\n            let num_logs = completion_logs.len();\n            if num_logs != 0 {\n                // The tag is not unique, so a pending partial note can resolve to more than one completion log (e.g.\n                // the same partial note completed twice). We complete with the first and ignore the rest rather than\n                // fail.\n                if num_logs > 1 {\n                    let tag = self.read_pending_partial_note().note_completion_log_tag;\n                    aztecnr_warn_log_format!(\n                        \"Found {0} completion logs for partial note with tag {1}, completing with the first\",\n                    )(\n                        [num_logs as Field, tag],\n                    );\n                }\n                self.complete_with_log(completion_logs.get(0), compute_note_hash, compute_note_nullifier);\n            }\n        }\n    }\n\n    /// Advances partial note in `completed` state: terminates it once the completion log block finalizes, since the\n    /// discovered note is then permanent and there is nothing left to track.\n    unconstrained fn step_completed(self) {\n        if self.completion_log_origin().unwrap().block_state.is_finalized() {\n            self.terminate();\n        }\n    }\n\n    /// Completes a partial note.\n    ///\n    /// Combines the delivered private content with the log's public content, discovers the resulting note(s), enqueues\n    /// them for validation, and transitions the FSM to `completed` state conditional to the completion log's block.\n    ///\n    /// A completion log that cannot yield a note (an empty payload, content too large to pack into a note, or one\n    /// matching no real note) is skipped without failing and the FSM still advances, so one bad message cannot break\n    /// sync.\n    ///\n    /// Because the completion fact is retractable, a reorg of the completion log's block rewinds the FSM back to\n    /// `pending` state (which signals that completion log search should restart).\n    unconstrained fn complete_with_log(\n        self,\n        log: LogRetrievalResponse,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        let pending = self.read_pending_partial_note();\n\n        // The completion log payload is the storage slot followed by the public note content, so an empty payload\n        // (e.g. an attacker's tag-only log) has no storage slot and no content.\n        let payload_len = log.log_payload.len();\n        let public_content_len = if payload_len == 0 { 0 } else { payload_len - 1 };\n\n        let combined_len = pending.packed_private_note_content.len() + public_content_len;\n\n        if payload_len == 0 {\n            aztecnr_warn_log_format!(\n                \"Partial note with tag {0} has an empty completion log, ignoring\",\n            )(\n                [pending.note_completion_log_tag],\n            );\n        } else if combined_len > MAX_NOTE_PACKED_LEN {\n            // A valid note packs into at most MAX_NOTE_PACKED_LEN fields, so this content cannot form one and would\n            // overflow the append below.\n            aztecnr_warn_log_format!(\n                \"Partial note with tag {0} has over-length content ({1} > {2} fields), ignoring\",\n            )(\n                [pending.note_completion_log_tag, combined_len as Field, MAX_NOTE_PACKED_LEN as Field],\n            );\n        } else {\n            let storage_slot = log.log_payload.get(0);\n            let public_note_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN - 1> = array::subbvec(log.log_payload, 1);\n\n            // Public fields are placed at the end of the packed representation, so we combine the private and public\n            // packed content to get the complete packed note.\n            let complete_packed_note = array::append(pending.packed_private_note_content, public_note_content);\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                self.collection.contract_address,\n                pending.owner,\n                storage_slot,\n                pending.randomness,\n                pending.note_type_id,\n                complete_packed_note,\n            );\n\n            // Content delivered over an unconstrained channel need not correspond to a real note, so discovery can\n            // come up empty.\n            if discovered_notes.len() == 0 {\n                aztecnr_warn_log_format!(\n                    \"Partial note with tag {0} completed with no matching note discovered, ignoring\",\n                )(\n                    [pending.note_completion_log_tag],\n                );\n            } else {\n                aztecnr_debug_log_format!(\"Discovered {0} notes for partial note with tag {1}\")(\n                    [discovered_notes.len() as Field, pending.note_completion_log_tag],\n                );\n            }\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    self.collection.contract_address,\n                    pending.owner,\n                    storage_slot,\n                    pending.randomness,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                );\n            });\n        }\n\n        self.mark_completed(BlockReference { block_number: log.block_number, block_hash: log.block_hash });\n    }\n}\n\n/// Serializes a [`DeliveredPendingPartialNote`] into a fact payload.\nunconstrained fn to_payload(pending: DeliveredPendingPartialNote) -> EphemeralArray<Field> {\n    EphemeralArray::from_array(pending.serialize())\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::logs::note::MAX_NOTE_PACKED_LEN;\n    use crate::messages::logs::partial_note::MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN;\n    use crate::messages::processing::{\n        get_enqueued_note_validation_requests, log_retrieval_response::LogRetrievalResponse,\n    };\n    use crate::oracle::block_reference::BlockReference;\n    use crate::partial_notes::DeliveredPendingPartialNote;\n    use crate::protocol::address::AztecAddress;\n    use crate::protocol::hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::PartialNoteFsm;\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// A delivered partial note with simple dummy content.\n    unconstrained fn make_pending(owner: AztecAddress) -> DeliveredPendingPartialNote {\n        DeliveredPendingPartialNote {\n            owner,\n            randomness: 0x11,\n            note_completion_log_tag: 0x22,\n            note_type_id: 0x33,\n            packed_private_note_content: BoundedVec::new(),\n        }\n    }\n\n    /// A low block, which TXE (proven == finalized == latest) reports as finalized.\n    fn finalized_block() -> BlockReference {\n        BlockReference { block_number: 1, block_hash: 0 }\n    }\n\n    #[test]\n    unconstrained fn init_creates_a_partial_note_fsm_in_pending_state() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_pending(), \"freshly delivered reception should be pending\");\n            assert(all.get(0).completion_log_origin().is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn read_pending_round_trips_the_delivered_content() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            let pending = PartialNoteFsm::load_all(address, scope).get(0).read_pending_partial_note();\n            assert_eq(pending.owner, scope);\n            assert_eq(pending.randomness, 0x11);\n            assert_eq(pending.note_completion_log_tag, 0x22);\n            assert_eq(pending.note_type_id, 0x33);\n        });\n    }\n\n    #[test]\n    unconstrained fn mark_completed_moves_to_completed() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(finalized_block());\n\n            let reloaded = PartialNoteFsm::load_all(address, scope).get(0);\n            assert(reloaded.is_completed(), \"should be completed after mark_completed\");\n            assert(reloaded.completion_log_origin().unwrap().block_state.is_finalized());\n        });\n    }\n\n    #[test]\n    unconstrained fn terminate_deletes_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            PartialNoteFsm::load_all(address, scope).get(0).terminate();\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn re_init_is_idempotent() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_leaves_a_pending_reception_untouched_when_it_has_no_completion_log() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // Neither an empty fetched-logs set (`Some(empty)`, the pass-1 \"searched, found nothing\" case) nor no\n            // fetch at all (`None`, the pass-2 case) can complete a pending reception, so it stays pending.\n            let no_logs: EphemeralArray<LogRetrievalResponse> = EphemeralArray::empty();\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::some(no_logs),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_pending(), \"reception without a completion log should stay pending\");\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_advances_a_pending_reception_whose_log_yields_no_notes() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // A malicious sender can deliver a partial note whose private content does not match the completion log it\n            // points at: the note hash computes but is absent from the log's transaction, so nonce discovery yields no\n            // note.\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                completion_log_with_unrelated_note_hashes(),\n                |_, _, _, _, _, _| Option::some(DISCOVERED_NOTE_HASH),\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_advances_when_combined_content_exceeds_note_packed_len() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n\n            // A poisoned delivery can carry a private half as long as MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN, which equals\n            // the packed-note capacity. Combined with any completion log's public content it exceeds that capacity, so\n            // completing must advance the reception rather than overflow the packed-note append and panic.\n            let pending = DeliveredPendingPartialNote {\n                owner: scope,\n                randomness: 0x11,\n                note_completion_log_tag: 0x22,\n                note_type_id: 0x33,\n                packed_private_note_content: BoundedVec::from_array([0; MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN]),\n            };\n            PartialNoteFsm::init(address, scope, pending, finalized_block());\n\n            // A completion log carrying one public field (storage slot followed by one value).\n            let mut log = completion_log_with_unrelated_note_hashes();\n            log.log_payload = BoundedVec::from_array([0, 0]);\n\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                log,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_advances_when_the_log_payload_is_empty() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // An attacker can emit a tag-only public log, which arrives with an empty payload (no storage slot).\n            // Completing must advance the reception rather than read the storage slot out of bounds and panic.\n            let mut log = completion_log_with_unrelated_note_hashes();\n            log.log_payload = BoundedVec::new();\n\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                log,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_discovers_a_note_whose_combined_content_fills_note_packed_len() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n\n            // A private half one field short of the cap plus a single public field combines to exactly\n            // MAX_NOTE_PACKED_LEN, the largest a valid note can be. The guard rejects only content that *exceeds* the\n            // cap, so this boundary case must still go through discovery and not be dropped.\n            let mut packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN> =\n                BoundedVec::new();\n            for _ in 0..MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN - 1 {\n                packed_private_note_content.push(0);\n            }\n            let pending = DeliveredPendingPartialNote {\n                owner: scope,\n                randomness: 0x11,\n                note_completion_log_tag: 0x22,\n                note_type_id: 0x33,\n                packed_private_note_content,\n            };\n            PartialNoteFsm::init(address, scope, pending, finalized_block());\n\n            // A matching completion log carrying one public field (storage slot followed by one value).\n            let mut log = matching_completion_log(address, COMPLETION_LOG_FIRST_NULLIFIER);\n            log.log_payload = BoundedVec::from_array([0, 0]);\n\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                log,\n                |_, _, _, _, _, _| Option::some(DISCOVERED_NOTE_HASH),\n                |_, _, _, _, _, _, _| Option::some(DISCOVERED_NOTE_NULLIFIER),\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_completes_once_when_multiple_completion_logs_are_found() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // A single pending partial note can resolve to more than one completion log (e.g. the same partial note\n            // completed twice). Both logs here would independently discover a note, but step must complete only once\n            // (enqueuing exactly one note) rather than panic, so this cannot break sync.\n            let completion_logs: EphemeralArray<LogRetrievalResponse> = EphemeralArray::from_array([\n                matching_completion_log(address, COMPLETION_LOG_FIRST_NULLIFIER),\n                matching_completion_log(address, SECOND_COMPLETION_LOG_FIRST_NULLIFIER),\n            ]);\n\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::some(completion_logs),\n                |_, _, _, _, _, _| Option::some(DISCOVERED_NOTE_HASH),\n                |_, _, _, _, _, _, _| Option::some(DISCOVERED_NOTE_NULLIFIER),\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_terminates_a_completed_reception_once_its_block_is_finalized() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(finalized_block());\n\n            // Completed with a finalized completion block: the discovered note is reorg-proof, so step terminates the\n            // FSM by deleting its collection.\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_keeps_a_completed_reception_while_its_block_is_unfinalized() {\n        let (env, scope) = setup();\n        // A future block never finalizes here, so the completed reception must survive the step.\n        let unfinalized_block = BlockReference { block_number: env.last_block_number() + 100, block_hash: 0 };\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(unfinalized_block);\n\n            // Completed but not yet finalized: step must not terminate it, since a reorg could still fold it back.\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed(), \"unfinalized completed reception should survive step\");\n        });\n    }\n\n    global COMPLETION_LOG_FIRST_NULLIFIER: Field = 0x47;\n    global SECOND_COMPLETION_LOG_FIRST_NULLIFIER: Field = 0x48;\n    global DISCOVERED_NOTE_HASH: Field = 0x99;\n    global DISCOVERED_NOTE_NULLIFIER: Field = 0x55;\n\n    /// The number of notes `complete_with_log` has enqueued for validation in the current context.\n    unconstrained fn enqueued_note_count() -> u32 {\n        get_enqueued_note_validation_requests().len()\n    }\n\n    /// A completion log whose transaction contains the unique note hash that `DISCOVERED_NOTE_HASH` resolves to for the\n    /// given `first_nullifier_in_tx`, so nonce discovery finds a note in it. Paired with compute functions that return\n    /// `DISCOVERED_NOTE_HASH`.\n    unconstrained fn matching_completion_log(\n        contract_address: AztecAddress,\n        first_nullifier_in_tx: Field,\n    ) -> LogRetrievalResponse {\n        let note_nonce = compute_note_hash_nonce(first_nullifier_in_tx, 0);\n        let unique_note_hash = compute_unique_note_hash(\n            note_nonce,\n            compute_siloed_note_hash(contract_address, DISCOVERED_NOTE_HASH),\n        );\n        LogRetrievalResponse {\n            log_payload: BoundedVec::from_array([0]),\n            tx_hash: 0,\n            unique_note_hashes_in_tx: BoundedVec::from_array([unique_note_hash]),\n            first_nullifier_in_tx,\n            block_number: 1,\n            block_timestamp: 0,\n            block_hash: 0,\n        }\n    }\n\n    /// A well-formed completion log tied to a block TXE reports as finalized, carrying the note hashes of some\n    /// unrelated transaction. A note whose hash is not among them discovers to nothing, standing in for the real log a\n    /// poisoned partial note's tag resolves to.\n    unconstrained fn completion_log_with_unrelated_note_hashes() -> LogRetrievalResponse {\n        LogRetrievalResponse {\n            log_payload: BoundedVec::from_array([0]),\n            tx_hash: 0,\n            unique_note_hashes_in_tx: BoundedVec::from_array([0x1234]),\n            first_nullifier_in_tx: COMPLETION_LOG_FIRST_NULLIFIER,\n            block_number: 1,\n            block_timestamp: 0,\n            block_hash: 0,\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"
+      "source": "//! The finite state machine to process a single partial note.\n//!\n//! A partial note arrives in two parts: a private part (delivered first, carrying the owner, randomness, completion-log\n//! tag, note type, and packed private content) and a public *completion log* (storage slot + packed public content).\n//! The note can only be discovered and stored once both are combined. The state chart below summarizes how a single\n//! partial note's process unfolds, including how reorgs cause it to rewind.\n//!\n//! ```text\n//!                   init() (partial note delivery message, including tx and block data)\n//!                         |\n//!                         v\n//!                     +-----------+    completion log found         +-----------+\n//!                ---- |           | ------------------------------> |           |\n//!  log not found |    |           |                                 |           |     discover note(s),\n//!                |--> |  PENDING  |                                 | COMPLETED | ~~> enqueue for storage, etc\n//!                     |           | <------------------------------ |           |\n//!                     |           |  completion log block re-orged  |           |\n//!                     +-----------+                                 +-----------+\n//!                         |                                               |\n//!                         |  delivery message block re-orged              |  completion log block finalized\n//!                         v                                               v\n//!                   +---------------------------------------------------------+\n//!                   |               TERMINATED (process ends)                 |\n//!                   +---------------------------------------------------------+\n//! ```\n//!\n//! ## States\n//!\n//! - **Pending**: the private part has been received but the completion log has not been found yet. While in this\n//!   state, message discovery keeps searching for that log on each sync.\n//! - **Completed**: the completion log was found, so the note was completed and enqueued for storage. Because the\n//!   block containing the completion log can be dropped by a reorg, this state is not terminal until the block\n//!   finalizes: a reorg dropping it rewinds the FSM back to `Pending` state.\n//! - **Terminated**: nothing else can be done with the partial note, either because its delivery block was re-orged\n//!   away (so the delivery itself was reverted) or because its completion block has finalized (so the discovered note\n//!   is permanent and reorg-proof). This is the terminal state of this FSM.\n//!\n//! ## Transitions (each evaluated by [`step`](PartialNoteFsm::step))\n//!\n//! - **Pending -> Completed** ([`complete_with_log`](PartialNoteFsm::complete_with_log)): the completion log is\n//!   found. Its public content is combined with the delivered private content, the resulting note(s) are discovered\n//!   and enqueued for storage.\n//! - **Completed -> Pending**: the completion log block is re-orged out. The completion log is searched for again.\n//! - **Pending -> Terminated**: the delivery block is re-orged out, retracting the `delivered` birth fact. The\n//!   delivery was reverted, so there is nothing left to do.\n//! - **Completed -> Terminated**: the completion log block finalizes, making the discovered note reorg-proof, so the\n//!   reception is complete and its collection is deleted.\n//!\n//! ## Implementation\n//!\n//! Each pending partial note is tracked as a [fact collection](crate::facts::FactCollection) of type\n//! `PARTIAL_NOTE_RECEPTION_TYPE_ID`, identified by a hash of its [`DeliveredPendingPartialNote`] content (so\n//! re-delivery of the same partial note is idempotent). The collection holds:\n//!\n//! - a retractable `PARTIAL_NOTE_DELIVERED` birth fact tied to a delivery block (so a reorg of that block auto-prunes\n//!   the pending note), whose payload is the serialized [`DeliveredPendingPartialNote`];\n//! - once the completion log is found, a retractable `PARTIAL_NOTE_COMPLETED` fact tied to the completion log block.\n//!\n//! Status folds from the canonical fact set:\n//!     - `delivered` only ⇒ Pending\n//!     - `delivered` + `completed` ⇒ Completed\n//!\n//! A reorg retracting either fact folds the reception back accordingly.\nuse crate::ephemeral::EphemeralArray;\nuse crate::facts::{\n    delete_fact_collection, Fact, FactCollection, FactScope, get_fact_collections_by_type, record_retractable_fact,\n    RetractableFactOrigin,\n};\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::messages::{\n    discovery::{ComputeNoteHash, ComputeNoteNullifier, nonce_discovery::attempt_note_nonce_discovery},\n    logs::note::MAX_NOTE_PACKED_LEN,\n    processing::{enqueue_note_for_validation, log_retrieval_response::{LogRetrievalResponse, MAX_LOG_CONTENT_LEN}},\n};\nuse crate::oracle::block_reference::BlockReference;\nuse crate::protocol::{address::AztecAddress, hash::{poseidon2_hash, sha256_to_field}, traits::{Deserialize, Serialize}};\nuse crate::utils::array;\nuse super::DeliveredPendingPartialNote;\n\n/// Fact-collection type id shared by every partial-note reception in the [fact store](crate::facts).\nglobal PARTIAL_NOTE_RECEPTION_TYPE_ID: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_RECEPTION_TYPE_ID\".as_bytes());\n\n/// Fact type id of the birth fact carrying the delivered private partial note.\nglobal PARTIAL_NOTE_DELIVERED: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_DELIVERED\".as_bytes());\n\n/// Fact type id marking a partial note as completed (its note has been discovered and enqueued).\nglobal PARTIAL_NOTE_COMPLETED: Field = sha256_to_field(\"AZTEC_NR::PARTIAL_NOTE_COMPLETED\".as_bytes());\n\n/// A single partial note's finite state machine, backed by a [`FactCollection`](crate::facts::FactCollection).\n#[derive(Deserialize, Serialize)]\npub(crate) struct PartialNoteFsm {\n    collection: FactCollection,\n}\n\nimpl PartialNoteFsm {\n    /// Initializes an FSM for a freshly discovered partial note.\n    ///\n    /// The FSM existence is tied to `origin_block`: if `origin_block` is dropped by a reorg, the FSM is transparently\n    /// deleted.\n    pub(crate) unconstrained fn init(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n        pending: DeliveredPendingPartialNote,\n        origin_block: BlockReference,\n    ) {\n        record_retractable_fact(\n            contract_address,\n            FactScope::account(scope),\n            PARTIAL_NOTE_RECEPTION_TYPE_ID,\n            Self::id_for(pending),\n            PARTIAL_NOTE_DELIVERED,\n            to_payload(pending),\n            origin_block,\n        );\n    }\n\n    /// Loads every active partial-note FSM for the given contract and scope.\n    pub(crate) unconstrained fn load_all(\n        contract_address: AztecAddress,\n        scope: AztecAddress,\n    ) -> EphemeralArray<PartialNoteFsm> {\n        get_fact_collections_by_type(\n            contract_address,\n            FactScope::account(scope),\n            PARTIAL_NOTE_RECEPTION_TYPE_ID,\n        )\n            .map(|collection: FactCollection| PartialNoteFsm { collection })\n    }\n\n    /// The fact-collection id identifying a specific partial note.\n    fn id_for(pending: DeliveredPendingPartialNote) -> Field {\n        poseidon2_hash(pending.serialize())\n    }\n\n    /// Reads and decodes the delivered partial note this FSM processes.\n    pub(crate) unconstrained fn read_pending_partial_note(self) -> DeliveredPendingPartialNote {\n        let delivered = self.collection.facts.find(|f: Fact| f.fact_type_id == PARTIAL_NOTE_DELIVERED).unwrap();\n        let mut fields = [0; <DeliveredPendingPartialNote as Deserialize>::N];\n        for i in 0..fields.len() {\n            fields[i] = delivered.payload.get(i);\n        }\n        Deserialize::deserialize(fields)\n    }\n\n    /// Whether the partial note FSM is in `completed` state, i.e. its note was completed and stored.\n    unconstrained fn is_completed(self) -> bool {\n        self.collection.facts.any(|f: Fact| f.fact_type_id == PARTIAL_NOTE_COMPLETED)\n    }\n\n    /// Whether the partial note FSM is in `pending` state, i.e. it hasn't been completed yet.\n    pub(crate) unconstrained fn is_pending(self) -> bool {\n        !self.is_completed()\n    }\n\n    /// Origin block of the partial note completion log, if available.\n    unconstrained fn completion_log_origin(self) -> Option<RetractableFactOrigin> {\n        let maybe_completed = self.collection.facts.find(|f: Fact| f.fact_type_id == PARTIAL_NOTE_COMPLETED);\n        if maybe_completed.is_some() {\n            maybe_completed.unwrap().origin_block\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Transition the partial note FSM as `completed`, conditional to `origin_block`.\n    unconstrained fn mark_completed(self, origin_block: BlockReference) {\n        let empty_payload: EphemeralArray<Field> = EphemeralArray::empty();\n        record_retractable_fact(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n            PARTIAL_NOTE_COMPLETED,\n            empty_payload,\n            origin_block,\n        );\n    }\n\n    /// Terminates this partial note FSM.\n    unconstrained fn terminate(self) {\n        delete_fact_collection(\n            self.collection.contract_address,\n            self.collection.scope,\n            self.collection.fact_collection_type_id,\n            self.collection.fact_collection_id,\n        );\n    }\n\n    /// Advances this partial-note FSM by one step.\n    ///\n    /// Partial notes can only be completed if completion logs have been found for them. Log discovery and\n    /// provisioning is responsibility of the caller.\n    ///\n    /// `compute_note_hash` and `compute_note_nullifier` are injected dependencies.\n    pub(crate) unconstrained fn step(\n        self,\n        maybe_completion_logs: Option<EphemeralArray<LogRetrievalResponse>>,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        if self.is_pending() {\n            self.step_pending(maybe_completion_logs, compute_note_hash, compute_note_nullifier);\n        } else {\n            self.step_completed();\n        }\n    }\n\n    /// Processes a partial note in pending state\n    ///\n    /// Completes the partial note if its completion log is given. If not, the partial note remains in pending state\n    /// and its completion log is searched for again on future syncs.\n    unconstrained fn step_pending(\n        self,\n        maybe_completion_logs: Option<EphemeralArray<LogRetrievalResponse>>,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        if maybe_completion_logs.is_some() {\n            let completion_logs = maybe_completion_logs.unwrap();\n            let num_logs = completion_logs.len();\n            if num_logs != 0 {\n                // The tag is not unique, so a pending partial note can resolve to more than one completion log (e.g.\n                // the same partial note completed twice). We complete with the first and ignore the rest rather than\n                // fail.\n                if num_logs > 1 {\n                    let tag = self.read_pending_partial_note().note_completion_log_tag;\n                    aztecnr_warn_log_format!(\n                        \"Found {0} completion logs for partial note with tag {1}, completing with the first\",\n                    )(\n                        [num_logs as Field, tag],\n                    );\n                }\n                self.complete_with_log(completion_logs.get(0), compute_note_hash, compute_note_nullifier);\n            }\n        }\n    }\n\n    /// Advances partial note in `completed` state: terminates it once the completion log block finalizes, since the\n    /// discovered note is then permanent and there is nothing left to track.\n    unconstrained fn step_completed(self) {\n        if self.completion_log_origin().unwrap().block_state.is_finalized() {\n            self.terminate();\n        }\n    }\n\n    /// Completes a partial note.\n    ///\n    /// Combines the delivered private content with the log's public content, discovers the resulting note(s), enqueues\n    /// them for validation, and transitions the FSM to `completed` state conditional to the completion log's block.\n    ///\n    /// A completion log that cannot yield a note (an empty payload, content too large to pack into a note, or one\n    /// matching no real note) is skipped without failing and the FSM still advances, so one bad message cannot break\n    /// sync.\n    ///\n    /// Because the completion fact is retractable, a reorg of the completion log's block rewinds the FSM back to\n    /// `pending` state (which signals that completion log search should restart).\n    unconstrained fn complete_with_log(\n        self,\n        log: LogRetrievalResponse,\n        compute_note_hash: ComputeNoteHash,\n        compute_note_nullifier: ComputeNoteNullifier,\n    ) {\n        let pending = self.read_pending_partial_note();\n\n        // The completion log payload is the storage slot followed by the public note content, so an empty payload\n        // (e.g. an attacker's tag-only log) has no storage slot and no content.\n        let payload_len = log.log_payload.len();\n        let public_content_len = if payload_len == 0 { 0 } else { payload_len - 1 };\n\n        let combined_len = pending.packed_private_note_content.len() + public_content_len;\n\n        if payload_len == 0 {\n            aztecnr_warn_log_format!(\n                \"Partial note with tag {0} has an empty completion log, ignoring\",\n            )(\n                [pending.note_completion_log_tag],\n            );\n        } else if combined_len > MAX_NOTE_PACKED_LEN {\n            // A valid note packs into at most MAX_NOTE_PACKED_LEN fields, so this content cannot form one and would\n            // overflow the append below.\n            aztecnr_warn_log_format!(\n                \"Partial note with tag {0} has over-length content ({1} > {2} fields), ignoring\",\n            )(\n                [pending.note_completion_log_tag, combined_len as Field, MAX_NOTE_PACKED_LEN as Field],\n            );\n        } else {\n            let storage_slot = log.log_payload.get(0);\n            let public_note_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN - 1> = array::subbvec(log.log_payload, 1);\n\n            // Public fields are placed at the end of the packed representation, so we combine the private and public\n            // packed content to get the complete packed note.\n            let complete_packed_note = array::append(pending.packed_private_note_content, public_note_content);\n\n            let discovered_notes = attempt_note_nonce_discovery(\n                log.unique_note_hashes_in_tx,\n                log.first_nullifier_in_tx,\n                compute_note_hash,\n                compute_note_nullifier,\n                self.collection.contract_address,\n                pending.owner,\n                storage_slot,\n                pending.randomness,\n                pending.note_type_id,\n                complete_packed_note,\n            );\n\n            // Content delivered over an unconstrained channel need not correspond to a real note, so discovery can\n            // come up empty.\n            if discovered_notes.len() == 0 {\n                aztecnr_warn_log_format!(\n                    \"Partial note with tag {0} completed with no matching note discovered, ignoring\",\n                )(\n                    [pending.note_completion_log_tag],\n                );\n            } else {\n                aztecnr_debug_log_format!(\"Discovered {0} notes for partial note with tag {1}\")(\n                    [discovered_notes.len() as Field, pending.note_completion_log_tag],\n                );\n            }\n\n            discovered_notes.for_each(|discovered_note| {\n                enqueue_note_for_validation(\n                    self.collection.contract_address,\n                    pending.owner,\n                    storage_slot,\n                    pending.randomness,\n                    discovered_note.note_nonce,\n                    complete_packed_note,\n                    discovered_note.note_hash,\n                    discovered_note.inner_nullifier,\n                    log.tx_hash,\n                );\n            });\n        }\n\n        self.mark_completed(BlockReference { block_number: log.block_number, block_hash: log.block_hash });\n    }\n}\n\n/// Serializes a [`DeliveredPendingPartialNote`] into a fact payload.\nunconstrained fn to_payload(pending: DeliveredPendingPartialNote) -> EphemeralArray<Field> {\n    EphemeralArray::from_array(pending.serialize())\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::messages::logs::note::MAX_NOTE_PACKED_LEN;\n    use crate::messages::logs::partial_note::MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN;\n    use crate::messages::processing::{\n        get_enqueued_note_validation_requests, log_retrieval_response::LogRetrievalResponse,\n    };\n    use crate::oracle::block_reference::BlockReference;\n    use crate::partial_notes::DeliveredPendingPartialNote;\n    use crate::protocol::address::AztecAddress;\n    use crate::protocol::hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash};\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::PartialNoteFsm;\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    /// A delivered partial note with simple dummy content.\n    unconstrained fn make_pending(owner: AztecAddress) -> DeliveredPendingPartialNote {\n        DeliveredPendingPartialNote {\n            owner,\n            randomness: 0x11,\n            note_completion_log_tag: 0x22,\n            note_type_id: 0x33,\n            packed_private_note_content: BoundedVec::new(),\n        }\n    }\n\n    /// A low block, which TXE (proven == finalized == latest) reports as finalized.\n    fn finalized_block() -> BlockReference {\n        BlockReference { block_number: 1, block_hash: 0 }\n    }\n\n    #[test]\n    unconstrained fn init_creates_a_partial_note_fsm_in_pending_state() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_pending(), \"freshly delivered reception should be pending\");\n            assert(all.get(0).completion_log_origin().is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn read_pending_round_trips_the_delivered_content() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            let pending = PartialNoteFsm::load_all(address, scope).get(0).read_pending_partial_note();\n            assert_eq(pending.owner, scope);\n            assert_eq(pending.randomness, 0x11);\n            assert_eq(pending.note_completion_log_tag, 0x22);\n            assert_eq(pending.note_type_id, 0x33);\n        });\n    }\n\n    #[test]\n    unconstrained fn mark_completed_moves_to_completed() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(finalized_block());\n\n            let reloaded = PartialNoteFsm::load_all(address, scope).get(0);\n            assert(reloaded.is_completed(), \"should be completed after mark_completed\");\n            assert(reloaded.completion_log_origin().unwrap().block_state.is_finalized());\n        });\n    }\n\n    #[test]\n    unconstrained fn terminate_deletes_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            PartialNoteFsm::load_all(address, scope).get(0).terminate();\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn re_init_is_idempotent() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_leaves_a_pending_reception_untouched_when_it_has_no_completion_log() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // Neither an empty fetched-logs set (`Some(empty)`, the pass-1 \"searched, found nothing\" case) nor no\n            // fetch at all (`None`, the pass-2 case) can complete a pending reception, so it stays pending.\n            let no_logs: EphemeralArray<LogRetrievalResponse> = EphemeralArray::empty();\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::some(no_logs),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_pending(), \"reception without a completion log should stay pending\");\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_advances_a_pending_reception_whose_log_yields_no_notes() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // A malicious sender can deliver a partial note whose private content does not match the completion log it\n            // points at: the note hash computes but is absent from the log's transaction, so nonce discovery yields no\n            // note.\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                completion_log_with_unrelated_note_hashes(),\n                |_, _, _, _, _, _| Option::some(DISCOVERED_NOTE_HASH),\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_advances_when_combined_content_exceeds_note_packed_len() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n\n            // A poisoned delivery can carry a private half as long as MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN, which equals\n            // the packed-note capacity. Combined with any completion log's public content it exceeds that capacity, so\n            // completing must advance the reception rather than overflow the packed-note append and panic.\n            let pending = DeliveredPendingPartialNote {\n                owner: scope,\n                randomness: 0x11,\n                note_completion_log_tag: 0x22,\n                note_type_id: 0x33,\n                packed_private_note_content: BoundedVec::from_array([0; MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN]),\n            };\n            PartialNoteFsm::init(address, scope, pending, finalized_block());\n\n            // A completion log carrying one public field (storage slot followed by one value).\n            let mut log = completion_log_with_unrelated_note_hashes();\n            log.log_payload = BoundedVec::from_array([0, 0]);\n\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                log,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_advances_when_the_log_payload_is_empty() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // An attacker can emit a tag-only public log, which arrives with an empty payload (no storage slot).\n            // Completing must advance the reception rather than read the storage slot out of bounds and panic.\n            let mut log = completion_log_with_unrelated_note_hashes();\n            log.log_payload = BoundedVec::new();\n\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                log,\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn complete_with_log_discovers_a_note_whose_combined_content_fills_note_packed_len() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n\n            // A private half one field short of the cap plus a single public field combines to exactly\n            // MAX_NOTE_PACKED_LEN, the largest a valid note can be. The guard rejects only content that *exceeds* the\n            // cap, so this boundary case must still go through discovery and not be dropped.\n            let mut packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN> =\n                BoundedVec::new();\n            for _ in 0..MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN - 1 {\n                packed_private_note_content.push(0);\n            }\n            let pending = DeliveredPendingPartialNote {\n                owner: scope,\n                randomness: 0x11,\n                note_completion_log_tag: 0x22,\n                note_type_id: 0x33,\n                packed_private_note_content,\n            };\n            PartialNoteFsm::init(address, scope, pending, finalized_block());\n\n            // A matching completion log carrying one public field (storage slot followed by one value).\n            let mut log = matching_completion_log(address, COMPLETION_LOG_FIRST_NULLIFIER);\n            log.log_payload = BoundedVec::from_array([0, 0]);\n\n            PartialNoteFsm::load_all(address, scope).get(0).complete_with_log(\n                log,\n                |_, _, _, _, _, _| Option::some(DISCOVERED_NOTE_HASH),\n                |_, _, _, _, _, _, _| Option::some(DISCOVERED_NOTE_NULLIFIER),\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_completes_once_when_multiple_completion_logs_are_found() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n\n            // A single pending partial note can resolve to more than one completion log (e.g. the same partial note\n            // completed twice). Both logs here would independently discover a note, but step must complete only once\n            // (enqueuing exactly one note) rather than panic, so this cannot break sync.\n            let completion_logs: EphemeralArray<LogRetrievalResponse> = EphemeralArray::from_array([\n                matching_completion_log(address, COMPLETION_LOG_FIRST_NULLIFIER),\n                matching_completion_log(address, SECOND_COMPLETION_LOG_FIRST_NULLIFIER),\n            ]);\n\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::some(completion_logs),\n                |_, _, _, _, _, _| Option::some(DISCOVERED_NOTE_HASH),\n                |_, _, _, _, _, _, _| Option::some(DISCOVERED_NOTE_NULLIFIER),\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed());\n            assert_eq(enqueued_note_count(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_terminates_a_completed_reception_once_its_block_is_finalized() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(finalized_block());\n\n            // Completed with a finalized completion block: the discovered note is reorg-proof, so step terminates the\n            // FSM by deleting its collection.\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            assert_eq(PartialNoteFsm::load_all(address, scope).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn step_keeps_a_completed_reception_while_its_block_is_unfinalized() {\n        let (env, scope) = setup();\n        // A future block never finalizes here, so the completed reception must survive the step.\n        let unfinalized_block = BlockReference { block_number: env.last_block_number() + 100, block_hash: 0 };\n        env.private_context(|context| {\n            let address = context.this_address();\n            PartialNoteFsm::init(address, scope, make_pending(scope), finalized_block());\n            PartialNoteFsm::load_all(address, scope).get(0).mark_completed(unfinalized_block);\n\n            // Completed but not yet finalized: step must not terminate it, since a reorg could still fold it back.\n            PartialNoteFsm::load_all(address, scope).get(0).step(\n                Option::none(),\n                dummy_compute_note_hash,\n                dummy_compute_note_nullifier,\n            );\n\n            let all = PartialNoteFsm::load_all(address, scope);\n            assert_eq(all.len(), 1);\n            assert(all.get(0).is_completed(), \"unfinalized completed reception should survive step\");\n        });\n    }\n\n    global COMPLETION_LOG_FIRST_NULLIFIER: Field = 0x47;\n    global SECOND_COMPLETION_LOG_FIRST_NULLIFIER: Field = 0x48;\n    global DISCOVERED_NOTE_HASH: Field = 0x99;\n    global DISCOVERED_NOTE_NULLIFIER: Field = 0x55;\n\n    /// The number of notes `complete_with_log` has enqueued for validation in the current context.\n    unconstrained fn enqueued_note_count() -> u32 {\n        get_enqueued_note_validation_requests().len()\n    }\n\n    /// A completion log whose transaction contains the unique note hash that `DISCOVERED_NOTE_HASH` resolves to for the\n    /// given `first_nullifier_in_tx`, so nonce discovery finds a note in it. Paired with compute functions that return\n    /// `DISCOVERED_NOTE_HASH`.\n    unconstrained fn matching_completion_log(\n        contract_address: AztecAddress,\n        first_nullifier_in_tx: Field,\n    ) -> LogRetrievalResponse {\n        let note_nonce = compute_note_hash_nonce(first_nullifier_in_tx, 0);\n        let unique_note_hash = compute_unique_note_hash(\n            note_nonce,\n            compute_siloed_note_hash(contract_address, DISCOVERED_NOTE_HASH),\n        );\n        LogRetrievalResponse {\n            log_payload: BoundedVec::from_array([0]),\n            tx_hash: 0,\n            unique_note_hashes_in_tx: BoundedVec::from_array([unique_note_hash]),\n            first_nullifier_in_tx,\n            block_number: 1,\n            block_timestamp: 0,\n            block_hash: 0,\n        }\n    }\n\n    /// A well-formed completion log tied to a block TXE reports as finalized, carrying the note hashes of some\n    /// unrelated transaction. A note whose hash is not among them discovers to nothing, standing in for the real log a\n    /// poisoned partial note's tag resolves to.\n    unconstrained fn completion_log_with_unrelated_note_hashes() -> LogRetrievalResponse {\n        LogRetrievalResponse {\n            log_payload: BoundedVec::from_array([0]),\n            tx_hash: 0,\n            unique_note_hashes_in_tx: BoundedVec::from_array([0x1234]),\n            first_nullifier_in_tx: COMPLETION_LOG_FIRST_NULLIFIER,\n            block_number: 1,\n            block_timestamp: 0,\n            block_hash: 0,\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"
     },
-    "224": {
+    "225": {
       "function_locations": [
         {
           "name": "process_partial_note_private_msg",
@@ -2148,7 +2148,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/partial_notes/mod.nr",
       "source": "mod fsm;\n\nuse crate::{\n    messages::{\n        discovery::{ComputeNoteHash, ComputeNoteNullifier},\n        encoding::MAX_MESSAGE_CONTENT_LEN,\n        logs::partial_note::{decode_partial_note_private_message, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN},\n        processing::{get_pending_partial_notes_completion_logs, ResolvedTx},\n    },\n    oracle::block_reference::BlockReference,\n};\n\nuse crate::logging::{aztecnr_debug_log_format, aztecnr_warn_log_format};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\nuse fsm::PartialNoteFsm;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n    pub(crate) owner: AztecAddress,\n    pub(crate) randomness: Field,\n    pub(crate) note_completion_log_tag: Field,\n    pub(crate) note_type_id: Field,\n    pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n}\n\npub(crate) unconstrained fn process_partial_note_private_msg(\n    contract_address: AztecAddress,\n    msg_metadata: u64,\n    msg_content: BoundedVec<Field, MAX_MESSAGE_CONTENT_LEN>,\n    resolved_tx: ResolvedTx,\n    recipient: AztecAddress,\n) {\n    let decoded = decode_partial_note_private_message(msg_metadata, msg_content);\n\n    if decoded.is_some() {\n        let (owner, randomness, note_completion_log_tag, note_type_id, packed_private_note_content) = decoded.unwrap();\n\n        PartialNoteFsm::init(\n            contract_address,\n            recipient,\n            DeliveredPendingPartialNote {\n                owner,\n                randomness,\n                note_completion_log_tag,\n                note_type_id,\n                packed_private_note_content,\n            },\n            BlockReference { block_number: resolved_tx.block_number, block_hash: resolved_tx.block_hash },\n        );\n    } else {\n        aztecnr_warn_log_format!(\n            \"Could not decode partial note private message from tx {0}, ignoring\",\n        )(\n            [resolved_tx.tx_hash],\n        );\n    }\n}\n\n/// Drives every active partial-note FSM forward.\npub(crate) unconstrained fn sync(\n    contract_address: AztecAddress,\n    compute_note_hash: ComputeNoteHash,\n    compute_note_nullifier: ComputeNoteNullifier,\n    scope: AztecAddress,\n) {\n    // `load_all` is a relatively expensive oracle round-trip, so we call it once and reuse the result.\n    let active_partial_note_fsms = PartialNoteFsm::load_all(contract_address, scope);\n\n    // Fetching completion logs is the dominant cost of partial note contract sync (a node round-trip each) and only\n    // pending notes need them, so we batch that fetch for the pending subset and then drive the FSMs in two passes:\n    //  1. Step each pending FSM with its freshly-fetched completion logs, giving found logs a chance to complete notes.\n    //  2. Step every active FSM with no logs, which is where completed-and-finalized FSMs terminate.\n    // Keeping both the completion and termination logic inside `PartialNoteFsm::step` is what lets the orchestrator\n    // stay this small, the price is the somewhat less elegant two-pass shape that the batched fetch forces on us.\n    let pending_partial_note_fsms = active_partial_note_fsms.filter(|fsm: PartialNoteFsm| fsm.is_pending());\n    let pending_partial_notes = pending_partial_note_fsms.map(|fsm: PartialNoteFsm| fsm.read_pending_partial_note());\n\n    aztecnr_debug_log_format!(\"{} pending partial notes\")([pending_partial_notes.len() as Field]);\n\n    let completion_logs = get_pending_partial_notes_completion_logs(contract_address, pending_partial_notes);\n    assert_eq(completion_logs.len(), pending_partial_notes.len());\n\n    pending_partial_note_fsms.for_each(|i, fsm: PartialNoteFsm| {\n        fsm.step(Option::some(completion_logs.get(i)), compute_note_hash, compute_note_nullifier);\n    });\n\n    active_partial_note_fsms.for_each(|_i, fsm: PartialNoteFsm| {\n        fsm.step(Option::none(), compute_note_hash, compute_note_nullifier);\n    });\n}\n"
     },
-    "278": {
+    "279": {
       "function_locations": [
         {
           "name": "UnconstrainedArray<T, Oracle>::at",
@@ -2222,7 +2222,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/unconstrained_array/mod.nr",
       "source": "pub(crate) mod test_helpers;\npub(crate) mod test_suite;\n\nuse crate::oracle::random::random;\nuse crate::protocol::traits::{Deserialize, Serialize};\n\n/// Oracle backend for an [`UnconstrainedArray`]: the set of PXE-side operations that implement its storage.\n///\n/// Each implementor routes these operations to a distinct family of oracles, and the oracle family determines the\n/// array's lifetime and visibility (e.g. [`EphemeralArray`](crate::ephemeral::EphemeralArray) arrays live for one\n/// contract call frame, while [`TransientArray`](crate::transient::TransientArray) arrays are shared across all frames\n/// of the same contract within one top-level PXE call).\npub(crate) trait ArrayOracles {\n    /// Returns the number of elements in the array at `slot`.\n    unconstrained fn len_oracle(slot: Field) -> u32;\n\n    /// Appends a serialized element to the array at `slot` and returns the new length.\n    unconstrained fn push_oracle<let N: u32>(slot: Field, values: [Field; N]) -> u32;\n\n    /// Removes and returns the last serialized element of the array at `slot`. Implementors must panic if the\n    /// array is empty.\n    unconstrained fn pop_oracle<let N: u32>(slot: Field) -> [Field; N];\n\n    /// Returns the serialized element at the given index of the array at `slot`. Implementors must panic if `index`\n    /// is out of bounds.\n    unconstrained fn get_oracle<let N: u32>(slot: Field, index: u32) -> [Field; N];\n\n    /// Overwrites the serialized element at the given index of the array at `slot`. Implementors must panic if\n    /// `index` is out of bounds.\n    unconstrained fn set_oracle<let N: u32>(slot: Field, index: u32, values: [Field; N]);\n\n    /// Removes the element at the given index of the array at `slot`, shifting subsequent elements backward.\n    /// Implementors must panic if `index` is out of bounds.\n    unconstrained fn remove_oracle(slot: Field, index: u32);\n\n    /// Removes all elements from the array at `slot`.\n    unconstrained fn clear_oracle(slot: Field);\n}\n\n/// A dynamically sized array backed by PXE-side in-memory storage via an [`ArrayOracles`] backend.\n///\n/// Arrays are identified by a slot, and each logical operation (push, pop, get, etc.) is a single oracle call. The\n/// `Oracle` backend determines the array's lifetime and visibility; contracts should not use this type directly but\n/// rather one of its aliases: [`EphemeralArray`](crate::ephemeral::EphemeralArray) (scoped to a single contract call\n/// frame) or [`TransientArray`](crate::transient::TransientArray) (shared across all frames of the same contract\n/// within one top-level PXE call).\npub struct UnconstrainedArray<T, Oracle> {\n    pub(crate) slot: Field,\n}\n\nimpl<T, Oracle> UnconstrainedArray<T, Oracle>\nwhere\n    Oracle: ArrayOracles,\n{\n    /// Returns a handle to the array at the given slot, which may already contain data (e.g. populated by an oracle\n    /// or by an earlier frame, depending on the backend's visibility).\n    pub unconstrained fn at(slot: Field) -> Self {\n        Self { slot }\n    }\n\n    /// Returns an empty array at the given slot, clearing any pre-existing data.\n    ///\n    /// For backends whose arrays are visible beyond a single call frame (e.g. transient arrays), this wipes data\n    /// other frames of the same contract may have written at the slot.\n    pub unconstrained fn empty_at(slot: Field) -> Self {\n        Self::at(slot).clear()\n    }\n\n    /// Returns an empty array at a fresh, randomly allocated slot.\n    ///\n    /// Use this when the caller does not need a specific slot: the random slot is isolated from every other array of\n    /// the same backend with overwhelming probability. Prefer [`UnconstrainedArray::empty_at`] when the slot must be a\n    /// known value (e.g. one shared with an oracle or another call frame).\n    pub unconstrained fn empty() -> Self {\n        Self::at(random())\n    }\n\n    /// Returns an array at a fresh, randomly allocated slot holding `values` in order.\n    pub unconstrained fn from_array<let N: u32>(values: [T; N]) -> Self\n    where\n        T: Serialize,\n    {\n        let array = Self::empty();\n        for i in 0..N {\n            array.push(values[i]);\n        }\n        array\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        Oracle::len_oracle(self.slot)\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push(self, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        let _ = Oracle::push_oracle(self.slot, serialized);\n    }\n\n    /// Removes and returns the last element. Implementors are required to panic if the array is empty.\n    pub unconstrained fn pop(self) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::pop_oracle(self.slot);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Retrieves the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn get(self, index: u32) -> T\n    where\n        T: Deserialize,\n    {\n        let serialized = Oracle::get_oracle(self.slot, index);\n        Deserialize::deserialize(serialized)\n    }\n\n    /// Overwrites the value stored at `index`. Implementors are required to panic if the index is out of bounds.\n    pub unconstrained fn set(self, index: u32, value: T)\n    where\n        T: Serialize,\n    {\n        let serialized = value.serialize();\n        Oracle::set_oracle(self.slot, index, serialized);\n    }\n\n    /// Removes the element at `index`, shifting subsequent elements backward. Implementors are required to panic if\n    /// the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        Oracle::remove_oracle(self.slot, index);\n    }\n\n    /// Removes all elements from the array and returns self for chaining.\n    pub unconstrained fn clear(self) -> Self {\n        Oracle::clear_oracle(self.slot);\n        self\n    }\n\n    /// Calls a function on each element of the array.\n    ///\n    /// The function `f` is called once with each array value and its corresponding index, in order (from the first\n    /// element to the last).\n    ///\n    /// Structurally mutating the array from inside the callback (e.g. via `push`, `pop`, `remove` or `clear`) is\n    /// **not** supported: it can cause elements to be skipped, visited more than once, or read out of bounds.\n    pub unconstrained fn for_each<Env>(self, f: unconstrained fn[Env](u32, T) -> ())\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        for i in 0..n {\n            f(i, self.get(i));\n        }\n    }\n\n    /// Applies `f` to every element and collects the results into a fresh array.\n    pub unconstrained fn map<U, Env>(self, f: unconstrained fn[Env](T) -> U) -> UnconstrainedArray<U, Oracle>\n    where\n        T: Deserialize,\n        U: Serialize,\n    {\n        let dest: UnconstrainedArray<U, Oracle> = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            dest.push(f(self.get(i)));\n        }\n        dest\n    }\n\n    /// Collects every element satisfying the predicate `f` into a fresh array.\n    pub unconstrained fn filter<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Self\n    where\n        T: Serialize + Deserialize,\n    {\n        let dest: Self = UnconstrainedArray::empty();\n        let n = self.len();\n        for i in 0..n {\n            let value = self.get(i);\n            if f(value) {\n                dest.push(value);\n            }\n        }\n        dest\n    }\n\n    /// Returns `true` if at least one element satisfies the predicate `f`.\n    pub unconstrained fn any<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() != 0\n    }\n\n    /// Returns `true` if every element satisfies the predicate `f` (vacuously `true` for an empty array).\n    pub unconstrained fn all<Env>(self, f: unconstrained fn[Env](T) -> bool) -> bool\n    where\n        T: Serialize + Deserialize,\n    {\n        self.filter(f).len() == self.len()\n    }\n\n    /// Returns the first element satisfying the predicate `f`, or `Option::none` if none do.\n    pub unconstrained fn find<Env>(self, f: unconstrained fn[Env](T) -> bool) -> Option<T>\n    where\n        T: Deserialize,\n    {\n        let n = self.len();\n        let mut result: Option<T> = Option::none();\n        let mut i = 0;\n        while (i < n) & result.is_none() {\n            let value = self.get(i);\n            if f(value) {\n                result = Option::some(value);\n            }\n            i += 1;\n        }\n        result\n    }\n}\n"
     },
-    "281": {
+    "282": {
       "function_locations": [
         {
           "name": "append",
@@ -2244,7 +2244,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "284": {
+    "285": {
       "function_locations": [
         {
           "name": "subarray",
@@ -2274,7 +2274,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "285": {
+    "286": {
       "function_locations": [
         {
           "name": "subbvec",
@@ -2316,7 +2316,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DstMaxLen` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DstLen` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DstLen` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SrcMaxLen: u32, let DstMaxLen: u32>(\n    bvec: BoundedVec<T, SrcMaxLen>,\n    offset: u32,\n) -> BoundedVec<T, DstMaxLen> {\n    // The new storage array is a subarray of the original one (which has zeroed storage past len), so elements past\n    // the new len remain zeroed: `subarray` does not allow extending arrays past their original length.\n    BoundedVec::from_parts(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not support capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DstLen too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "288": {
+    "289": {
       "function_locations": [
         {
           "name": "encode_bytes_as_fields",
@@ -2342,7 +2342,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "289": {
+    "290": {
       "function_locations": [
         {
           "name": "encode_fields_as_bytes",
@@ -2392,7 +2392,7 @@
       "path": "/home/aztec-dev/aztec-node/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"
     },
-    "292": {
+    "293": {
       "function_locations": [
         {
           "name": "get_sign_of_point",
@@ -2616,49 +2616,7 @@
       "path": "std/array/mod.nr",
       "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a vector.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let vector = array.as_vector();\n    /// assert_eq(vector, [1, 2].as_vector());\n    /// ```\n    #[builtin(as_vector)]\n    pub fn as_vector(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(&self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array along with its index,\n    /// returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.mapi(|i, a| i + a * 2);\n    /// assert_eq(b, [2, 5, 8]);\n    /// ```\n    pub fn mapi<U, Env>(&self, f: fn[Env](u32, T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(i, self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// let mut i = 0;\n    /// a.for_each(|x| {\n    ///     b[i] = x;\n    ///     i += 1;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_each<Env>(&self, f: fn[Env](T) -> ()) {\n        for i in 0..self.len() {\n            f(self[i]);\n        }\n    }\n\n    /// Applies a function to each element of this array along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// a.for_eachi(|i, x| {\n    ///     b[i] = x;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_eachi<Env>(&self, f: fn[Env](u32, T) -> ()) {\n        for i in 0..self.len() {\n            f(i, self[i]);\n        }\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(&self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(&self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(&self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(&self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n\n    /// Concatenates this array with another array.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr1 = [1, 2, 3, 4];\n    ///     let arr2 = [6, 7, 8, 9, 10, 11];\n    ///     let concatenated_arr = arr1.concat(arr2);\n    ///     assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    /// }\n    /// ```\n    pub fn concat<let M: u32>(&self, array2: [T; M]) -> [T; N + M] {\n        let mut result = [crate::mem::zeroed(); N + M];\n        for i in 0..N {\n            result[i] = self[i];\n        }\n        for i in 0..M {\n            result[i + N] = array2[i];\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the [`Self::sort_via`] function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(&self) -> Self {\n        self.sort_via(|a, b| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(&self, ordering: fn[Env](T, T) -> bool) -> Self {\n        if N != 0 {\n            // Safety: `sorted` array is checked to be:\n            // a. a permutation of `input`'s elements\n            // b. satisfying the predicate `ordering`\n            let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n            if !is_unconstrained() {\n                for i in 0..N - 1 {\n                    assert(\n                        ordering(sorted[i], sorted[i + 1]),\n                        \"Array has not been sorted correctly according to `ordering`.\",\n                    );\n                }\n                check_shuffle::check_shuffle(self, &sorted);\n            }\n            sorted\n        } else {\n            *self\n        }\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n\n    global arr_with_100_values: [u32; 100] = [\n        42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n        89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n        53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n        21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n        125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n    ];\n    global expected_with_100_values: [u32; 100] = [\n        0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n        32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n        62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n        86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n        119, 120, 121, 123, 123, 123, 125, 126, 127,\n    ];\n    fn sort_u32(a: u32, b: u32) -> bool {\n        a <= b\n    }\n\n    #[test]\n    fn test_sort() {\n        let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_empty() {\n        let arr: [u32; 0] = [];\n        let sorted = arr.sort();\n        assert(sorted == arr);\n    }\n\n    #[test]\n    fn test_sort_via_empty() {\n        let arr: [u32; 0] = [];\n        let sorted = arr.sort_via(sort_u32);\n        assert(sorted == arr);\n    }\n\n    #[test]\n    fn test_sort_100_values() {\n        let arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values_comptime() {\n        let sorted = arr_with_100_values.sort();\n        assert(sorted == expected_with_100_values);\n    }\n\n    #[test]\n    fn test_sort_via() {\n        let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_via_100_values() {\n        let arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn mapi_empty() {\n        assert_eq([].mapi(|i, x| i * x + 1), []);\n    }\n\n    #[test]\n    fn for_each_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_each(|_x| assert(false));\n    }\n\n    #[test]\n    fn for_eachi_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_eachi(|_i, _x| assert(false));\n    }\n\n    #[test]\n    fn map_example() {\n        let a = [1, 2, 3];\n        let b = a.map(|a| a * 2);\n        assert_eq(b, [2, 4, 6]);\n    }\n\n    #[test]\n    fn mapi_example() {\n        let a = [1, 2, 3];\n        let b = a.mapi(|i, a| i + a * 2);\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn for_each_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        let mut i = 0;\n        let i_ref = &mut i;\n        a.for_each(|x| {\n            b_ref[*i_ref] = x * 2;\n            *i_ref += 1;\n        });\n        assert_eq(b, [2, 4, 6]);\n        assert_eq(i, 3);\n    }\n\n    #[test]\n    fn for_eachi_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn concat() {\n        let arr1 = [1, 2, 3, 4];\n        let arr2 = [6, 7, 8, 9, 10, 11];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    }\n\n    #[test]\n    fn concat_zero_length_with_something() {\n        let arr1 = [];\n        let arr2 = [1];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_something_with_zero_length() {\n        let arr1 = [1];\n        let arr2 = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_zero_lengths() {\n        let arr1: [Field; 0] = [];\n        let arr2: [Field; 0] = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, []);\n    }\n\n    #[test]\n    fn test_fold() {\n        let array = [1, 2, 3];\n        let sum_plus_10 = array.fold(10, |x, y| x + y);\n        assert_eq(sum_plus_10, 16);\n    }\n\n    #[test]\n    fn test_reduce() {\n        let array = [1, 2, 3];\n        let sum = array.reduce(|x, y| x + y);\n        assert_eq(sum, 6);\n    }\n\n    #[test(should_fail_with = \"Index out of bounds\")]\n    fn test_reduce_failure_on_empty_array() {\n        let array: [Field; 0] = [];\n        let sum = array.reduce(|x, y| x + y);\n        assert_eq(sum, 6);\n    }\n\n    #[test]\n    fn test_all() {\n        let array = [1, 2, 3];\n        assert(array.all(|x| x >= 1));\n        assert(!array.all(|x| x >= 2));\n    }\n\n    #[test]\n    fn test_any() {\n        let array = [1, 2, 3];\n        assert(array.any(|x| x >= 3));\n        assert(!array.any(|x| x >= 4));\n    }\n\n    #[test]\n    fn test_to_string() {\n        let str = [78_u8, 111, 105, 114].as_str_unchecked();\n        assert_eq(str, \"Noir\");\n    }\n\n    #[test]\n    fn test_bytes_from_string() {\n        let bytes: [u8; 4] = crate::convert::From::from(\"Noir\");\n        assert_eq(bytes, [78_u8, 111, 105, 114]);\n    }\n}\n"
     },
-    "302": {
-      "function_locations": [
-        {
-          "name": "Poseidon2::hash",
-          "start": 333
-        },
-        {
-          "name": "Poseidon2::new",
-          "start": 442
-        },
-        {
-          "name": "Poseidon2::perform_duplex",
-          "start": 649
-        },
-        {
-          "name": "Poseidon2::absorb",
-          "start": 923
-        },
-        {
-          "name": "Poseidon2::squeeze",
-          "start": 1453
-        },
-        {
-          "name": "Poseidon2::hash_internal",
-          "start": 1814
-        },
-        {
-          "name": "<impl Hasher for Poseidon2Hasher>::finish",
-          "start": 4105
-        },
-        {
-          "name": "<impl Hasher for Poseidon2Hasher>::write",
-          "start": 4426
-        },
-        {
-          "name": "<impl Default for Poseidon2Hasher>::default",
-          "start": 4549
-        }
-      ],
-      "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon2.nr",
-      "source": "use std::default::Default;\nuse std::hash::Hasher;\n\nglobal RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        self.state[0] += self.cache[0];\n        self.state[1] += self.cache[1];\n        self.state[2] += self.cache[2];\n        self.state = crate::poseidon2_permutation(self.state);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut state = [0; 4];\n        state[RATE] = iv;\n\n        if std::runtime::is_unconstrained() {\n            for i in 0..(in_len / RATE) {\n                state[0] += input[i * RATE];\n                state[1] += input[i * RATE + 1];\n                state[2] += input[i * RATE + 2];\n                state = crate::poseidon2_permutation(state);\n            }\n\n            // handle remaining elements after last full RATE-sized chunk\n            let num_extra_fields = in_len % RATE;\n            if num_extra_fields != 0 {\n                let remainder_start = in_len - num_extra_fields;\n                state[0] += input[remainder_start];\n                if num_extra_fields > 1 {\n                    state[1] += input[remainder_start + 1];\n                }\n            }\n        } else {\n            let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n            states[0] = state;\n\n            // process all full RATE-sized chunks, storing state after each permutation\n            for chunk_idx in 0..(N / RATE) {\n                for i in 0..RATE {\n                    state[i] += input[chunk_idx * RATE + i];\n                }\n                state = crate::poseidon2_permutation(state);\n                states[chunk_idx + 1] = state;\n            }\n\n            // get state at the last full block before in_len\n            let first_partially_filled_chunk = in_len / RATE;\n            state = states[first_partially_filled_chunk];\n\n            // handle remaining elements after last full RATE-sized chunk\n            let remainder_start = (in_len / RATE) * RATE;\n            for j in 0..RATE {\n                let idx = remainder_start + j;\n                if idx < in_len {\n                    state[j] += input[idx];\n                }\n            }\n        }\n\n        // always run final permutation unless we just completed a full chunk\n        // still need to permute once if in_len is 0\n        if (in_len == 0) | (in_len % RATE != 0) {\n            state = crate::poseidon2_permutation(state);\n        };\n\n        state[0]\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: @[] }\n    }\n}\n"
-    },
-    "360": {
+    "361": {
       "function_locations": [
         {
           "name": "<impl Empty for AztecAddress>::empty",
@@ -2745,10 +2703,10 @@
           "start": 12908
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V3, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            DOM_SEP__CONTRACT_ADDRESS_V3,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x23877639c7424d1d2a9f514e59ee662b3154a730b783caf822d196b625ba4355;\n    assert_eq(address, expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V3);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x2e0787752b82b3ab9c28d67b48f24f8a3dac253023bf5136bbcb8ddbf4b1381c;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nfn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
     },
-    "390": {
+    "391": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -2891,10 +2849,10 @@
           "start": 19830
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/hash.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/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). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), 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/// 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\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_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 = separator_as_bytes.concat(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/// Computes a Poseidon2 hash with a domain separator 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/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\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/// Computes a Poseidon2 hash of a fixed string, such as a function signature or a domain separator name.\n///\n/// The bytes are packed into 31-byte little-endian chunks, one `Field` per chunk, and the result is\n/// [`poseidon2_hash`] of those fields.\n///\n/// The hash commits to the number of chunks but not to the byte length `N`: zero bytes at the end of the last chunk\n/// do not change the result, so `[1]`, `[1, 0]` and `[1, 0, ..., 0]` (31 bytes) all hash to the same value. Do not\n/// use this to commit to variable-length data, e.g. a payload zero-padded to a maximum length, unless the length is\n/// bound separately.\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 poseidon2_hash_bytes_matches_hash_of_packed_chunks() {\n    let mut bytes = [0; 32];\n    bytes[0] = 1;\n    bytes[1] = 2;\n    bytes[31] = 3;\n\n    assert_eq(poseidon2_hash_bytes(bytes), poseidon2_hash([1 + 2 * 256, 3]));\n}\n\n#[test]\nfn poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk() {\n    let hash = poseidon2_hash_bytes([1]);\n\n    assert_eq(poseidon2_hash_bytes([1, 0]), hash);\n    assert_eq(poseidon2_hash_bytes([1].concat([0; 30])), hash);\n}\n\n#[test]\nfn poseidon2_hash_bytes_commits_to_chunk_count() {\n    let one_chunk: [u8; 31] = [1].concat([0; 30]);\n    let two_chunks: [u8; 32] = [1].concat([0; 31]);\n\n    assert(poseidon2_hash_bytes(one_chunk) != poseidon2_hash_bytes(two_chunks));\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 subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\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"
     },
-    "392": {
+    "393": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -2965,10 +2923,10 @@
           "start": 2802
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/logging.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/noir-protocol-circuits/crates/types/src/logging.nr",
       "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_misc_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
-    "411": {
+    "412": {
       "function_locations": [
         {
           "name": "Poseidon2Sponge::hash",
@@ -2976,29 +2934,29 @@
         },
         {
           "name": "Poseidon2Sponge::new",
-          "start": 931
+          "start": 912
         },
         {
           "name": "Poseidon2Sponge::perform_duplex",
-          "start": 1144
+          "start": 1125
         },
         {
           "name": "Poseidon2Sponge::absorb",
-          "start": 1585
+          "start": 1566
         },
         {
           "name": "Poseidon2Sponge::squeeze",
-          "start": 2119
+          "start": 2100
         },
         {
           "name": "Poseidon2Sponge::hash_internal",
-          "start": 2537
+          "start": 2461
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/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 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"
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/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)\n    }\n\n    pub 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>(input: [Field; N], in_len: u32) -> 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"
     },
-    "429": {
+    "430": {
       "function_locations": [
         {
           "name": "<impl ToField for Field>::to_field",
@@ -3033,10 +2991,10 @@
           "start": 912
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/traits/to_field.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/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"
     },
-    "430": {
+    "431": {
       "function_locations": [
         {
           "name": "<impl Packable for bool>::pack",
@@ -3183,10 +3141,10 @@
           "start": 6145
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/type_packing.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/noir-protocol-circuits/crates/types/src/type_packing.nr",
       "source": "use crate::traits::{Deserialize, Packable, Serialize};\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\nglobal POINT_PACKED_LEN: u32 = 2;\n\nimpl Packable for bool {\n    let N: u32 = BOOL_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    /// Unpacks a `bool`, constraining the field to be a canonical boolean. A field outside `{0, 1}` is\n    /// rejected (rather than silently reinterpreted), so an arbitrary-origin field cannot be misread.\n    /// `pack` always emits `0` or `1`, so round-tripping is unaffected.\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> bool {\n        let v = fields[0];\n        // v * v == v holds iff v is 0 or 1: a single degree-2 constraint that both validates the field\n        // is a canonical bool and avoids the byte-range decomposition that a cast to u8 would require.\n        assert(v * v == v, \"Packable::unpack: bool field must be 0 or 1\");\n        v == 1\n    }\n}\n\nimpl Packable for u8 {\n    let N: u32 = U8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable for u16 {\n    let N: u32 = U16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable for u32 {\n    let N: u32 = U32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable for u64 {\n    let N: u32 = U64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable for u128 {\n    let N: u32 = U128_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable for Field {\n    let N: u32 = FIELD_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable for i8 {\n    let N: u32 = I8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u8 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Packable for i16 {\n    let N: u32 = I16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u16 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Packable for i32 {\n    let N: u32 = I32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u32 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Packable for i64 {\n    let N: u32 = I64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u64 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl Packable for super::point::EmbeddedCurvePoint {\n    let N: u32 = POINT_PACKED_LEN;\n    fn pack(self) -> [Field; Self::N] {\n        self.serialize()\n    }\n\n    fn unpack(packed: [Field; Self::N]) -> Self {\n        Self::deserialize(packed)\n    }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n    T: Packable,\n{\n    let N: u32 = M * <T as Packable>::N;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n        for i in 0..M {\n            let serialized = self[i].pack();\n            for j in 0..<T as Packable>::N {\n                result[i * <T as Packable>::N + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let result: [T; M] = std::mem::zeroed();\n        reader.read_struct_array::<T, <T as Packable>::N, M>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n\n#[test]\nfn test_bool_unpack_accepts_canonical_values() {\n    assert_eq(bool::unpack([0]), false);\n    assert_eq(bool::unpack([1]), true);\n}\n\n#[test(should_fail_with = \"bool field must be 0 or 1\")]\nfn test_bool_unpack_rejects_even_non_bool() {\n    // 2 has LSB 0, so the previous LSB-based unpack silently returned false; now it is rejected.\n    let _ = bool::unpack([2]);\n}\n\n#[test(should_fail_with = \"bool field must be 0 or 1\")]\nfn test_bool_unpack_rejects_odd_non_bool() {\n    // 3 has LSB 1, so the previous LSB-based unpack silently returned true; now it is rejected.\n    let _ = bool::unpack([3]);\n}\n\n#[test(should_fail_with = \"bool field must be 0 or 1\")]\nfn test_bool_unpack_rejects_large_field() {\n    let _ = bool::unpack([1000000]);\n}\n\n#[test]\nfn test_bool_pack_unpack_roundtrip() {\n    // `pack` always emits 0 or 1, so it round-trips through the canonical-bool check in `unpack`.\n    assert_eq(true.pack(), [1]);\n    assert_eq(false.pack(), [0]);\n    assert_eq(bool::unpack(true.pack()), true);\n    assert_eq(bool::unpack(false.pack()), false);\n}\n"
     },
-    "437": {
+    "438": {
       "function_locations": [
         {
           "name": "field_from_bytes",
@@ -3301,7 +3259,7 @@
           "start": 12474
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/types/src/utils/field.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    std::static_assert(N < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n    if f1.lt(f2) {\n        f1\n    } else {\n        f2\n    }\n}\n\n// TODO: write doc-comments and tests for these magic constants.\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// @dev: only use this for _huge_ exponents y, when writing a constrained function.\n// If you're only exponentiating by a small value, first consider writing-out the multiplications by hand.\n// Only after you've measured the gates of that approach, consider using the native Field::pow_32 function.\n// Only if your exponent is larger than 32 bits, resort to using this function.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [bool; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n/// Returns Option::some(sqrt) if there is a square root, and Option::none() if there isn't.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\nunconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field2.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n\n#[test]\nunconstrained fn sqrt_valid_test() {\n    let x = 16; // examples: 16, 9, 25, 81\n    let result = sqrt(x);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), x);\n}\n\n#[test]\nunconstrained fn sqrt_invalid_test() {\n    let x = KNOWN_NON_RESIDUE; // has no square root in the field\n    let result = sqrt(x);\n    assert(result.is_none());\n}\n\n#[test]\nunconstrained fn sqrt_zero_test() {\n    let result = sqrt(0);\n    assert(result.is_some());\n    assert_eq(result.unwrap(), 0);\n}\n\n#[test]\nunconstrained fn sqrt_one_test() {\n    let result = sqrt(1);\n    assert(result.is_some());\n    assert_eq(result.unwrap() * result.unwrap(), 1);\n}\n\n#[test]\nunconstrained fn field_from_bytes_empty_test() {\n    let empty: [u8; 0] = [];\n    let result = field_from_bytes(empty, true);\n    assert_eq(result, 0);\n\n    let result_le = field_from_bytes(empty, false);\n    assert_eq(result_le, 0);\n}\n\n#[test]\nunconstrained fn field_from_bytes_little_endian_test() {\n    // Test little-endian conversion: [0x01, 0x02] should be 0x0201 = 513\n    let bytes = [0x01, 0x02];\n    let result_le = field_from_bytes(bytes, false);\n    assert_eq(result_le, 0x0201);\n\n    // Compare with big-endian: [0x01, 0x02] should be 0x0102 = 258\n    let result_be = field_from_bytes(bytes, true);\n    assert_eq(result_be, 0x0102);\n}\n\n#[test]\nunconstrained fn pow_test() {\n    assert_eq(pow(2, 0), 1);\n    assert_eq(pow(2, 1), 2);\n    assert_eq(pow(2, 10), 1024);\n    assert_eq(pow(3, 5), 243);\n    assert_eq(pow(0, 5), 0);\n    assert_eq(pow(1, 100), 1);\n}\n\n#[test]\nunconstrained fn min_test() {\n    assert_eq(min(5, 10), 5);\n    assert_eq(min(10, 5), 5);\n    assert_eq(min(7, 7), 7);\n    assert_eq(min(0, 1), 0);\n}\n\n#[test]\nunconstrained fn sqrt_has_two_roots_test() {\n    // Every square has two roots: r and -r (i.e., p - r)\n    // sqrt(16) can return 4 or -4\n    let x = 16;\n    let result = sqrt(x).unwrap();\n    assert(result * result == x);\n    // The other root is -result\n    let other_root = 0 - result;\n    assert(other_root * other_root == x);\n    // Verify they are different (unless x = 0)\n    assert(result != other_root);\n\n    // Same for 9: roots are 3 and -3\n    let y = 9;\n    let result_y = sqrt(y).unwrap();\n    assert(result_y * result_y == y);\n    let other_root_y = 0 - result_y;\n    assert(other_root_y * other_root_y == y);\n    assert(result_y != other_root_y);\n}\n\n#[test]\nunconstrained fn sqrt_negative_one_test() {\n    let x = 0 - 1;\n    let result = sqrt(x).unwrap();\n    // -1 has two square roots, `r` and `-r` (= p - r), and `sqrt()` may legitimately return either one.\n    // Accept both rather than pinning the test to one particular root.\n    let known_root = 0x30644e72e131a029048b6e193fd841045cea24f6fd736bec231204708f703636;\n    assert((result == known_root) | (result == 0 - known_root));\n}\n\n#[test]\nunconstrained fn sqrt_negative_one_squares_back_test() {\n    let x = 0 - 1;\n    let root = sqrt(x).unwrap();\n    // Whichever root `sqrt` returns is a genuine square root of -1...\n    assert_eq(root * root, x);\n    // ...and so is its negation (the other root), which must be distinct.\n    let other_root = 0 - root;\n    assert_eq(other_root * other_root, x);\n    assert(root != other_root);\n}\n\n#[test]\nunconstrained fn validate_sqrt_hint_valid_test() {\n    // 4 is a valid sqrt of 16\n    validate_sqrt_hint(16, 4);\n    // -4 is also a valid sqrt of 16\n    validate_sqrt_hint(16, 0 - 4);\n    // 0 is a valid sqrt of 0\n    validate_sqrt_hint(0, 0);\n    // 1 is a valid sqrt of 1\n    validate_sqrt_hint(1, 1);\n    // -1 is also a valid sqrt of 1\n    validate_sqrt_hint(1, 0 - 1);\n}\n\n#[test(should_fail_with = \"is not the sqrt of x\")]\nunconstrained fn validate_sqrt_hint_invalid_test() {\n    // 5 is not a valid sqrt of 16\n    validate_sqrt_hint(16, 5);\n}\n\n#[test]\nunconstrained fn validate_not_sqrt_hint_valid_test() {\n    // 5 (KNOWN_NON_RESIDUE) is not a square.\n    let x = KNOWN_NON_RESIDUE;\n    let hint = tonelli_shanks_sqrt(x * KNOWN_NON_RESIDUE);\n    validate_not_sqrt_hint(x, hint);\n}\n\n#[test(should_fail_with = \"0 has a square root\")]\nunconstrained fn validate_not_sqrt_hint_zero_test() {\n    // 0 has a square root, so we cannot claim it is not square\n    validate_not_sqrt_hint(0, 0);\n}\n\n#[test(should_fail_with = \"does not demonstrate that\")]\nunconstrained fn validate_not_sqrt_hint_wrong_hint_test() {\n    // Provide a wrong hint for a non-square\n    let x = KNOWN_NON_RESIDUE;\n    validate_not_sqrt_hint(x, 123);\n}\n"
     },
     "44": {
@@ -3482,7 +3440,63 @@
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nmod tests {\n    use crate::cmp::Ord;\n    use crate::cmp::Ordering;\n    use crate::default::Default as _;\n    use super::Option;\n\n    #[test]\n    fn some_and_none() {\n        assert(Option::<u8>::none().is_none());\n        assert(!Option::<u8>::none().is_some());\n        assert(Option::some(1).is_some());\n        assert(!Option::some(1).is_none());\n    }\n\n    #[test]\n    fn unwrap_succeeds() {\n        assert_eq(Option::some(1).unwrap(), 1);\n    }\n\n    #[test(should_fail)]\n    fn unwrap_fails() {\n        let _ = Option::<u8>::none().unwrap();\n    }\n\n    #[test]\n    fn unwrap_or() {\n        assert_eq(Option::some(1).unwrap_or(2), 1);\n        assert_eq(Option::none().unwrap_or(2), 2);\n    }\n\n    #[test]\n    fn unwrap_or_else() {\n        assert_eq(Option::some(1).unwrap_or_else(|| 2), 1);\n        assert_eq(Option::none().unwrap_or_else(|| 2), 2);\n    }\n\n    #[test]\n    fn expect_succeeds() {\n        assert_eq(Option::some(1).expect(f\"Should be there\"), 1);\n    }\n\n    #[test(should_fail_with = \"Should be there\")]\n    fn expect_fails() {\n        let _ = Option::<u8>::none().expect(f\"Should be there\");\n    }\n\n    #[test]\n    fn map() {\n        assert(Option::<u8>::none().map(|x| x + 1).is_none());\n        assert_eq(Option::some(1).map(|x| x + 1), Option::some(2));\n    }\n\n    #[test]\n    fn map_or() {\n        assert_eq(Option::<u8>::none().map_or(0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or(0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn map_or_else() {\n        assert_eq(Option::<u8>::none().map_or_else(|| 0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or_else(|| 0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn and() {\n        assert_eq(Option::<u8>::none().and(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().and(Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and(Option::some(2)), Option::some(2));\n        assert_eq(Option::some(1).and(Option::none()), Option::none());\n    }\n\n    #[test]\n    fn and_then() {\n        assert_eq(Option::<u8>::none().and_then(|_| Option::<u8>::none()), Option::none());\n        assert_eq(Option::<u8>::none().and_then(|_| Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and_then(|x| Option::some(x + 1)), Option::some(2));\n        assert_eq(Option::some(1).and_then(|_| Option::<u8>::none()), Option::none());\n    }\n\n    #[test]\n    fn or() {\n        assert_eq(Option::<u8>::none().or(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn or_else() {\n        assert_eq(Option::<u8>::none().or_else(|| Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or_else(|| Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn xor() {\n        assert_eq(Option::<u8>::none().xor(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().xor(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).xor(Option::some(2)), Option::none());\n        assert_eq(Option::some(1).xor(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn filter() {\n        assert_eq(Option::<u8>::none().filter(|_| true), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 1), Option::some(1));\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n    }\n\n    #[test]\n    fn flatten() {\n        assert_eq(Option::<Option<u8>>::none().flatten(), Option::none());\n        assert_eq(Option::some(Option::<u8>::none()).flatten(), Option::none());\n        assert_eq(Option::some(Option::some(1)).flatten(), Option::some(1));\n    }\n\n    #[test]\n    fn default() {\n        assert_eq(Option::<u8>::default(), Option::none());\n    }\n\n    #[test]\n    fn eq() {\n        assert(Option::<u8>::none() == Option::none());\n        assert(Option::<u8>::some(1) != Option::none());\n        assert(Option::<u8>::none() != Option::some(1));\n        assert(Option::<u8>::some(1) == Option::some(1));\n        assert(Option::<u8>::some(1) != Option::some(2));\n    }\n\n    #[test]\n    fn cmp() {\n        let none = Option::<u8>::none();\n        let one = Option::<u8>::some(1);\n        let two = Option::<u8>::some(2);\n        assert_eq(none.cmp(none), Ordering::equal());\n        assert_eq(none.cmp(one), Ordering::less());\n        assert_eq(one.cmp(none), Ordering::greater());\n        assert_eq(one.cmp(one), Ordering::equal());\n        assert_eq(one.cmp(two), Ordering::less());\n        assert_eq(two.cmp(one), Ordering::greater());\n    }\n}\n"
     },
-    "442": {
+    "449": {
+      "function_locations": [
+        {
+          "name": "Poseidon2::hash",
+          "start": 333
+        },
+        {
+          "name": "Poseidon2::new",
+          "start": 442
+        },
+        {
+          "name": "Poseidon2::perform_duplex",
+          "start": 649
+        },
+        {
+          "name": "Poseidon2::absorb",
+          "start": 1028
+        },
+        {
+          "name": "Poseidon2::squeeze",
+          "start": 1558
+        },
+        {
+          "name": "Poseidon2::hash_internal",
+          "start": 1919
+        },
+        {
+          "name": "<impl Hasher for Poseidon2Hasher>::finish",
+          "start": 4210
+        },
+        {
+          "name": "<impl Hasher for Poseidon2Hasher>::write",
+          "start": 4531
+        },
+        {
+          "name": "<impl Default for Poseidon2Hasher>::default",
+          "start": 4654
+        }
+      ],
+      "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.4.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] * ((0 < self.cache_size) as Field);\n        self.state[1] += self.cache[1] * ((1 < self.cache_size) as Field);\n        self.state[2] += self.cache[2] * ((2 < self.cache_size) as Field);\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"
+    },
+    "45": {
+      "function_locations": [
+        {
+          "name": "panic",
+          "start": 196
+        },
+        {
+          "name": "tests::panics",
+          "start": 469
+        }
+      ],
+      "path": "std/panic.nr",
+      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
+    },
+    "452": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -3529,10 +3543,10 @@
           "start": 1426
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/reader.nr",
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/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"
     },
-    "443": {
+    "453": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -3540,25 +3554,25 @@
         },
         {
           "name": "derive_deserialize",
-          "start": 7176
+          "start": 7397
         },
         {
           "name": "get_params_len_quote",
-          "start": 11002
+          "start": 11362
         },
         {
           "name": "get_generics_declarations",
-          "start": 11494
+          "start": 11854
         },
         {
           "name": "get_where_trait_clause",
-          "start": 12587
+          "start": 12947
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/serialization.nr",
-      "source": "use crate::{reader::Reader, writer::Writer};\nuse std::meta::type_def::StructField;\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    let params = nested_struct.definition().fields(nested_struct.generics());\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(|field: StructField| {\n            let name = field.name();\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.definition().fields(nested_struct.generics());\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(|field: StructField| {\n                let param_type = field.typ();\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(|field: StructField| {\n                let param_name = field.name();\n                let param_type = field.typ();\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(|field: StructField| {\n                let param_name = field.name();\n                quote { $param_name }\n            })\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].name();\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` - The struct fields to serialize. Each field's type needs 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: [StructField]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|field: StructField| {\n                let param_type = field.typ();\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(|generic| {\n                let name = generic.typ();\n                let maybe_integer_typ = generic.numeric_type();\n                // numeric_type is Some only when 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    // numeric_type is Some only when the generic is numeric.\n    let non_numeric_generics = generics.filter(|generic| generic.numeric_type().is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations = non_numeric_generics\n            .map(|generic| {\n                let name = generic.typ();\n                quote {$name: $trait_name}\n            })\n            .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"
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/serialization.nr",
+      "source": "use crate::{reader::Reader, writer::Writer};\nuse std::meta::type_def::StructField;\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    let params = nested_struct.definition().fields(nested_struct.generics());\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 = if params.len() == 0 {\n        // Nothing to serialize, so the parameter is referenced to keep the generated function warning-free.\n        quote { let _ = writer; }\n    } else {\n        params\n            .map(|field: StructField| {\n                let name = field.name();\n                quote {\n                    $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n                }\n            })\n            .join(quote {})\n    };\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.definition().fields(nested_struct.generics());\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(|field: StructField| {\n                let param_type = field.typ();\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(|field: StructField| {\n                let param_name = field.name();\n                let param_type = field.typ();\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(|field: StructField| {\n                let param_name = field.name();\n                quote { $param_name }\n            })\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].name();\n        quote {\n            Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n        }\n    } else {\n        // Nothing to deserialize, so the parameter is referenced to keep the generated function warning-free.\n        quote {\n            let _ = reader;\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` - The struct fields to serialize. Each field's type needs 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: [StructField]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|field: StructField| {\n                let param_type = field.typ();\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(|generic| {\n                let name = generic.typ();\n                let maybe_integer_typ = generic.numeric_type();\n                // numeric_type is Some only when 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    // numeric_type is Some only when the generic is numeric.\n    let non_numeric_generics = generics.filter(|generic| generic.numeric_type().is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations = non_numeric_generics\n            .map(|generic| {\n                let name = generic.typ();\n                quote {$name: $trait_name}\n            })\n            .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"
     },
-    "445": {
+    "455": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -3762,117 +3776,113 @@
         },
         {
           "name": "<impl Deserialize for Option<T>>::deserialize",
-          "start": 10997
+          "start": 11278
         },
         {
           "name": "<impl Deserialize for Option<T>>::stream_deserialize",
-          "start": 11243
+          "start": 11524
         },
         {
           "name": "<impl Serialize for EmbeddedCurveScalar>::serialize",
-          "start": 11621
+          "start": 11902
         },
         {
           "name": "<impl Serialize for EmbeddedCurveScalar>::stream_serialize",
-          "start": 11744
+          "start": 12025
         },
         {
           "name": "<impl Deserialize for EmbeddedCurveScalar>::deserialize",
-          "start": 11944
+          "start": 12225
         },
         {
           "name": "<impl Deserialize for EmbeddedCurveScalar>::stream_deserialize",
-          "start": 12090
+          "start": 12371
         },
         {
           "name": "<impl Serialize for EmbeddedCurvePoint>::serialize",
-          "start": 12297
+          "start": 12578
         },
         {
           "name": "<impl Serialize for EmbeddedCurvePoint>::stream_serialize",
-          "start": 12397
+          "start": 12678
         },
         {
           "name": "<impl Deserialize for EmbeddedCurvePoint>::deserialize",
-          "start": 12593
+          "start": 12874
         },
         {
           "name": "<impl Deserialize for EmbeddedCurvePoint>::stream_deserialize",
-          "start": 12737
+          "start": 13018
         },
         {
           "name": "<impl Deserialize for str<M>>::deserialize",
-          "start": 12916
+          "start": 13197
         },
         {
           "name": "<impl Deserialize for str<M>>::stream_deserialize",
-          "start": 13162
+          "start": 13443
         },
         {
           "name": "<impl Serialize for str<M>>::serialize",
-          "start": 13395
+          "start": 13676
         },
         {
           "name": "<impl Serialize for str<M>>::stream_serialize",
-          "start": 13616
+          "start": 13897
         },
         {
           "name": "<impl Deserialize for BoundedVec<T, M>>::deserialize",
-          "start": 13997
+          "start": 14278
         },
         {
           "name": "<impl Deserialize for BoundedVec<T, M>>::stream_deserialize",
-          "start": 14243
+          "start": 14524
         },
         {
           "name": "<impl Deserialize for ()>::deserialize",
-          "start": 15299
+          "start": 15744
         },
         {
           "name": "<impl Deserialize for ()>::stream_deserialize",
-          "start": 15546
+          "start": 15991
         },
         {
           "name": "<impl Serialize for BoundedVec<T, M>>::serialize",
-          "start": 15911
+          "start": 16356
         },
         {
           "name": "<impl Serialize for BoundedVec<T, M>>::stream_serialize",
-          "start": 16132
+          "start": 16577
         },
         {
           "name": "make_slice",
-          "start": 16617
+          "start": 17137
         },
         {
           "name": "impl_serialize_for_tuple",
-          "start": 16867
+          "start": 17387
         },
         {
           "name": "<impl Serialize for (T1,)>::serialize",
-          "start": 20178
+          "start": 20698
         },
         {
           "name": "<impl Serialize for (T1,)>::stream_serialize",
-          "start": 20429
+          "start": 20949
         },
         {
           "name": "<impl Deserialize for (T1,)>::deserialize",
-          "start": 20636
+          "start": 21156
         },
         {
           "name": "<impl Deserialize for (T1,)>::stream_deserialize",
-          "start": 20897
-        },
-        {
-          "name": "bounded_vec_serialization",
-          "start": 21246
+          "start": 21417
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/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"
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/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        let is_some = self.is_some();\n        writer.write_bool(is_some);\n        // A `None` must have an all-zero payload, so every `Option` value has exactly one encoding. Private function\n        // arguments are bound to the caller only through a hash of this encoding.\n        let payload = self.unwrap_unchecked().serialize();\n        if !is_some {\n            assert_eq(payload, [0; <T as Serialize>::N], \"Option None payload must be zero\");\n        }\n        writer.write_array(payload);\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 raw_len = reader.peek_offset(payload_len);\n        let len = raw_len as u32;\n        assert_eq(raw_len, len as Field, \"BoundedVec length is not u32\");\n        assert(len <= M, \"BoundedVec length exceeds max\");\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        let len = self.len();\n        assert(len <= M, \"BoundedVec length exceeds max\");\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(len);\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"
     },
-    "446": {
+    "456": {
       "function_locations": [
         {
           "name": "Writer<N>::new",
@@ -3906,31 +3916,323 @@
           "name": "Writer<N>::write_struct_array",
           "start": 1040
         },
-        {
-          "name": "Writer<N>::advance_offset",
-          "start": 1185
-        },
         {
           "name": "Writer<N>::finish",
-          "start": 1263
+          "start": 1173
         }
       ],
-      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0-rc.6/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/writer.nr",
-      "source": "pub struct Writer<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Writer<N> {\n    pub fn new() -> Self {\n        Self { data: [0; N], offset: 0 }\n    }\n\n    pub fn write(&mut self, value: Field) {\n        self.data[self.offset] = value;\n        self.offset += 1;\n    }\n\n    pub fn write_u32(&mut self, value: u32) {\n        self.write(value as Field);\n    }\n\n    pub fn write_u64(&mut self, value: u64) {\n        self.write(value as Field);\n    }\n\n    pub fn write_bool(&mut self, value: bool) {\n        self.write(value as Field);\n    }\n\n    pub fn write_array<let K: u32>(&mut self, value: [Field; K]) {\n        for i in 0..K {\n            self.data[i + self.offset] = value[i];\n        }\n        self.offset += K;\n    }\n\n    pub fn write_struct<T, let K: u32>(&mut self, value: T, serialize: fn(T) -> [Field; K]) {\n        self.write_array(serialize(value));\n    }\n\n    pub fn write_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        value: [T; C],\n        serialize: fn(T) -> [Field; K],\n    ) {\n        for i in 0..C {\n            self.write_struct(value[i], serialize);\n        }\n    }\n\n    pub fn advance_offset(&mut self, offset: u32) {\n        self.offset += offset;\n    }\n\n    pub fn finish(self) -> [Field; N] {\n        assert_eq(self.offset, self.data.len(), \"Writer did not write all data\");\n        self.data\n    }\n}\n"
+      "path": "/home/aztec-dev/nargo/github.com/AztecProtocol/aztec-packages/v6.0.0/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/writer.nr",
+      "source": "pub struct Writer<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Writer<N> {\n    pub fn new() -> Self {\n        Self { data: [0; N], offset: 0 }\n    }\n\n    pub fn write(&mut self, value: Field) {\n        self.data[self.offset] = value;\n        self.offset += 1;\n    }\n\n    pub fn write_u32(&mut self, value: u32) {\n        self.write(value as Field);\n    }\n\n    pub fn write_u64(&mut self, value: u64) {\n        self.write(value as Field);\n    }\n\n    pub fn write_bool(&mut self, value: bool) {\n        self.write(value as Field);\n    }\n\n    pub fn write_array<let K: u32>(&mut self, value: [Field; K]) {\n        for i in 0..K {\n            self.data[i + self.offset] = value[i];\n        }\n        self.offset += K;\n    }\n\n    pub fn write_struct<T, let K: u32>(&mut self, value: T, serialize: fn(T) -> [Field; K]) {\n        self.write_array(serialize(value));\n    }\n\n    pub fn write_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        value: [T; C],\n        serialize: fn(T) -> [Field; K],\n    ) {\n        for i in 0..C {\n            self.write_struct(value[i], serialize);\n        }\n    }\n\n    pub fn finish(self) -> [Field; N] {\n        assert_eq(self.offset, self.data.len(), \"Writer did not write all data\");\n        self.data\n    }\n}\n"
     },
-    "45": {
+    "5": {
       "function_locations": [
         {
-          "name": "panic",
-          "start": 196
+          "name": "derive_eq",
+          "start": 305
         },
         {
-          "name": "tests::panics",
-          "start": 469
+          "name": "<impl Eq for Field>::eq",
+          "start": 851
+        },
+        {
+          "name": "<impl Eq for u128>::eq",
+          "start": 940
+        },
+        {
+          "name": "<impl Eq for u64>::eq",
+          "start": 1026
+        },
+        {
+          "name": "<impl Eq for u32>::eq",
+          "start": 1112
+        },
+        {
+          "name": "<impl Eq for u16>::eq",
+          "start": 1198
+        },
+        {
+          "name": "<impl Eq for u8>::eq",
+          "start": 1282
+        },
+        {
+          "name": "<impl Eq for i8>::eq",
+          "start": 1366
+        },
+        {
+          "name": "<impl Eq for i16>::eq",
+          "start": 1452
+        },
+        {
+          "name": "<impl Eq for i32>::eq",
+          "start": 1538
+        },
+        {
+          "name": "<impl Eq for i64>::eq",
+          "start": 1624
+        },
+        {
+          "name": "<impl Eq for ()>::eq",
+          "start": 1717
+        },
+        {
+          "name": "<impl Eq for bool>::eq",
+          "start": 1796
+        },
+        {
+          "name": "<impl Eq for [T; N]>::eq",
+          "start": 1921
+        },
+        {
+          "name": "<impl Eq for [T]>::eq",
+          "start": 2139
+        },
+        {
+          "name": "<impl Eq for str<N>>::eq",
+          "start": 2418
+        },
+        {
+          "name": "make_tuple_eq_body",
+          "start": 2598
+        },
+        {
+          "name": "<impl Eq for (A,)>::eq",
+          "start": 2848
+        },
+        {
+          "name": "<impl Eq for (A, B)>::eq",
+          "start": 2959
+        },
+        {
+          "name": "<impl Eq for (A, B, C)>::eq",
+          "start": 3091
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D)>::eq",
+          "start": 3236
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E)>::eq",
+          "start": 3394
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F)>::eq",
+          "start": 3565
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F, G)>::eq",
+          "start": 3749
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F, G, H)>::eq",
+          "start": 3946
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F, G, H, I)>::eq",
+          "start": 4156
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F, G, H, I, J)>::eq",
+          "start": 4379
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F, G, H, I, J, K)>::eq",
+          "start": 4616
+        },
+        {
+          "name": "<impl Eq for (A, B, C, D, E, F, G, H, I, J, K, L)>::eq",
+          "start": 4866
+        },
+        {
+          "name": "<impl Eq for Ordering>::eq",
+          "start": 4976
+        },
+        {
+          "name": "Ordering::less",
+          "start": 5577
+        },
+        {
+          "name": "Ordering::equal",
+          "start": 5648
+        },
+        {
+          "name": "Ordering::greater",
+          "start": 5721
+        },
+        {
+          "name": "derive_ord",
+          "start": 6092
+        },
+        {
+          "name": "<impl Ord for u128>::cmp",
+          "start": 6742
+        },
+        {
+          "name": "<impl Ord for u64>::cmp",
+          "start": 6989
+        },
+        {
+          "name": "<impl Ord for u32>::cmp",
+          "start": 7237
+        },
+        {
+          "name": "<impl Ord for u16>::cmp",
+          "start": 7485
+        },
+        {
+          "name": "<impl Ord for u8>::cmp",
+          "start": 7731
+        },
+        {
+          "name": "<impl Ord for i8>::cmp",
+          "start": 7977
+        },
+        {
+          "name": "<impl Ord for i16>::cmp",
+          "start": 8225
+        },
+        {
+          "name": "<impl Ord for i32>::cmp",
+          "start": 8473
+        },
+        {
+          "name": "<impl Ord for i64>::cmp",
+          "start": 8721
+        },
+        {
+          "name": "<impl Ord for ()>::cmp",
+          "start": 8975
+        },
+        {
+          "name": "<impl Ord for bool>::cmp",
+          "start": 9074
+        },
+        {
+          "name": "<impl Ord for [T; N]>::cmp",
+          "start": 9544
+        },
+        {
+          "name": "<impl Ord for [T]>::cmp",
+          "start": 9947
+        },
+        {
+          "name": "make_tuple_ord_body",
+          "start": 10515
+        },
+        {
+          "name": "<impl Ord for (A,)>::cmp",
+          "start": 11125
+        },
+        {
+          "name": "<impl Ord for (A, B)>::cmp",
+          "start": 11246
+        },
+        {
+          "name": "<impl Ord for (A, B, C)>::cmp",
+          "start": 11388
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D)>::cmp",
+          "start": 11544
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E)>::cmp",
+          "start": 11714
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F)>::cmp",
+          "start": 11898
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F, G)>::cmp",
+          "start": 12096
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F, G, H)>::cmp",
+          "start": 12308
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F, G, H, I)>::cmp",
+          "start": 12534
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F, G, H, I, J)>::cmp",
+          "start": 12774
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F, G, H, I, J, K)>::cmp",
+          "start": 13029
+        },
+        {
+          "name": "<impl Ord for (A, B, C, D, E, F, G, H, I, J, K, L)>::cmp",
+          "start": 13298
+        },
+        {
+          "name": "max",
+          "start": 13660
+        },
+        {
+          "name": "min",
+          "start": 14037
+        },
+        {
+          "name": "cmp_tests::sanity_check_min",
+          "start": 14231
+        },
+        {
+          "name": "cmp_tests::sanity_check_max",
+          "start": 14427
+        },
+        {
+          "name": "cmp_tests::correctly_handles_unequal_length_vectors",
+          "start": 14649
+        },
+        {
+          "name": "cmp_tests::lexicographic_ordering_for_vectors",
+          "start": 14849
+        },
+        {
+          "name": "cmp_tests::eq_unit",
+          "start": 15181
+        },
+        {
+          "name": "cmp_tests::eq_bool",
+          "start": 15246
+        },
+        {
+          "name": "cmp_tests::eq_integers",
+          "start": 15422
+        },
+        {
+          "name": "cmp_tests::eq_tuples",
+          "start": 16163
+        },
+        {
+          "name": "cmp_tests::cmp_unit",
+          "start": 17041
+        },
+        {
+          "name": "cmp_tests::cmp_bool",
+          "start": 17130
+        },
+        {
+          "name": "cmp_tests::cmp_integers",
+          "start": 17394
+        },
+        {
+          "name": "cmp_tests::cmp_tuples",
+          "start": 18217
+        },
+        {
+          "name": "cmp_tests::cmp_array",
+          "start": 19224
+        },
+        {
+          "name": "cmp_tests::cmp_vectors",
+          "start": 19468
         }
       ],
-      "path": "std/panic.nr",
-      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
+      "path": "std/cmp.nr",
+      "source": "use crate::meta::ctstring::AsCtString;\nuse crate::meta::derive_via;\n\n/// Compare two values for equality\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n    fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n    let for_each_field = |name| quote { (_self.$name == _other.$name) };\n    let body = |fields| {\n        if s.fields_as_written().len() == 0 {\n            quote { true }\n        } else {\n            fields\n        }\n    };\n    crate::meta::make_trait_impl(\n        s,\n        quote { $crate::cmp::Eq },\n        signature,\n        for_each_field,\n        quote { & },\n        body,\n    )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n    fn eq(self, other: Field) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for u128 {\n    fn eq(self, other: u128) -> bool {\n        self == other\n    }\n}\nimpl Eq for u64 {\n    fn eq(self, other: u64) -> bool {\n        self == other\n    }\n}\nimpl Eq for u32 {\n    fn eq(self, other: u32) -> bool {\n        self == other\n    }\n}\nimpl Eq for u16 {\n    fn eq(self, other: u16) -> bool {\n        self == other\n    }\n}\nimpl Eq for u8 {\n    fn eq(self, other: u8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i8 {\n    fn eq(self, other: i8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i16 {\n    fn eq(self, other: i16) -> bool {\n        self == other\n    }\n}\nimpl Eq for i32 {\n    fn eq(self, other: i32) -> bool {\n        self == other\n    }\n}\nimpl Eq for i64 {\n    fn eq(self, other: i64) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for () {\n    fn eq(_self: Self, _other: ()) -> bool {\n        true\n    }\n}\nimpl Eq for bool {\n    fn eq(self, other: bool) -> bool {\n        self == other\n    }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T; N]) -> bool {\n        let mut result = true;\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<T> Eq for [T]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T]) -> bool {\n        let mut result = self.len() == other.len();\n        if result {\n            for i in 0..self.len() {\n                result &= self[i].eq(other[i]);\n            }\n        }\n        result\n    }\n}\n\nimpl<let N: u32> Eq for str<N> {\n    fn eq(self, other: str<N>) -> bool {\n        let self_bytes = self.as_bytes();\n        let other_bytes = other.as_bytes();\n        self_bytes == other_bytes\n    }\n}\n\ncomptime fn make_tuple_eq_body(n: u32) -> Quoted {\n    let mut body = f\"self.0.eq(other.0)\".as_ctstring();\n    for i in 1u32..n {\n        body = body.append_fmtstr(f\" & self.{i}.eq(other.{i})\");\n    }\n    f\"{body}\".quoted_contents()\n}\n\nimpl<A: Eq> Eq for (A,) {\n    fn eq(self, other: (A,)) -> bool {\n        self.0 == other.0\n    }\n}\n\nimpl<A: Eq, B: Eq> Eq for (A, B) {\n    fn eq(self, other: (A, B)) -> bool {\n        make_tuple_eq_body!(2u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq> Eq for (A, B, C) {\n    fn eq(self, other: (A, B, C)) -> bool {\n        make_tuple_eq_body!(3u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq> Eq for (A, B, C, D) {\n    fn eq(self, other: (A, B, C, D)) -> bool {\n        make_tuple_eq_body!(4u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq> Eq for (A, B, C, D, E) {\n    fn eq(self, other: (A, B, C, D, E)) -> bool {\n        make_tuple_eq_body!(5u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq> Eq for (A, B, C, D, E, F) {\n    fn eq(self, other: (A, B, C, D, E, F)) -> bool {\n        make_tuple_eq_body!(6u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq> Eq for (A, B, C, D, E, F, G) {\n    fn eq(self, other: (A, B, C, D, E, F, G)) -> bool {\n        make_tuple_eq_body!(7u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for (A, B, C, D, E, F, G, H) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H)) -> bool {\n        make_tuple_eq_body!(8u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq> Eq for (A, B, C, D, E, F, G, H, I) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I)) -> bool {\n        make_tuple_eq_body!(9u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq> Eq for (A, B, C, D, E, F, G, H, I, J) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J)) -> bool {\n        make_tuple_eq_body!(10u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> bool {\n        make_tuple_eq_body!(11u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K, L) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> bool {\n        make_tuple_eq_body!(12u32)\n    }\n}\n\nimpl Eq for Ordering {\n    fn eq(self, other: Ordering) -> bool {\n        self.result == other.result\n    }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\n/// A value with three states: `Ordering::less()`, `Ordering::equal()` or `Ordering::greater()`.\n/// Most often used to encode the result of a comparison operation.\npub struct Ordering {\n    result: Field,\n}\n\nimpl Ordering {\n    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n    // into the compiler, do not change these without also updating\n    // the compiler itself!\n    pub fn less() -> Ordering {\n        Ordering { result: 0 }\n    }\n\n    pub fn equal() -> Ordering {\n        Ordering { result: 1 }\n    }\n\n    pub fn greater() -> Ordering {\n        Ordering { result: 2 }\n    }\n}\n\n/// Compare one object to another, returning whether it is less-than, equal-to,\n/// or greater-than the other object.\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n    fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::cmp::Ord };\n    let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n    let for_each_field = |name| quote {\n        if result == $crate::cmp::Ordering::equal() {\n            result = _self.$name.cmp(_other.$name);\n        }\n    };\n    let body = |fields| quote {\n        let mut result = $crate::cmp::Ordering::equal();\n        $fields\n        result\n    };\n    crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n    fn cmp(self, other: u128) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\nimpl Ord for u64 {\n    fn cmp(self, other: u64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u32 {\n    fn cmp(self, other: u32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u16 {\n    fn cmp(self, other: u16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u8 {\n    fn cmp(self, other: u8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i8 {\n    fn cmp(self, other: i8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i16 {\n    fn cmp(self, other: i16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i32 {\n    fn cmp(self, other: i32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i64 {\n    fn cmp(self, other: i64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for () {\n    fn cmp(_self: Self, _other: ()) -> Ordering {\n        Ordering::equal()\n    }\n}\n\nimpl Ord for bool {\n    fn cmp(self, other: bool) -> Ordering {\n        if self {\n            if other {\n                Ordering::equal()\n            } else {\n                Ordering::greater()\n            }\n        } else if other {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T; N]) -> Ordering {\n        let mut result = Ordering::equal();\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                result = self[i].cmp(other[i]);\n            }\n        }\n        result\n    }\n}\n\nimpl<T> Ord for [T]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T]) -> Ordering {\n        let self_len = self.len();\n        let other_len = other.len();\n        let min_len = if self_len < other_len {\n            self_len\n        } else {\n            other_len\n        };\n\n        let mut result = Ordering::equal();\n        for i in 0..min_len {\n            if result == Ordering::equal() {\n                result = self[i].cmp(other[i]);\n            }\n        }\n\n        if result != Ordering::equal() {\n            result\n        } else {\n            self_len.cmp(other_len)\n        }\n    }\n}\n\ncomptime fn make_tuple_ord_body(n: u32) -> Quoted {\n    let last = n - 1u32;\n    let mut body = if last == 1 {\n        f\"let result = self.0.cmp(other.0);\".as_ctstring()\n    } else {\n        f\"let mut result = self.0.cmp(other.0);\".as_ctstring()\n    };\n    for i in 1u32..last {\n        body = body.append_fmtstr(\n            f\" if result == Ordering::equal() {{ result = self.{i}.cmp(other.{i}); }}\",\n        );\n    }\n    body = body.append_fmtstr(\n        f\" if result != Ordering::equal() {{ result }} else {{ self.{last}.cmp(other.{last}) }}\",\n    );\n    f\"{body}\".quoted_contents()\n}\n\nimpl<A: Ord> Ord for (A,) {\n    fn cmp(self, other: (A,)) -> Ordering {\n        self.0.cmp(other.0)\n    }\n}\n\nimpl<A: Ord, B: Ord> Ord for (A, B) {\n    fn cmp(self, other: (A, B)) -> Ordering {\n        make_tuple_ord_body!(2u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C) {\n    fn cmp(self, other: (A, B, C)) -> Ordering {\n        make_tuple_ord_body!(3u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord> Ord for (A, B, C, D) {\n    fn cmp(self, other: (A, B, C, D)) -> Ordering {\n        make_tuple_ord_body!(4u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord> Ord for (A, B, C, D, E) {\n    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n        make_tuple_ord_body!(5u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord> Ord for (A, B, C, D, E, F) {\n    fn cmp(self, other: (A, B, C, D, E, F)) -> Ordering {\n        make_tuple_ord_body!(6u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord> Ord for (A, B, C, D, E, F, G) {\n    fn cmp(self, other: (A, B, C, D, E, F, G)) -> Ordering {\n        make_tuple_ord_body!(7u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord> Ord for (A, B, C, D, E, F, G, H) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H)) -> Ordering {\n        make_tuple_ord_body!(8u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord> Ord for (A, B, C, D, E, F, G, H, I) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I)) -> Ordering {\n        make_tuple_ord_body!(9u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord> Ord for (A, B, C, D, E, F, G, H, I, J) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J)) -> Ordering {\n        make_tuple_ord_body!(10u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> Ordering {\n        make_tuple_ord_body!(11u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering {\n        make_tuple_ord_body!(12u32)\n    }\n}\n\n/// Compares and returns the maximum of two values.\n///\n/// Returns the second argument if the comparison determines them to be equal.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq(cmp::max(1, 2), 2);\n/// assert_eq(cmp::max(2, 2), 2);\n/// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v1\n    } else {\n        v2\n    }\n}\n\n/// Compares and returns the minimum of two values.\n///\n/// Returns the first argument if the comparison determines them to be equal.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq(cmp::min(1, 2), 1);\n/// assert_eq(cmp::min(2, 2), 2);\n/// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v2\n    } else {\n        v1\n    }\n}\n\nmod cmp_tests {\n    use crate::meta::unquote;\n    use super::{Eq, max, min, Ord, Ordering};\n\n    #[test]\n    fn sanity_check_min() {\n        assert_eq(min(0_u64, 1), 0);\n        assert_eq(min(0_u64, 0), 0);\n        assert_eq(min(1_u64, 1), 1);\n        assert_eq(min(255_u8, 0), 0);\n    }\n\n    #[test]\n    fn sanity_check_max() {\n        assert_eq(max(0_u64, 1), 1);\n        assert_eq(max(0_u64, 0), 0);\n        assert_eq(max(1_u64, 1), 1);\n        assert_eq(max(255_u8, 0), 255);\n    }\n\n    #[test]\n    fn correctly_handles_unequal_length_vectors() {\n        let vector_1 = [0, 1, 2, 3].as_vector();\n        let vector_2 = [0, 1, 2].as_vector();\n        assert(!vector_1.eq(vector_2));\n    }\n\n    #[test]\n    fn lexicographic_ordering_for_vectors() {\n        assert(\n            [2_u32].as_vector().cmp([1_u32, 1_u32, 1_u32].as_vector())\n                == super::Ordering::greater(),\n        );\n        assert(\n            [1_u32, 2_u32].as_vector().cmp([1_u32, 2_u32, 3_u32].as_vector())\n                == super::Ordering::less(),\n        );\n    }\n\n    #[test]\n    fn eq_unit() {\n        assert(().eq(()));\n    }\n\n    #[test]\n    fn eq_bool() {\n        assert(false.eq(false));\n        assert(!(false.eq(true)));\n        assert(!(true.eq(false)));\n        assert(true.eq(true));\n    }\n\n    #[test]\n    fn eq_integers() {\n        comptime {\n            for typ in @[\n                quote { u8 },\n                quote { i8 },\n                quote { u16 },\n                quote { i16 },\n                quote { u32 },\n                quote { i32 },\n                quote { u64 },\n                quote { i64 },\n                quote { u128 },\n                quote { Field },\n            ] {\n                let one = f\"1_{typ}\".quoted_contents();\n                let two = f\"2_{typ}\".quoted_contents();\n                unquote!(\n                    quote {\n                        assert($one.eq($one));\n                        assert(!($one.eq($two)));\n                    },\n                );\n            }\n        }\n    }\n\n    #[test]\n    fn eq_tuples() {\n        comptime {\n            for i in 1..=12 {\n                let mut tuple1 = @[];\n                let mut tuple2 = @[];\n                for _ in 0..i - 1 {\n                    tuple1 = tuple1.push_back(quote { 0 });\n                    tuple2 = tuple2.push_back(quote { 0 });\n                }\n                tuple1 = tuple1.push_back(quote { 0 });\n                tuple2 = tuple2.push_back(quote { 1 });\n                let tuple1 = tuple1.join(quote { , });\n                let tuple2 = tuple2.join(quote { , });\n                let tuple1 = quote { ($tuple1,) };\n                let tuple2 = quote { ($tuple2,) };\n                unquote!(\n                    quote {\n                    assert($tuple1.eq($tuple1));\n                    assert(!($tuple1.eq($tuple2)));\n                },\n                )\n            }\n        }\n    }\n\n    #[test]\n    fn cmp_unit() {\n        assert_eq(().cmp(()), Ordering::equal());\n    }\n\n    #[test]\n    fn cmp_bool() {\n        assert_eq(false.cmp(true), Ordering::less());\n        assert_eq(false.cmp(false), Ordering::equal());\n        assert_eq(true.cmp(true), Ordering::equal());\n        assert_eq(true.cmp(false), Ordering::greater());\n    }\n\n    #[test]\n    fn cmp_integers() {\n        comptime {\n            for typ in @[\n                quote { u8 },\n                quote { i8 },\n                quote { u16 },\n                quote { i16 },\n                quote { u32 },\n                quote { i32 },\n                quote { u64 },\n                quote { i64 },\n                quote { u128 },\n            ] {\n                let one = f\"1_{typ}\".quoted_contents();\n                let two = f\"2_{typ}\".quoted_contents();\n                unquote!(\n                    quote {\n                        assert_eq($one.cmp($two), Ordering::less());\n                        assert_eq($one.cmp($one), Ordering::equal());\n                        assert_eq($two.cmp($one), Ordering::greater());\n                    },\n                );\n            }\n        }\n    }\n\n    #[test]\n    fn cmp_tuples() {\n        comptime {\n            for i in 1..=12 {\n                let mut tuple1 = @[];\n                let mut tuple2 = @[];\n                for _ in 0..i - 1 {\n                    tuple1 = tuple1.push_back(quote { 0_u8 });\n                    tuple2 = tuple2.push_back(quote { 0_u8 });\n                }\n                tuple1 = tuple1.push_back(quote { 0_u8 });\n                tuple2 = tuple2.push_back(quote { 1_u8 });\n                let tuple1 = tuple1.join(quote { , });\n                let tuple2 = tuple2.join(quote { , });\n                let tuple1 = quote { ($tuple1,) };\n                let tuple2 = quote { ($tuple2,) };\n                unquote!(\n                    quote {\n                    assert_eq($tuple1.cmp($tuple1), Ordering::equal());\n                    assert_eq($tuple1.cmp($tuple2), Ordering::less());\n                    assert_eq($tuple2.cmp($tuple1), Ordering::greater());\n                },\n                )\n            }\n        }\n    }\n\n    #[test]\n    fn cmp_array() {\n        assert_eq([1_u8, 2, 3].cmp([1, 2, 3]), Ordering::equal());\n        assert_eq([1_u8, 2, 3].cmp([1, 3, 2]), Ordering::less());\n        assert_eq([1_u8, 3, 3].cmp([1, 2, 3]), Ordering::greater());\n    }\n\n    #[test]\n    fn cmp_vectors() {\n        // Equal lengths\n        assert_eq(@[1_u8, 2, 3].cmp(@[1, 2, 3]), Ordering::equal());\n        assert_eq(@[1_u8, 3, 3].cmp(@[1, 2, 3]), Ordering::greater());\n        assert_eq(@[1_u8, 2, 3].cmp(@[1, 3, 3]), Ordering::less());\n\n        // Different lengths\n        assert_eq(@[1_u8, 2].cmp(@[1, 2, 3]), Ordering::less());\n        assert_eq(@[1_u8, 2, 3].cmp(@[1, 2]), Ordering::greater());\n        assert_eq(@[10_u8, 0].cmp(@[9]), Ordering::greater());\n        assert_eq(@[9_u8, 0].cmp(@[10]), Ordering::less());\n        assert_eq(@[9_u8].cmp(@[10, 0]), Ordering::less());\n        assert_eq(@[10_u8].cmp(@[9, 0]), Ordering::greater());\n    }\n}\n"
     },
     "53": {
       "function_locations": [
@@ -4802,79 +5104,95 @@
       "function_locations": [
         {
           "name": "record_retractable_fact",
-          "start": 2643
+          "start": 2698
         },
         {
           "name": "record_non_retractable_fact",
-          "start": 3279
+          "start": 3331
         },
         {
           "name": "delete_fact_collection",
-          "start": 3916
+          "start": 3965
         },
         {
           "name": "get_fact_collection",
-          "start": 4294
+          "start": 4340
         },
         {
           "name": "get_fact_collections_by_type",
-          "start": 4687
+          "start": 4730
         },
         {
           "name": "test::setup",
-          "start": 5457
+          "start": 5508
         },
         {
           "name": "test::assert_payload",
-          "start": 5649
+          "start": 5720
         },
         {
           "name": "test::record_fact",
-          "start": 5890
+          "start": 5958
         },
         {
           "name": "test::records_and_reads_a_fact",
-          "start": 6179
+          "start": 6247
+        },
+        {
+          "name": "test::records_and_reads_a_public_fact",
+          "start": 7130
+        },
+        {
+          "name": "test::reading_the_public_scope_excludes_account_facts",
+          "start": 8055
+        },
+        {
+          "name": "test::deleting_an_account_collection_keeps_the_public_collection",
+          "start": 8731
         },
         {
           "name": "test::reads_collections_by_type",
-          "start": 7056
+          "start": 9513
         },
         {
           "name": "test::records_a_retractable_fact_finalized_at_latest_block",
-          "start": 7806
+          "start": 10263
         },
         {
           "name": "test::retractable_fact_above_proven_tip_is_pending",
-          "start": 9062
+          "start": 11519
         },
         {
           "name": "test::deletes_a_fact_collection",
-          "start": 9959
+          "start": 12416
         },
         {
           "name": "test::reading_unknown_collection_returns_none",
-          "start": 10465
+          "start": 12922
         },
         {
           "name": "test::cannot_record_for_other_contract",
-          "start": 10874
+          "start": 13331
+        },
+        {
+          "name": "test::cannot_record_for_an_account_outside_the_allowed_scopes",
+          "start": 13700
         },
         {
           "name": "test::re_recording_an_identical_fact_is_a_no_op",
-          "start": 11176
+          "start": 14041
         },
         {
           "name": "test::deleting_a_non_existing_collection_is_a_no_op",
-          "start": 11672
+          "start": 14537
         },
         {
           "name": "test::recording_a_fact_after_delete_recreates_the_collection",
-          "start": 12104
+          "start": 14969
         }
       ],
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/facts/mod.nr",
-      "source": "//! Per-contract storage of immutable facts grouped into collections.\n//!\n//! A fact is a contract-defined, typed, immutable datum. Facts are grouped into collections identified by a\n//! `(collection type, collection id)` tuple.\n//!\n//! They are stored in PXE's FactStore, which automatically deals with reorgs by removing any facts\n//! associated with blocks that have been pruned.\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::block_reference::BlockReference;\nuse crate::oracle::fact_store::{\n    delete_fact_collection_oracle, get_fact_collection_oracle, get_fact_collections_by_type_oracle, record_fact_oracle,\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\nmod origin_state;\npub use origin_state::OriginBlockState;\n\n/// A retractable fact's origin block.\n#[derive(Deserialize, Eq, Serialize)]\npub struct RetractableFactOrigin {\n    pub block_number: u32,\n    pub block_hash: Field,\n    pub block_state: OriginBlockState,\n}\n\n/// A single immutable fact in a collection.\n#[derive(Deserialize, Serialize)]\npub struct Fact {\n    /// A user-defined identifier for fact kinds. Typically used to determine how to deserialize `payload`.\n    pub fact_type_id: Field,\n    pub payload: EphemeralArray<Field>,\n    /// The block the fact is associated to, if any. A fact with an origin block is said to be a 'retractable' fact,\n    /// and will be automatically deleted if its origin block gets pruned in a reorg. Typically used by facts\n    /// associated with a transaction (e.g. 'processed entry X using data from tx Y in block Z').\n    pub origin_block: Option<RetractableFactOrigin>,\n}\n\n/// A fact collection as returned by the store.\n#[derive(Deserialize, Serialize)]\npub struct FactCollection {\n    pub contract_address: AztecAddress,\n    pub scope: AztecAddress,\n    /// The collection's type. A single contract may have facts in collections of different types (e.g. one for the\n    /// processing offchain messages, another for partial notes, etc.).\n    pub fact_collection_type_id: Field,\n    /// The collection's unique identifier among the other collections of this type in this contract and scope.\n    pub fact_collection_id: Field,\n    pub facts: EphemeralArray<Fact>,\n}\n\n/// Records a retractable fact into a collection: PXE prunes it if `origin_block` is reorg'd away. Re-recording an\n/// identical fact is a no-op.\npub unconstrained fn record_retractable_fact(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n    origin_block: BlockReference,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::some(origin_block),\n    );\n}\n\n/// Records a non-retractable fact into a collection: it survives reorgs and will persist until the fact collection\n/// itself is deleted. Re-recording an identical fact is a no-op.\npub unconstrained fn record_non_retractable_fact(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::none(),\n    );\n}\n\n/// Deletes a fact collection, removing all its facts from PXE storage.\n///\n/// Collections must be eventually deleted to reclaim storage and to stop reprocessing past the lifespan of the\n/// workflows they enable.\n///\n/// A no-op if no such collection exists.\npub unconstrained fn delete_fact_collection(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) {\n    delete_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    );\n}\n\n/// Fetches a fact collection.\npub unconstrained fn get_fact_collection(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) -> Option<FactCollection> {\n    get_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    )\n}\n\n/// Returns every fact collection of `fact_collection_type_id`.\npub unconstrained fn get_fact_collections_by_type(\n    contract_address: AztecAddress,\n    scope: AztecAddress,\n    fact_collection_type_id: Field,\n) -> EphemeralArray<FactCollection> {\n    get_fact_collections_by_type_oracle(contract_address, scope, fact_collection_type_id)\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::facts::{\n        delete_fact_collection, get_fact_collection, get_fact_collections_by_type, record_non_retractable_fact,\n        record_retractable_fact,\n    };\n    use crate::oracle::block_reference::BlockReference;\n    use crate::protocol::address::AztecAddress;\n    use crate::protocol::traits::{FromField, ToField};\n    use crate::test::helpers::test_environment::TestEnvironment;\n\n    global TYPE_ID: Field = 42;\n    global COLLECTION_ID: Field = 7;\n    global FACT_TYPE_ID: Field = 99;\n    global PAYLOAD: [Field; 3] = [123, 456, 789];\n\n    unconstrained fn setup() -> (TestEnvironment, AztecAddress) {\n        let mut env = TestEnvironment::new();\n        let scope = env.create_light_account();\n        (env, scope)\n    }\n\n    unconstrained fn assert_payload(payload: EphemeralArray<Field>) {\n        assert_eq(payload.len(), PAYLOAD.len());\n        for i in 0..PAYLOAD.len() {\n            assert_eq(payload.get(i), PAYLOAD[i]);\n        }\n    }\n\n    unconstrained fn record_fact(contract_address: AztecAddress, scope: AztecAddress) {\n        record_non_retractable_fact(\n            contract_address,\n            scope,\n            TYPE_ID,\n            COLLECTION_ID,\n            FACT_TYPE_ID,\n            EphemeralArray::from_array(PAYLOAD),\n        );\n    }\n\n    #[test]\n    unconstrained fn records_and_reads_a_fact() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.contract_address, contract_address);\n            assert_eq(collection.scope, scope);\n            assert_eq(collection.fact_collection_type_id, TYPE_ID);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n            assert(fact.origin_block.is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn reads_collections_by_type() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 1);\n\n            let collection = collections.get(0);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n        });\n    }\n\n    #[test]\n    unconstrained fn records_a_retractable_fact_finalized_at_latest_block() {\n        let (env, scope) = setup();\n        let origin_block_number = env.last_block_number();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_retractable_fact(\n                contract_address,\n                scope,\n                TYPE_ID,\n                COLLECTION_ID,\n                FACT_TYPE_ID,\n                EphemeralArray::from_array(PAYLOAD),\n                BlockReference { block_number: origin_block_number, block_hash: 0xabc },\n            );\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n\n            let origin = fact.origin_block.unwrap();\n            assert_eq(origin.block_number, origin_block_number);\n            assert_eq(origin.block_hash, 0xabc);\n            // TXE finalizes every mined block, so an origin at the latest block is Finalized.\n            assert(origin.block_state.is_finalized());\n        });\n    }\n\n    #[test]\n    unconstrained fn retractable_fact_above_proven_tip_is_pending() {\n        let (env, scope) = setup();\n        let future_block_number = env.last_block_number() + 100;\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_retractable_fact(\n                contract_address,\n                scope,\n                TYPE_ID,\n                COLLECTION_ID,\n                FACT_TYPE_ID,\n                EphemeralArray::from_array(PAYLOAD),\n                BlockReference { block_number: future_block_number, block_hash: 0xabc },\n            );\n\n            let origin = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID)\n                .unwrap()\n                .facts\n                .get(0)\n                .origin_block\n                .unwrap();\n            assert(origin.block_state.is_pending());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_a_fact_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn reading_unknown_collection_returns_none() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(collection.is_none());\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_record_for_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let other = AztecAddress::from_field(context.this_address().to_field() + 1);\n            record_fact(other, scope);\n        });\n    }\n\n    #[test]\n    unconstrained fn re_recording_an_identical_fact_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn deleting_a_non_existing_collection_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn recording_a_fact_after_delete_recreates_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            record_fact(contract_address, scope);\n            let collection_before_delete =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_before_delete.facts.len(), 1);\n\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n\n            record_fact(contract_address, scope);\n            let collection_after_recreate =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_after_recreate.facts.len(), 1);\n        });\n    }\n}\n"
+      "source": "//! Per-contract storage of immutable facts grouped into collections.\n//!\n//! A fact is a contract-defined, typed, immutable datum. Facts are grouped into collections identified by a\n//! `(collection type, collection id)` tuple, within a [`FactScope`].\n//!\n//! They are stored in PXE's FactStore, which automatically deals with reorgs by removing any facts\n//! associated with blocks that have been pruned.\nuse crate::ephemeral::EphemeralArray;\nuse crate::oracle::block_reference::BlockReference;\nuse crate::oracle::fact_store::{\n    delete_fact_collection_oracle, get_fact_collection_oracle, get_fact_collections_by_type_oracle, record_fact_oracle,\n};\nuse crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\nmod origin_state;\nmod scope;\npub use origin_state::OriginBlockState;\npub use scope::FactScope;\n\n/// A retractable fact's origin block.\n#[derive(Deserialize, Eq, Serialize)]\npub struct RetractableFactOrigin {\n    pub block_number: u32,\n    pub block_hash: Field,\n    pub block_state: OriginBlockState,\n}\n\n/// A single immutable fact in a collection.\n#[derive(Deserialize, Serialize)]\npub struct Fact {\n    /// A user-defined identifier for fact kinds. Typically used to determine how to deserialize `payload`.\n    pub fact_type_id: Field,\n    pub payload: EphemeralArray<Field>,\n    /// The block the fact is associated to, if any. A fact with an origin block is said to be a 'retractable' fact,\n    /// and will be automatically deleted if its origin block gets pruned in a reorg. Typically used by facts\n    /// associated with a transaction (e.g. 'processed entry X using data from tx Y in block Z').\n    pub origin_block: Option<RetractableFactOrigin>,\n}\n\n/// A fact collection as returned by the store.\n#[derive(Deserialize, Serialize)]\npub struct FactCollection {\n    pub contract_address: AztecAddress,\n    pub scope: FactScope,\n    /// The collection's type. A single contract may have facts in collections of different types (e.g. one for the\n    /// processing offchain messages, another for partial notes, etc.).\n    pub fact_collection_type_id: Field,\n    /// The collection's unique identifier among the other collections of this type in this contract and scope.\n    pub fact_collection_id: Field,\n    pub facts: EphemeralArray<Fact>,\n}\n\n/// Records a retractable fact into a collection: PXE prunes it if `origin_block` is reorg'd away. Re-recording an\n/// identical fact is a no-op.\npub unconstrained fn record_retractable_fact(\n    contract_address: AztecAddress,\n    scope: FactScope,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n    origin_block: BlockReference,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::some(origin_block),\n    );\n}\n\n/// Records a non-retractable fact into a collection: it survives reorgs and will persist until the fact collection\n/// itself is deleted. Re-recording an identical fact is a no-op.\npub unconstrained fn record_non_retractable_fact(\n    contract_address: AztecAddress,\n    scope: FactScope,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n    fact_type_id: Field,\n    payload: EphemeralArray<Field>,\n) {\n    record_fact_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n        fact_type_id,\n        payload,\n        Option::none(),\n    );\n}\n\n/// Deletes a fact collection, removing all its facts from PXE storage.\n///\n/// Collections must be eventually deleted to reclaim storage and to stop reprocessing past the lifespan of the\n/// workflows they enable.\n///\n/// A no-op if no such collection exists.\npub unconstrained fn delete_fact_collection(\n    contract_address: AztecAddress,\n    scope: FactScope,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) {\n    delete_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    );\n}\n\n/// Fetches a fact collection.\npub unconstrained fn get_fact_collection(\n    contract_address: AztecAddress,\n    scope: FactScope,\n    fact_collection_type_id: Field,\n    fact_collection_id: Field,\n) -> Option<FactCollection> {\n    get_fact_collection_oracle(\n        contract_address,\n        scope,\n        fact_collection_type_id,\n        fact_collection_id,\n    )\n}\n\n/// Returns every fact collection of `fact_collection_type_id`.\npub unconstrained fn get_fact_collections_by_type(\n    contract_address: AztecAddress,\n    scope: FactScope,\n    fact_collection_type_id: Field,\n) -> EphemeralArray<FactCollection> {\n    get_fact_collections_by_type_oracle(contract_address, scope, fact_collection_type_id)\n}\n\nmod test {\n    use crate::ephemeral::EphemeralArray;\n    use crate::facts::{\n        delete_fact_collection, FactScope, get_fact_collection, get_fact_collections_by_type,\n        record_non_retractable_fact, record_retractable_fact,\n    };\n    use crate::oracle::block_reference::BlockReference;\n    use crate::protocol::address::AztecAddress;\n    use crate::protocol::traits::{FromField, ToField};\n    use crate::test::helpers::test_environment::TestEnvironment;\n\n    global TYPE_ID: Field = 42;\n    global COLLECTION_ID: Field = 7;\n    global FACT_TYPE_ID: Field = 99;\n    global PAYLOAD: [Field; 3] = [123, 456, 789];\n\n    unconstrained fn setup() -> (TestEnvironment, FactScope) {\n        let mut env = TestEnvironment::new();\n        let scope = FactScope::account(env.create_light_account());\n        (env, scope)\n    }\n\n    unconstrained fn assert_payload(payload: EphemeralArray<Field>) {\n        assert_eq(payload.len(), PAYLOAD.len());\n        for i in 0..PAYLOAD.len() {\n            assert_eq(payload.get(i), PAYLOAD[i]);\n        }\n    }\n\n    unconstrained fn record_fact(contract_address: AztecAddress, scope: FactScope) {\n        record_non_retractable_fact(\n            contract_address,\n            scope,\n            TYPE_ID,\n            COLLECTION_ID,\n            FACT_TYPE_ID,\n            EphemeralArray::from_array(PAYLOAD),\n        );\n    }\n\n    #[test]\n    unconstrained fn records_and_reads_a_fact() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.contract_address, contract_address);\n            assert_eq(collection.scope, scope);\n            assert_eq(collection.fact_collection_type_id, TYPE_ID);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n            assert(fact.origin_block.is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn records_and_reads_a_public_fact() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, FactScope::public());\n\n            let collection = get_fact_collection(\n                contract_address,\n                FactScope::public(),\n                TYPE_ID,\n                COLLECTION_ID,\n            )\n                .unwrap();\n            assert_eq(collection.scope, FactScope::public());\n            assert_eq(collection.facts.len(), 1);\n            assert_payload(collection.facts.get(0).payload);\n\n            let collections = get_fact_collections_by_type(contract_address, FactScope::public(), TYPE_ID);\n            assert_eq(collections.len(), 1);\n            assert_eq(collections.get(0).scope, FactScope::public());\n        });\n    }\n\n    #[test]\n    unconstrained fn reading_the_public_scope_excludes_account_facts() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            assert(\n                get_fact_collection(\n                    contract_address,\n                    FactScope::public(),\n                    TYPE_ID,\n                    COLLECTION_ID,\n                )\n                    .is_none(),\n            );\n            assert_eq(get_fact_collections_by_type(contract_address, FactScope::public(), TYPE_ID).len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn deleting_an_account_collection_keeps_the_public_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            record_fact(contract_address, FactScope::public());\n\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n            assert(\n                get_fact_collection(\n                    contract_address,\n                    FactScope::public(),\n                    TYPE_ID,\n                    COLLECTION_ID,\n                )\n                    .is_some(),\n            );\n        });\n    }\n\n    #[test]\n    unconstrained fn reads_collections_by_type() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 1);\n\n            let collection = collections.get(0);\n            assert_eq(collection.fact_collection_id, COLLECTION_ID);\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n        });\n    }\n\n    #[test]\n    unconstrained fn records_a_retractable_fact_finalized_at_latest_block() {\n        let (env, scope) = setup();\n        let origin_block_number = env.last_block_number();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_retractable_fact(\n                contract_address,\n                scope,\n                TYPE_ID,\n                COLLECTION_ID,\n                FACT_TYPE_ID,\n                EphemeralArray::from_array(PAYLOAD),\n                BlockReference { block_number: origin_block_number, block_hash: 0xabc },\n            );\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n\n            let fact = collection.facts.get(0);\n            assert_eq(fact.fact_type_id, FACT_TYPE_ID);\n            assert_payload(fact.payload);\n\n            let origin = fact.origin_block.unwrap();\n            assert_eq(origin.block_number, origin_block_number);\n            assert_eq(origin.block_hash, 0xabc);\n            // TXE finalizes every mined block, so an origin at the latest block is Finalized.\n            assert(origin.block_state.is_finalized());\n        });\n    }\n\n    #[test]\n    unconstrained fn retractable_fact_above_proven_tip_is_pending() {\n        let (env, scope) = setup();\n        let future_block_number = env.last_block_number() + 100;\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_retractable_fact(\n                contract_address,\n                scope,\n                TYPE_ID,\n                COLLECTION_ID,\n                FACT_TYPE_ID,\n                EphemeralArray::from_array(PAYLOAD),\n                BlockReference { block_number: future_block_number, block_hash: 0xabc },\n            );\n\n            let origin = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID)\n                .unwrap()\n                .facts\n                .get(0)\n                .origin_block\n                .unwrap();\n            assert(origin.block_state.is_pending());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_a_fact_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            let collections = get_fact_collections_by_type(contract_address, scope, TYPE_ID);\n            assert_eq(collections.len(), 0);\n        });\n    }\n\n    #[test]\n    unconstrained fn reading_unknown_collection_returns_none() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(collection.is_none());\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_record_for_other_contract() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let other = AztecAddress::from_field(context.this_address().to_field() + 1);\n            record_fact(other, scope);\n        });\n    }\n\n    #[test(should_fail_with = \"not in the allowed scopes list\")]\n    unconstrained fn cannot_record_for_an_account_outside_the_allowed_scopes() {\n        let (env, _) = setup();\n        env.private_context(|context| {\n            let outsider = AztecAddress::from_field(context.this_address().to_field() + 1);\n            record_fact(context.this_address(), FactScope::account(outsider));\n        });\n    }\n\n    #[test]\n    unconstrained fn re_recording_an_identical_fact_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            record_fact(contract_address, scope);\n            record_fact(contract_address, scope);\n\n            let collection = get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection.facts.len(), 1);\n        });\n    }\n\n    #[test]\n    unconstrained fn deleting_a_non_existing_collection_is_a_no_op() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n        });\n    }\n\n    #[test]\n    unconstrained fn recording_a_fact_after_delete_recreates_the_collection() {\n        let (env, scope) = setup();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            record_fact(contract_address, scope);\n            let collection_before_delete =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_before_delete.facts.len(), 1);\n\n            delete_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID);\n            assert(get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).is_none());\n\n            record_fact(contract_address, scope);\n            let collection_after_recreate =\n                get_fact_collection(contract_address, scope, TYPE_ID, COLLECTION_ID).unwrap();\n            assert_eq(collection_after_recreate.facts.len(), 1);\n        });\n    }\n}\n"
     },
     "86": {
       "function_locations": [
@@ -4939,6 +5257,56 @@
       "source": "use crate::protocol::{traits::{Deserialize, Serialize}, utils::reader::Reader};\n\n/// Chain state of a retractable fact's origin block, mirroring the L2 chain tips.\n#[derive(Serialize)]\npub struct OriginBlockState {\n    // Noir has no enums, so this wraps a `u8` discriminant. The discriminant values must stay in sync with the\n    // TypeScript `OriginBlockState` enum in `yarn-project/pxe/src/storage/fact_store/origin_state.ts`, which PXE\n    // serializes into the `Fact` oracle response that `from_u8` below deserializes.\n    inner: u8,\n}\n\nimpl OriginBlockState {\n    pub fn pending() -> Self {\n        Self { inner: 1 }\n    }\n\n    pub fn proven() -> Self {\n        Self { inner: 2 }\n    }\n\n    pub fn finalized() -> Self {\n        Self { inner: 3 }\n    }\n\n    /// Whether the origin block is still above the proven tip.\n    pub fn is_pending(self) -> bool {\n        self == Self::pending()\n    }\n\n    /// Whether the origin block is proven but not yet finalized.\n    pub fn is_proven(self) -> bool {\n        self == Self::proven()\n    }\n\n    /// Whether the origin block is finalized, and thus facts related to it can no longer be retracted.\n    pub fn is_finalized(self) -> bool {\n        self == Self::finalized()\n    }\n\n    fn from_u8(inner: u8) -> Self {\n        let state = Self { inner };\n        assert(state.is_valid(), \"unrecognized origin state\");\n        state\n    }\n\n    fn is_valid(self) -> bool {\n        self.is_pending() | self.is_proven() | self.is_finalized()\n    }\n}\n\nimpl Eq for OriginBlockState {\n    fn eq(self, other: Self) -> bool {\n        self.inner == other.inner\n    }\n}\n\nimpl Deserialize for OriginBlockState {\n    let N: u32 = <u8 as Deserialize>::N;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self::from_u8(<u8 as Deserialize>::deserialize(fields))\n    }\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self::from_u8(reader.read() as u8)\n    }\n}\n\nmod test {\n    use crate::protocol::traits::{Deserialize, Serialize};\n    use super::OriginBlockState;\n\n    #[test]\n    fn query_functions_identify_each_state() {\n        assert(OriginBlockState::pending().is_pending());\n        assert(!OriginBlockState::pending().is_proven());\n        assert(!OriginBlockState::pending().is_finalized());\n\n        assert(OriginBlockState::proven().is_proven());\n        assert(!OriginBlockState::proven().is_pending());\n        assert(!OriginBlockState::proven().is_finalized());\n\n        assert(OriginBlockState::finalized().is_finalized());\n        assert(!OriginBlockState::finalized().is_pending());\n        assert(!OriginBlockState::finalized().is_proven());\n    }\n\n    #[test]\n    fn origin_state_roundtrips_through_serialization() {\n        let pending = OriginBlockState::pending();\n        let proven = OriginBlockState::proven();\n        let finalized = OriginBlockState::finalized();\n        assert(OriginBlockState::deserialize(pending.serialize()) == pending);\n        assert(OriginBlockState::deserialize(proven.serialize()) == proven);\n        assert(OriginBlockState::deserialize(finalized.serialize()) == finalized);\n    }\n\n    #[test(should_fail_with = \"unrecognized origin state\")]\n    fn deserializing_invalid_state_fails() {\n        let _ = OriginBlockState::deserialize([99]);\n    }\n}\n"
     },
     "87": {
+      "function_locations": [
+        {
+          "name": "FactScope::account",
+          "start": 813
+        },
+        {
+          "name": "FactScope::public",
+          "start": 932
+        },
+        {
+          "name": "FactScope::from_parts",
+          "start": 1142
+        },
+        {
+          "name": "<impl Deserialize for FactScope>::deserialize",
+          "start": 1593
+        },
+        {
+          "name": "<impl Deserialize for FactScope>::stream_deserialize",
+          "start": 1748
+        },
+        {
+          "name": "test::scopes_roundtrip_through_serialization",
+          "start": 2113
+        },
+        {
+          "name": "test::serializes_to_the_pxe_wire_layout",
+          "start": 2470
+        },
+        {
+          "name": "test::deserializing_invalid_kind_fails",
+          "start": 2734
+        },
+        {
+          "name": "test::deserializing_kind_that_overflows_u8_fails",
+          "start": 2907
+        },
+        {
+          "name": "test::stream_deserializing_kind_that_overflows_u8_fails",
+          "start": 3088
+        },
+        {
+          "name": "test::deserializing_public_scope_with_account_fails",
+          "start": 3337
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/facts/scope.nr",
+      "source": "use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}, utils::reader::Reader};\n\n// PXE decodes these discriminants, so their values are part of the oracle interface.\nglobal ACCOUNT: u8 = 1;\nglobal PUBLIC: u8 = 2;\n\n/// The scope a fact collection belongs to.\n///\n/// A collection under an account scope is only accessible to executions where that account is in scope. A collection\n/// under the public scope is shared by all accounts, so any execution of the contract can access it.\n#[derive(Eq, Serialize)]\npub struct FactScope {\n    // Noir has no enums, so this wraps a discriminant plus the account it names, zero for the public scope.\n    kind: u8,\n    account: AztecAddress,\n}\n\nimpl FactScope {\n    /// The scope of a single account.\n    pub fn account(account: AztecAddress) -> Self {\n        Self { kind: ACCOUNT, account }\n    }\n\n    /// The scope shared by all accounts.\n    pub fn public() -> Self {\n        Self { kind: PUBLIC, account: AztecAddress::zero() }\n    }\n\n    /// Validates raw parts, as deserialization must reject malformed values.\n    fn from_parts(kind: Field, account: AztecAddress) -> Self {\n        assert((kind == ACCOUNT as Field) | (kind == PUBLIC as Field), f\"unrecognized fact scope kind: {kind}\");\n        assert(\n            (kind == ACCOUNT as Field) | (account == AztecAddress::zero()),\n            f\"public fact scope must not name an account, got {account}\",\n        );\n        Self { kind: kind as u8, account }\n    }\n}\n\nimpl Deserialize for FactScope {\n    let N: u32 = 2;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self::from_parts(fields[0], AztecAddress::deserialize([fields[1]]))\n    }\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let kind = reader.read();\n        let account = AztecAddress::stream_deserialize(reader);\n        Self::from_parts(kind, account)\n    }\n}\n\nmod test {\n    use crate::protocol::{address::AztecAddress, traits::{Deserialize, FromField, Serialize}, utils::reader::Reader};\n    use super::FactScope;\n\n    #[test]\n    fn scopes_roundtrip_through_serialization() {\n        let account_scope = FactScope::account(AztecAddress::from_field(42));\n        let public_scope = FactScope::public();\n\n        assert(FactScope::deserialize(account_scope.serialize()) == account_scope);\n        assert(FactScope::deserialize(public_scope.serialize()) == public_scope);\n    }\n\n    #[test]\n    fn serializes_to_the_pxe_wire_layout() {\n        assert_eq(FactScope::account(AztecAddress::from_field(42)).serialize(), [1, 42]);\n        assert_eq(FactScope::public().serialize(), [2, 0]);\n    }\n\n    #[test(should_fail_with = \"unrecognized fact scope kind\")]\n    fn deserializing_invalid_kind_fails() {\n        let _ = FactScope::deserialize([99, 0]);\n    }\n\n    #[test(should_fail_with = \"unrecognized fact scope kind\")]\n    fn deserializing_kind_that_overflows_u8_fails() {\n        let _ = FactScope::deserialize([257, 0]);\n    }\n\n    #[test(should_fail_with = \"unrecognized fact scope kind\")]\n    fn stream_deserializing_kind_that_overflows_u8_fails() {\n        let mut reader = Reader::new([257, 0]);\n        let _ = FactScope::stream_deserialize(&mut reader);\n    }\n\n    #[test(should_fail_with = \"public fact scope must not name an account\")]\n    fn deserializing_public_scope_with_account_fails() {\n        let _ = FactScope::deserialize([2, 42]);\n    }\n}\n"
+    },
+    "88": {
       "function_locations": [
         {
           "name": "compute_secret_hash",
@@ -4984,7 +5352,7 @@
       "path": "/home/aztec-dev/aztec-node/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE, DOM_SEP__PUBLIC_CALLDATA,\n        DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash<let N: u32>(secret: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(secret, DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of an l1 to l2 message is the hash of the message salted with the secret.\npub fn compute_l1_to_l2_message_nullifier<let N: u32>(message_hash: Field, secret: [Field; N]) -> Field {\n    poseidon2_hash_with_separator([message_hash].concat(secret), DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the prepended field.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n\n#[test]\nunconstrained fn secret_hash_matches_typescript() {\n    let secret = 8;\n    let hash = compute_secret_hash([secret]);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let secret_hash_from_ts = 0x1848b066724ab0ffb50ecb0ee3398eb839f162823d262bad959721a9c13d1e96;\n\n    assert_eq(hash, secret_hash_from_ts);\n}\n\n#[test]\nunconstrained fn var_args_hash_matches_typescript() {\n    let mut input = [0; 100];\n    for i in 0..100 {\n        input[i] = i as Field;\n    }\n    let hash = hash_args(input);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let var_args_hash_from_ts = 0x262e5e121a8efc0382566ab42f0ae2a78bd85db88484f83018fe07fc2552ba0c;\n\n    assert_eq(hash, var_args_hash_from_ts);\n}\n\n#[test]\nunconstrained fn compute_calldata_hash() {\n    let mut input = [0; 100];\n    for i in 0..input.len() {\n        input[i] = i as Field;\n    }\n    let hash = hash_calldata_array(input);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let calldata_hash_from_ts = 0x14a1539bdb1d26e03097cf4d40c87e02ca03f0bb50a3e617ace5a7bfd3943944;\n\n    // Used in cpp vm2 tests:\n    assert_eq(hash, calldata_hash_from_ts);\n}\n\n#[test]\nunconstrained fn public_bytecode_commitment() {\n    let mut input = [0; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS];\n    let len = 99;\n    for i in 1..len + 1 {\n        input[i] = i as Field;\n    }\n    input[0] = (len as Field) * 31;\n    let hash = compute_public_bytecode_commitment(input);\n    // Used in cpp vm2 tests:\n    assert_eq(hash, 0x09348974e76c3602893d7a4b4bb52c2ec746f1ade5004ac471d0fbb4587a81a6);\n}\n"
     },
-    "98": {
+    "99": {
       "function_locations": [
         {
           "name": "derive_ecdh_shared_secret",
@@ -6839,11 +7207,11 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "constructor",
       "verification_key": "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"
@@ -8759,11 +9127,11 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+3dBZwV9fc3cGbmNiB2oqLYYoEoYtJgIhiYSCyhlEtIGKDYtSxgt4Ld3d33iJ3Y3d3BcxZ/v93lu3O8Z4Y9/ub+n8/n9Xv9n/t8nf2eOTNz575vzBBUzzjjtVb9+w+YPK5iUP9Rlf2HjxpXUTlqwIix/ftXjBpXOWnMaB6Z33SVaTd0HjFg0CGdR0/sPn7UoC4DRoyYNqdPp117dKuedvnew8eNqhg71m+lWCjwFAstrZlp2R0UC61QnKpYakXVUqtq1mo1zUKraxZqpVloDdWar6laqrVqqbVUS62tWfn1NAttoDlgNtQs1Eaz0MaaddpUM9NmmoXaahbaXLNOW2hm2lKzUAfNQh0167SNZqZtNQttp1loB806ddbM1EWzUFfNQt1zioV6eNOu7lw5fMSI4UNr/vusJlVVM6uqHmnV5J/jTbuq09ixFZXj9q2oHD2zakb1I602Hbxr5bubXbT+Hb273TZtWr8D1mv3Sc9Jd46Z0eXdH2d+w39CQYlpX9ro/UPiTDtDnHbN/z4I2RC39B49tmL44NGj2vauqBw5ftyAccNHj6qeVbtheHVrH69bd96o999nzKKgmoKZFPCD2Yuu+czq0ptwfcUyXEG1Dc4oOVWT6Cu4gWoFZ6pW8EyLFdxQtYKzVCt4lmIF4xxFZ9R7fGa9x2fVezybD6CzKTiHgnMpOC/6dmij2g5nq7bD+RY7aiPVCp6jWsELLFZwY9UKnqtawQuNjqTz6z2+oN7jC+s9Po+PpIsouJiCSyi4NPp22ES1HS5SbYfLLHbUpqoVvFi1gnMsVnAz1QpeolrBuUZH0mX1Hs+p93huvceX8pF0OQVXUHAlBVdF3w5tVdvhctV2uNpiR7VTreAVqhW8xmIFN1et4JWqFbzW6Ei6ut7ja+o9vrbe46v4SLqOguspuIGCG6Nvh/aq7XCdajvcZLGjtlCt4PWqFbzZYgW3VK3gDaoVvMXoSLqp3uOb6z2+pd7jG/lIupWC2yi4nYI7om+HDqrtcKtqO9xpsaO2Uq3gbaoVvMtiBTuqVvB21QrebXQk3Vnv8V31Ht9d7/EdfCTdQ8G9FNxHwf3Rt8PWqu1wj2o7PGCxo7ZRreC9qhV80GIFt1Wt4H2qFXzI6Eh6oN7jB+s9fqje4/v5SHqYgkcoeJSCx6Jvh+1U2+Fh1XZ43GJHba9awUdUK/iExQruoFrBR1Ur+KTRkfR4vcdP1Hv8ZL3Hj/GR9BQFT1NQpICib4dOqu3wlGo7PGOxozqrVvBp1QrOs1jBLqoVLKpW8FmjI+mZeo/n1Xv8bL3HxEfScxQ8T8ELFLwYfTt0VW2H51Tb4SWLHdVNtYLPq1bwZYsV7K5awRdUK/iK0ZH0Ur3HL9d7/Eq9xy/ykfQqBa9R8DoFb0TfDj1U2+FV1XaYb7Qd5td7/Fq9x6/Xe/wGb4c3KXiLgrcpeGfR7VCt6HFtVYfvKr53Kf2VDs/TKvoaLqtaw/dKTOTtPlW1hu/tsOjXTrkZ0+b2HT5q6IiKv7/1KbW23Uuv7MIZR44ZUUHB+9G/0poxU7ESPLPu65n3VU+DD0pPFWcdP9B9jfaB4um1yD7zIu4zzfFdf699qJ32g1gnhoYH5Yfe4h2UURv8yOaw5NXguXUr/LHBIbew/sdVEV9Wa2ZWHKS8l6p1B4XqoP8k6ou/7vn+sWqpT012/ic8se4Z/1mMXVS6fs0u0tX/3Kx+VdRzmT+z7qle+o+z0+Z0qqwcMGl+k9aaxffTLDRAs9BkzULjNAup+hykWWgjzUKjNAtVahY6QLNQK81CfRttO41rtIWGN9rGHNpo22mKZqFNNQsd0WjrpHq2jG20ckMa7VCpaLR1GtNo22lSo6145X9OjDN0YPJKn6arGhOBsSTzQWN644tGouoXreK9Mn7RmM182UjNfNlq0RfjIOaLcXe8GJfti3G3RlvxweX6Oju20Q4V1UE3vtFeZNo02iYY+e/uu+GNtk7jG22mVo325FQdKhMa77X/30XwQM1CI/5dko1ttO4G/7srrpppSKMt1Hivd+MabROoyo1utHPBqEbrrvGenK0a7fBtvHdejfjmM9p7E5XVG/XdySIGTkX+7PnfXt1Yb6Y+030y+FXUzdXI3x99vWDBgnof1H9t9v3R16U+T65Zk5rFNNv3G5vvj76ZoVrHb6Lus3rfH1VrP/x/V/tG90uLL2y+1T5/NNtC887425jf/nyue5p9Z/00U5Wot4G/t/pG7DueW7fCP5h8I8b1f4j8pUS+unZrz2z8J4hqxs95xsZ4JnkLu1N+qrNw4eq6o+LHuoc/6Q4QzXPrR91iP7WK8TXlu9pv3QtzTF5p/3sCLF3/8hj1Vf1/Plt32PzzWlZ/s3CpH1Wns580FQtzVEtdrjico++Xb/iUrjs1/2xyXPxQsylV9XVb/BeTk/XPPLFuK/0acStVzWqMg/I/xX/71w63ho3onoY1G1L3gf/Pqo5/t3pboPTKH4vxCqo+cX6lW5ff7F7v/qx7+Ffjvd79qVvsr5jfLH01U/2kKX2+/1M1118xztGlZ605R+ueNN+o1nJB1HOU7gSt2kSpJiYn6AU8sepZkvJMmk95qqV8k+bVp4hUELH5alX9X/lJpFrwdz5h6lY0ZXJer3ki4YdYpRbCd7/4IRZ+iNUEP8Rq8n/kh1jfmLzq/cYv+poFUz6/7upe9dLWn36uH+Wzz1TG5rPP9Xlm1Y5LZQ0++eTq2aqIB0SVTt+/qXZyLsYmLTXrBtyUZh03UK1h3gJfqRxPrHsaFBrnu4pUwfkVXzris2XdxjsHxdqmpbbUhjxtta66ars3NdjvNUem5n247sjMqpZqZnDS4m3dLPJbh8zsRj89R5twvcaecN3GnrDUx1aLTql5VrQJNM+JQLFMm9JrVvcZWap53cMltGeFZo10pmse4yOyVDP+O93po5nqadeikZppEf37raDNzMba56pWlzQQJW/npsqTvu5ldCmbT7p05+ClI56DVeZO5flFXXtst9BtpWWszb1JJHMva2PuTXhm3SlpOQNzc/Xlopp7hvZNWFb3tfJNJqhdmg8gXf2boz4bVd9epJZXfZl3k2qpm2MceKXWcFPe9ZoXmU1V3a5gshOX54l1J4sVG+klbsXFfGeyUSO+M4mzTUttqc14Wh0tVlBt95WinqTrfc3aOG/QFixY8E7Mb09TK9c9XKXRvj1NraxbbJVW0e+RU/IN499fiqZWVu28VRRbNvKXoqkVuLzFa0rNCUtz6tWdsJZTLdXS4BWfn4Itzd+wKmwTbcKNG3vCjSJMqDNoVvlt50IbVEUorznu2zbam9u2kd7crlr3cDXtGbWlonfNGWzVVot7bm9W8gz0S9xz++p1D1s13rl9dd1irWKd25upzu2rq85crRRbNvq5vSWXtzi31zSvg94aBtXXV1df06D6eurqrU2Qze/Il9TVX8ug/rrq7te26n4JXf11rN4nK/tf16r/5rr660Wsr/snmVKaj9av2qVi5OjKSb1GDR83s8n8JjvwaYCfi/yE4GOSDwzeN7x5eA15trL439y/+4m6u3ILd1dL3XbdQLFdr/h7PXYbU91k5kP8J5TaMM6noy21rx0b6t56bqhqsE3EBh9e2GCbmBtdt+YtVWu+UfRdsxGlNo68azaJsGs21jW4sarBTaLvGm5wE7td42t3zabRdw2/L90s8q7ZOMKu2Uy3azZTNdg2+q7hBtva7ZpAu2vaRd817Si1efSvrNo21ldWbVV9tY/xlZXquNlcBQBesL3uANtc1c4W0Q8w3k1b2B1gKe0BtmX0A2xLSnWI/NzfKMJzv4Nu13RQNbhV9F3DDW5lt2vS2l3TMfqu6UiprWN8kdmy5nMU5c7ZWrdztla1uE30ncMtbmO3czLanbNt9J2zLaW2i/OlmuofGGm0L9Vinne30x5o2+uOn+1Um2aH6McP74Ud7I6frPb46RT9+OlEqc7xntyravdiZ93O6axqsUv0ncMtdonxfr6mxcZ8r9K1kT4r7trK3Yf8RrhbnA8Muis+ynVKdadUjzilepZ+Y+GW6kmpXnFK7Vgaym6pHSm1U5xSO5cmk1tqZ0rtEqfUrqUJ4JbalVK7xSnVu/QLmluqN6V2j1OqT+lzn1uqD6X6xim1R+kTsltqD0rtGafUXiVL5d1Se1Fq7zil+pUsVXBL9aPUPnFK7VuyVFO31L6U2i9Oqf1LlmrmltqfUgfEKXVgyVLN3VIHUqp/nFIHlSy1hFvqIEoNiFNqYMlSLdxSAyk1KE6pwSVLLemWGkypijilhpQstZRbagilhsYpNaxkqaXdUsMoNTxOqYNLllrGLXUwpQ6JU2pEyVLLuqVGUGpknFKjSpZazi01ilKj45QaU7LU8m6pMZQ6NE6pypKlVnBLVVJqbJxS40qWWtEtNY5S4+OUmlCy1EpuqQmUOixOqYklS63slppIqUlxSk0uWWoVt9RkSk2JU+rwkqVauqUOp9QRcUodWbLUqm6pIyl1VJxSU0uWWs0tNZVS0+KUOrpkqdXdUkdT6pg4paaXLNXg/dV0Sh0bp9RxJUut4ZY6jlLHxyl1QslSa7qlTqDUiXFKnVSyVGu31EmUOjlOqVNKllrLLXUKpU6NU+q0kqXWdkudRqnT45Qq/bOfddxSVZSaEadU6Y8v1nVLVVNqZpxSs0qWWs8tNYtSs+OUOqNkqfXdUmdQ6sw4pc4qWWoDt9RZlDo7TqlzSpba0C11DqXOjVPqvJKl2rilzqPU+XFKXVCy1EZuqQsodWGcUheVLLWxW+oiSl0cp9QlJUtt4pa6hFKXxil1WclSm7qlLqPUnDil5pYstZlbai6lLo9T6oqSpdq6pa6g1JVxSl1VslQ7t9RVlLo6TqlrSpba3C11DaWujVPqupKl2rulrqPU9XFK3VCy1BZuqRsodWOcUjeVLLWlW+omSt0cp9QtJUt1cEvdQqlb45S6rWSprdxSt1Hq9jil7ihZqqNb6g5K3Rmn1F0lS23tlrqLUnfHKXVPyVLbuKXuodS9cUrdV7LUtm6p+yh1f5xSD5QstZ1b6gFKPRin1EMlS23vluL/PRz1W7P0wsuXlRcaPhL1V7C6a7d1lyM9qvjqK/pXhtz8UrrmH4vYvPLH98rL5h83qL6w+yV19Z8wqL+uuvsnLbqv+fm5sv5Tmvr1fqftzW/CTn2MdxtvOV59nuF//rtr/K9x/xfzd+z8rHuET2a64+5pxXFX9yLg1bwIPE2pYpzfsa+kvIBat+JkcrrSb7hnom+4Zyg1L8Zvnlbg7a1aeV6QdD9OKapafDbiOcnHOen//P/in5Me5QNKd8uQOK/FCt3xs093oeg81bPjOdXPIJ+MdJrwa36axqeJ52IiuzHvPfG8yQmW98LzuhPsCxG3HJ9gX6DUi6br9FL0dXqJUi/HubRoBe1rw4u6nf6iqsFXrHb6K7qnPlk99V/WPfVfVm2lV1VPfYr+1OeD5VXT99evKX5yGWv/vqb65/NSj6rW8nXFWjpPs9cp9UbMNddtufnRn/rzKfVmjJ9R83O6vfbJ/4buyf+GqsW3rJ78b+me/M9ZPfnf1D3531RtpbdVT/7noj/5+XB52+51P9C+7r9jdRS8o3uivRv9ifYupd4zXaf3o6/T+5T6IM61a+rX/fd0T/33VA1+aLXTP9Q99V+yeup/oHvqf6DaSh+pnvovRX/q88Hykenr/sclp0vF278fK173/9S+7n+iWEvnafYJpT6N9xq7ovaCn666TfzZ//gDqc+jfyD1OaW+iLFOy/Gf6b53+dLgPbJX84ThNf/S9J3eV9G35leU+jre1vxatzW/MXjbsXBr8pp/sxjsL7Gkr/3+7dvo2/xbSn2XgDX/3uS5z0fGd7oj4wcDky48Mr7nuU1l9WP0ff4jpX6KtzV/0m3Nnw1e5hduTV7znxfjZbbEkint0fpL9G3+C6V+jfcyu73Ws5/qPPupqsXfTJ6Qjb0jov4rrtXaA/1XbTu/6Z6lf0Q/1n/nv1q8G8gr7txS7wbyf9rcQL49z6y72eZfpTdknOp/VVm9tmyve2tm9nnAZ7r670asr7zXxQLVSf4d1VLvxjjwSq3hFrzrNWfELTTdppuY7MQFPLFqJ6Y1//qs4j4HaW8xbyDfrvR6aG8gH2ubltpSW/K01brqqu3uK9ZRusmw+p8mUX9kFeFf7Sq9VIn79y/GjevTQd3DVKPd3Dgd6BZLOTc3ntWY2+yfD5q/b4GcDlSHVkqx/SN/ZJfm/wVVcc74Tf6dTfSf1UzHOOOXrF3TfFp3Ps000vk00yryata8MGleYlUvTPwap2k3a7C5+VSbNf+HAjR3H4w04eaNPWG7CBOq339srzZgY/9DAR0a7R8K6FB6zeq9ZOTqHua1gMg20pM412oxX8ObRbhlYjP9P51XeqmWJV9D4v4DBelC3cOmjfcaXtAt1jTWa7hym6lewwuq82pTxfaP/hqe5fIWr+E51SbKKe+9lm4WcRXVdyhcQ/vNUjfdc2kNVTvNrdpZU9tOD107a6raWcKqndbadnrp2mmtaqeFVTtradvZSdfOWqp2lrRqZ21tO7vo2llb1c5SVu2so21nN10766jaWdqqnXW17eyua2ddVTvLWLWznradvrp21lO1s6zJZ3G8lnvq3jsuZ1V/b1395a3q76Orv4JV/f109Ve0qn+Arv5KVvX76+qvbFV/gK7+Klb1B+nqt7SqX6Grv6pV/aG6+qtZ1R+uq7+6Vf1DdPVbWdUfqau/hlX90br6a1rVP1RXv7VV/bG6+mtZ1R+vq7+2Vf3DdPXXsao/SVd/Xav6U3T117Oqf4Su/vpW9Y/S1d/Aqv40Xf0Nreofo6vfxqr+sbr6G1nVP15Xf2Or+ifq6m9iVf9kXf1Nreqfqqu/mVX903X121rVn6Gr386q/kxd/c2t6s/W1W9vVf9MXf0trOqfrau/pVX9c3X1O1jVP19Xfyur+hfq6ne0qn+xrv7WVvUv1dXfxqr+HF39ba3qX66rv51V/St19be3qn+1rv4OVvWv1dXvZFX/el39zlb1b9TV72JV/2Zd/a5W9W/V1e9mVf92Xf3uVvXv1NXvYVX/bl39nlb179XV72VV/35d/R2t6j+oq7+TVf2HdfV31tSvd1u1YH6THSjdnNJLULoFf/XOX1fzV7z8tSh/lcjf5vEXavydFn+txN/s8Jcr/P0Gf8XAn/LzB+38WTd/3Myf+PKHrvy5J3/0yJ/+8Qdw/BkYfwzFnwTxhzH8eQh/JMGfCvAbc35vzG9P+R0iv0nj90n8VoXfLTDY2czMVpYj4439xIRhRfALOb+W8ssZv6LwSZ3Pq3xq47MLP8H5OcaHOR9pvLN5e3PLsW8bVvNjoma67bqLYrvWXaQUzHyI/4TSu0a+wqpmpbS/g9pV92P+XVUN7haxwYcXNrhbzI2uW/Osas17R981vSm9e+Rd0z7CrtH9RIEX08zXJ/qu4Qb72O0aX7tr+kbfNX0pvUfkXbN5hF2zh27X7KFqcM/ou4Yb3NNu1wTaXbNX9F2zF6X3jvyLzaCD5gIK1W+mVX31i/gCXK09bvbW7qZ+ugNsb1U7+0Q/wHg37WN3gKW0B9i+0Q+wfSm9X+TnfrsIz/39dLtmP1WD+0ffNdzg/na7Jq3dNQdE3zUHUPrAyLtm4ZrntTvnQN3OOVDVYv/oO4db7G+3czLanXNQ9J1zEKUHxLhMOT1Qs8Eb7TLlmOfdAdq9MFB3/AxQbZpB0Y8f3guD7I6frPb4GRz9+BlM6Yp4T+6cdi9W6HZOharFIdF3Drc4JM51nY1y2cx/Vnto6aniHT/K38YNU2w2zQVIw1rFW81cY77rG95IzQxv5TwbUvzBxcHuGH/qcIg7xp9BjHDH+BOJke7YzpQe5Y7tSunR7hi/ZxvjjvWh9KHu2B6UrnTH2Hxj3bF+lB7njjFAxrtj+1N6gjt2IKUPc8f4/DbRHRtI6UnuGD/VJrtjQyg9xR0bRunD3bGDKX2EOzaC0ke6Y6MofZQ7NobSU92xSkpPc8fGUfpod2wCpY9xxyZSero7NpnSx7pjh1P6OHfsSEof745NpfQJ7tjRlD7RHZtO6ZPcseMofbI7dgKlT3HHTqL0qe7YKZQ+zR07jdKnu2NVlK5yx6opPcMdm0XpanfsDErPdMfOovQsd+wcSs92x86j9Bnu2AWUPtMdu4jSZ7ljl1D6bHfsMkqf447NpfS57tgVlD7PHbuK0ue7Y9dQ+gJ37DpKX+iO3UDpi9yxmyh9sTt2C6Uvccduo/Sl7tgdlL7MHbuL0nPcsXsoPdcdu4/Sl7tjD1D6CneMX/yvjPyymFbd7iCtvd3BVRHlqL7dwVW6l8WrI9ZX/rNgupsPXGNigqt5Yl3z10aiVM3t2tLXUvq6OJ9r+8pb1OhW/HqTo0a/4W6IvuH4BHFjjPdA/L/rtIf89TpiXadq8abILdbY6WZ3jO10izvGdrrVHWM73eaOsZ1ud8fYTne4Y2ynO90xttNd7hjb6W53jO10jzvGdrrXHWM73eeOsZ3ud8fYTg+4Y2ynB90xttND7hjb6WF3jO30iDvGdnrUHWM7PeaOsZ0ed8fYTk+4Y2ynJ90xttNT7hjb6Wl3jO1UdMfYTuSOsZ2eccfYTvPcMbbTs+4Y2+k5d4zt9Lw7xnZ6wR1jO73ojrGdXnLH2E4vu2Nsp1fcMbbTq+4Y2+k1d4zt9Lo7xnZ6wx1jO813x9hOb7pjbKe33DG209vuGNvpHXeM7fSuO8Z2es8dYzu9746xnT5wx9hOH7pjbKeP3DG208fuGNvpE3eMT42fumNsp8/cMbbT5+4Y2+kLd4zt9KU7xnb6yh1jO33tjrGdvnHH2E7fumN8Rl/09sC6fxo1/X3J0+oO7ivH95T+IU6p0jfA7eSW+pHSP8Up9XPJUp3dUj9T+pc4pX4tWaqLW+pXSv8Wp1Tpm6h2dUv9Tuk/4pT6s2Spbm6pPyn9V5xSC0qW6u6WWkCZJjFKZUrfm7GHUyrjUcaPUyooWaqnWyqgTCpOqdJ3aOvllkpTJhOnVOn7OO3olspSJhenVL5kqZ3cUnnKFOKUalqy1M5uqaaUaRanVOlb1+zilmpOmSXilCp9H5Zd3VItKLNknFKlbyqym1tqKcosHafUMiVL9XZLLUOZZeOUKn33iN3dUstRZvk4pUrfqKGPW2oFyqwYp1TpeyL0dUutRJmV45QqffuBPdxSq1CmZZxSpa/039MttSplVotTqvRF9Xu5pVYn5+6TylKlr1/f2y21BmXWjFOq9KXi/dxSrSmzVpxSpa/K3scttTZl1olTqvQF0Pu6pdalzHpxSpW+1ng/t9T6lNkgTqnSl/Xu75bakDJt4pQqfQXtAW6pjSizcZxSpS9WPdAttQllNo1TqvR1of3dUptRpm2cUu1KljrILdWOMpvHKVX6ascBbqn2lNkiTqnSFxYOdEttSZkOcUqVvoZvkFtqK8p0jFOq9OVyg91SW1NmmzilSl+ZVuGW2pYy28UpVfoisCFuqe0ps0OcUqWvtxrqlupEmc5xSpW+tGmYW6oLZbrGKVX6KqLhbqlulOkep1TpC3YOdkv1oEzPOKVKXxtziFuqF2V2jFOq9GUoI9xSO1Fm5zilSl8ZMdIttQtldo1TqvQ1CqPcUrtRpnecUruXLDXaLbU7ZfrEKVX6R/Jj3FJ9KbNHnFKlf65+qFtqT8rsFafU3iVLVbql9qZMvzilSv9Geqxbah/K7Bun1H4lS41zS+1Hmf3jlCr9I93xbqkDKHNgnFKlfyw7wS3VnzIHxSk1oGSpw9xSAygzME6p0j/hnOiWGkSZwXFKVZQsNcktVUGZIXFKlf4R4WS31FDKDItTqvRP7Ka4pYZT5uA4pQ4pWepwt9QhlBkRp9TIkqWOcEuNpMyoOKVGlyx1pFtqNGXGxCl1aMlSR7mlDqVMZZxSY0uWmuqWGkuZcXFKjS9ZappbajxlJsQpdVjJUke7pQ6jzMQ4pSaVLHWMW2oSZSbHKTWlZKnpbqkplDk8TqkjSpY61i11BGWOjFPqqJKljnNLHUWZqXFKTStZ6ni31DTKHB2n1DElS53gljqGMtPjlDq2ZKkT3VLHUua4OKWOL1nqJLfU8ZQ5IU6pE0uWOtktdSJlTopT6uSSpU5xS51MmVPilDq1ZKlT3VKnUua0OKVOL1nqNLfU6ZSpilNqRslSp7ulZlCmOk6p0r+dq3JLzaTMrDilZpcsNcMtNZsyZ8QpdWbJUtVuqTMpc1acUmeXLDXTLXU2Zc6JU+rckqVmuaXOpcx5cUqdX7LUbLfU+ZS5IE6pC0uWOsMtdSFlLopT6uKSpc50S11MmUvilLq0ZKmz3FKXUuayOKXmlCx1tltqDmXmxil1eclS57ilLqfMFXFKXVmy1LluqSspc1WcUqV/436eW+pqylwTp1TpX5Sf75a6ljLXxSlV+jfgF7ilrqfMDXFK3Viy1IVuqRspc9Mi99pJzW9yEaVvpvQtlL6V0rdR+nZK30HpOyl9F6XvpvQ9lL6X0vdR+n5KP0DpByn9EKUfpvQjlH6U0o9R+nFKP0HpJyn9FKWfpnSR0kTpZyg9j9LPUvo5Sj9P6Rco/SKlX6L0y5R+hdKvUvo1Sr9O6TcoPZ/Sb1L6LUq/Tel3KP0upd+j9PuU/oDSH1L6I0p/TOlPKP0ppT+j9OeU/oLSX1L6K0p/TelvKP0tpb+j9A+U/onSv1D6N0r/Qem/KMObx6dMijIZyuQoU6BMM8osQZklKbM0ZZalzPKUWZEyK1OmJWVW4y/m+Qtz/iKbv2DmL375C1n+opS/wOQvFvkLP/4ijr8g4y+u+Asl/qKHv4DhL0b4Cwv+IoE/4OcP3vkDcf6gmj9A5g92+QNX/iCUP6DkDw75Az3+oI0/AOMPpvgDI/4ghz9g4Q8++AMJ/qCA38DzG2t+w8tvRPkNIr9x4zdU/EaH34DwGwMGO0OagcvwZBAy1BhQDBsGB0OAX6D5hZNf0PiFhl8A+MTMJ0w+kfEJhp/4/ITkJwofwHxg8Q6Pfy+iayh9k+pYbKr5p/2i3qZjYf0bVdfEpm9UPWNu1syl6qXueZWquZSXN/PN/+NrljK3mFy2UzOx7nR0q8nVL3wY627zl7kt4m7j0+FtlLnddJ3uiL5Od1DmzsiXMrXnHaW8cCdzu+p6HF5M0+BdVjv9Lt15p6nReSdzp+q8k7lTtZXuVp13mkY+79QcLHf/r88795Scyo933rmn1EWNXy9YsED5D8Nn7jVZSz5Q7tWt5TWqtbxPsZbO+eI+ytwfc81157AHop/DHqDMg5HPYQsvFuynPYvdrzuL3a9q8SGrs9hDurNYC6uz2IO6s9iDqq30sOos1iL6WYwPl4f/12exR0pOFcQ7iz2ie5Y9anUIPqqr/1j0Z/ljlHncdJ2eiL5OT1DmychnnnYR9PS47rzzuKrBp6x2+lO6884yVuedJ3XnnSdVW+lp1XlnmejnHT5Ynv5fn3eKJadKxTvvFBUu+VOrJzJZSz5QSLeWOj09o1hL53zxDGXmxZOKp73FlO5facw8G/G5qLvlh+7OVZnnIn528O/fqSzzvMm5Un1zjcwLkc4vCz9tfYEyL0ZfpxR/fPmiaudmXjL4PMurOTPymr9k+sHIy9G35suUeSXe1nxFtzVfNXiXvnBr8pq/uhhvLkss6Svv65N5Lfo2f40yrydgzd+weO7XHBmv646M+QbvfBYeGW/w3KaEfjP6Pn+TMm/F25pv6bbm2waeW7g1ec3fXgyGlFgypT1a34m+zd+hzLvxGDJQ+8Zlnu6NyzxVi+9ZvXFp1B3xfsS1rNYe6O9q23lP9yz9IPqx/j7/VRwP6rz/oY0H86qldG+cPlJss6s7Vw4fMWL40Jr7rM7KzZg2t+/wUUNHVPz9BXupFVH8s3kLZxw5ZkQFZT6eWVVl8AXc1jzzDNUT95PSGy1O9U+qLJ7q/CRKD9R9RrGa1anmWV391SPW193nPPOp6kVwNdVSq8c48Eqt4Ta86zWvGNuouv3MYidmPuWJdSfYzxX1FXdmznzeatFzSjriOUXxT5FW6WaKt01LbalteVqdEz5Tbfcvop6k89W1G1RNoIzqYPmQXzJKnMv4i7p36vbnPy/s1fyf6rrz/5d1D7/SvRRojrcvdYt91SrWZ4TpjO4U2Mrk2VuzQ3T114h6Cp71z9NWf7NwBb5UHcJfqU7BrVRLraE4/iJ/3p75jFupsnmV+vrfa75JrN8n1TT/te414JtGeg34JvqTrebFVLPBdS+mn6iW+tZgc/PLw7dVUU/pmdmN7u5oE3Zs7Am3ijBhtZrDardWRSivOYNsF2he8jX/HJriX7qu95L5Xd3D77Xo+baRnsTftVpMd/AXO8NUJ6jn+KuL0u74Ja47fqh7+GPjueMH3WI/xvxXV4bpXvfXNHFHzQ7R1W8d9UVV544fVOfvH1UvqmuqlmqtOP6iu+NbbsXIHT+Vbiunaj4XfS+q/xWw5trD/WDdHfCbqzbNz1btLKFt5xBdO0uo2vnFqp0W2nZG6NppoWrnV6t2ltS2M1LXzpKqdn6zamcpbTujdO0spWrnd6t2lta2M1rXztKqdv6wamcZbTtjdO0so2rnT6t2ltW2c6iunWVV7fxl1c5y2nYqde0sp2pngVU7y2vbGatrZ3lNO9kmVu2soG1nnK4d1bdhWc+qnRW17YzXtbOiqh3fqp2VtO1M0LWzkqqdwKqdlbXtHKZrZ2VVOymrdlbRtjNR184qqnbSVu201LYzSdeO6oeS2YxVO6tq25msa2dVVTtZq3ZW07YzRdfOaqp2clbtrK5t53BdO6ur2slbtdNK284RunZaqdopWLWzhradI3XtrKFqp6lVO2tq2zlK186aqnaaWbXTWtvOVF07rVXtNLdqZy1tO9N07aylamcJq3bW1rZztK6dtVXttLBqZx1tO8fo2llH1c6SVu2sq21nuq6ddVXtLGXVznrado7VtbOeqp2lrdpZX9vOcbp21le1s4xVOxto2zle184GqnaWtWpnQ207J+ja2VDVznJW7bTRtnOirp02qnaWt2pnI207J+na2UjVzgpW7WysbedkXTsbq9pZ0aqdTbTtnKJrZxNVOytZtbOptp1Tde1sqmpnZat2NtO2c5qunc1U7axi1U5bbTun69ppq2qnpVU77bTtVOnaaadqZ1WrdjbXtjND187mqnZWs2qnvbadal077VXtrG7Vzhbadmbq2tlC1U4rq3a21LYzS9fOlqp21rBqp4O2ndm6djqo2lnTqp2ttO2coWtnK1U7Zj8x6qht50xdOx1V7axl1c7W2nbO0rWztaqdta3a2Ubbztm6dlQ//86uY9XOttp2ztG1s62qnXWt2tlO2865una2U7WznlU722vbOU/Xzvaqdta3amcHbTvn69rZQdXOBlbtdNK2c4GunU6qdja0aqeztp0Lde10VrXTxqqdLtp2LtK100XVzkZW7XTVtnOxrp2uqnY2tmqnm7adS3TtdFO1s4lVO9217Vyqa6e7qp1NrdrpoW3nMl07PVTtbGbVTk9tO3N07fRUtdPWqp1e2nbm6trppWqnnVU7O2rbuVzXzo6qdja3amcnbTtX6NrZSdVOe6t2dta2c6WunZ1V7WyhaafeP2mSnt9kB8r8TJlfKPMrZX6jzO+U+YMyf1LmL8osoGzNz2Up61M2oGyKsmnKZiibpWyOsnnKFijblLLNKNucsktQtgV/dc5fN/NXtPy1Jn8VyF+f8VdO/DUNf7XBXwfwR+j8sTN/VMsfb/JHgvwxGn/0xB/X8Ecc/LEAv5Xmt5/8lo3f5vBbA+Y0E5TZxtRhHvBLKr8M8ambT3d8iuCnFR+KvPu45dj/ZEfNRVk/qa5uy26p2K51Nx1Kz3yI/4SyHSLfMalmpTRHGK96toPqwMnqPmTaKmKDDy9scKuYG11324xvVWveMfqu6UjZrSPvmq0j7JqtdbtG95HMNtF3DTe4jd2u8bW7Ztvou2Zbym4Xedd0jLBrttPtGt0HGNtH3zXc4PZ2uybQ7podou+aHSjbqcGal6oUbKe525nqenlVX50tXs9rjptOyt2U7aw7wHQfWnSJfoDxbupid4CltAdY1+gHWFfKdov83N8qwnO/m27X6N4Td4++a7jB7na7Jq3dNT2i75oelO0Z/faPNWv+vXbn9NTtHN17yF7Rdw632Mtu52S0O2fH6DtnR8ruFOPGAdmdNRu80W6rF/O8u5P2vLuz7vjRvS3cJfrxw3thF7vjJ6s9fnaNfvzsStnd4j25v9Puxd10O2c3VYu9o+8cbrF3nKfI7qqDv1FuLFKzUKzjJ7u77j1sH8VmU9zIJtunVbzD/LvGfNfXt5Ga6dvKeTak+GOHPdyx7pTd0x3rSdm93DE+B+ztju1M2X7uGB+O+7hjvSm7rzvWh7L7uWN7UHZ/d2wvyh7gjvWj7IHu2L6U7e+O7U/Zg9yxAyk7wB07iLID3bGBlB3kjg2m7GB3bAhlK9yxYZQd4o4dTNmh7tgIyg5zx0ZRdrg7NoayB7tjlZQ9xB0bR9kR7tgEyo50xyZSdpQ7Npmyo92xwyk7xh07krKHumNTKVvpjh1N2bHu2HTKjnPHjqPseHfsBMpOcMdOouxh7tgplJ3ojp1G2UnuWBVlJ7tj1ZSd4o7Nouzh7tgZlD3CHTuLske6Y+dQ9ih37DzKTnXHLqDsNHfsIsoe7Y5dQtlj3LHLKDvdHZtL2WPdsSsoe5w7dhVlj3fHrqHsCe7YdZQ90R27gbInuWM3UfZkd+wWyp7ijt1G2VPdsTsoe5o7dhdlT3fH7qFslTt2H2VnuGMPULbaHeMX/5lxXhZnad6NaG51mY5+w1LtrS6zs3Qvi7Mj1tfdO15348nsGRYmyM7miXXNnxmJUjX//EL2TMqeFedz7S8UVtxWe5Pq7NkWR02EDXdO9A3HJ79zY7wH4iP5LO0hr/vtXPYsVYvnRW6xxk7nu2NspwvcMbbThe4Y2+kid4ztdLE7xna6xB1jO13qjrGdLnPH2E5z3DG201x3jO10uTvGdrrCHWM7XemOsZ2ucsfYTle7Y2yna9wxttO17hjb6Tp3jO10vTvGdrrBHWM73eiOsZ1ucsfYTje7Y2ynW9wxttOt7hjb6TZ3jO10uzvGdrrDHWM73emOsZ3ucsfYTne7Y2yne9wxttO97hjb6T53jO10vzvGdnrAHWM7PeiOsZ0ecsfYTg+7Y2ynR9wxttOj7hjb6TF3jO30uDvGp48n3DG205PuGNvpKXeM7fS0O8Z2KrpjbCdyx9hOz7hjbKd57hjb6Vl3jO30nDvGdnreHWM7veCOsZ1edMfYTi+5Y2ynl90xttMr7hjb6VV3jO30mjvGdnrdHWM7veGO8Rl9vjOW/p6yb7pjP1L2LXfsZ8q+7Y79Stl33LHfKfuuO/YnZd9zx/iL+vedsQyf5z9wx/hL/A/dMf5K/yN3jL/g/9gd46/7P3HH+Mv/T92x5pT9zB1rQdnP3bGlKPuFO7YMZb90x5aj7Ffu2AqU/dodW4my37hjq1D2W3dsVcp+546tTtnv3bE1KPuDO9aasj+6Y2tT9id3bF3K/uyO8WvjL+7YhpT91R3biLK/uWObUPZ3d2wzyv7hjrWj7J/uWHvK/uWO8Vf3C9yxrSjX4J/a2ppynju2LeV8d2x7ygXuWCfKpdyxLpRLu2PdKJdxx3pQLuuO9aJczh3biXJ5d2wXyhXcsd0o19Qd251yzdyxvpRr7o7tSbkl3LG9KdfCHduHcku6Y/tRbil37ADKLe2O9afcMu7YAMot644Notxy7lgF5ZZ3x4ZSbgV3bDjlVnTHDqHcSu7YSMqt7I6Nptwq7tihlGvpjo2l3Kru2HjKreaOHUa51d2xSZRr5Y5Nodwa7tgRlFvTHTuKcq3dsWmUW8sdO4Zya7tjx1JuHXfseMqt646dSLn13LGTKbe+O3Yq5TZwx06n3Ibu2AzKtXHHZlJuI3dsNuU2dsfOpNwm7tjZlNvUHTuXcpu5Y+dTrq07diHl2rljF1Nuc3fsUsq1d8fmUG4Ld+xyym3pjl1JuQ7u2NWU28odu5ZyHd2x6ym3tTt2I+W2WeS3bJn5Tdg55/PbDX53wW8m+L0Dv1Xgdwb8RoDdz8xn1TPi2exMdBY5A5y9zbxmTTOe2cpMY5Yww5edy6xlxTJa2ahMUhYog5N9yZxkPTIW2YZMQZYfQ49dx4xjtTHS2GRMMBYXA4s9xXxiLTGO2EJMH5YOw4Ydw2xhpTBK2CBMDhYGg4L9wFxgHTAG+LWfX+r5lZ1fyPl1m1+m+VWZX4T5NZdfYvkVlV9A+fWSXx751ZBf/Pi1jl/a+JWMX7j4dYpflvhViF90+DWGX1L4FYRfMPj1gV8O+OzPJ3s+t/OpnM/cfKLm8zKfhvmsyydZPqfyKZTPmHyC5PMhn/74bMcnNz6X8amLz1R8YuLzEJ92+CzDJxU+h/Apg88QfELg5z8/3fnZzU9mfu7yU5WfmfxE5OcdP834WcVPIn7O8FOEnxH8BODjnQ9vPpr54OVjlQ9NPhL5wOPjjA8rPor4oOFjhA8JPgJ4h8f+rV+WmX2e7k72d8b4aEHxSQ+/+1f9w3/ZczVrmdtW9Z3TnZHew2dqvio7h+eO8Zlgbrt/9TPBeP/8TW471SGQ297k06UzeGJd/R0i7raH+E8o18l0nTpHX6fOlOsS53eWnyk/GMt1Un3elVP91irX1Wqnd9Wdd+41Ou/kuqjOOznVhVq5bqrzzr2Rzzs1B0u3OOed7v/qecePd97pXupLg68XLFig/IcCcz0s1rLmQOmhWsvsGaq17KlYS+d80ZNyvWKuue4ctmP0c9iOlNspxo9j2GedtWexXrqzmOpyo9zOVmexnXVnsQetzmI76c5iqt935XZRncUejH4W48NllzhnsV3/1bNYEO8stqvuWbab1SG4m65+7+jP8t6U2910nfpEX6c+lOsb5+fQaj3trjvv7K5qcA+rnb6H7rzzqNV5p6/uvNNXtZX2VJ13Ho1+3uGDZc845529/tXzTireeWcvhUv+1Oppb4u1rDlQ9latpVJP/RRr6Zwv+lFun1hSyXyu/aVpX93Jbl+bn9Sofhma2y/iZwfKJ8r+/+ovgU1/vJI7IPIvO3L8rcWBMZ68n/CfqXZurr/B51lezZmR17y/6QcjB0XfmgdRbkC8rTlAtzUHGrxLX7g1ec0HLsabyxJL+srfzeUGRd/m/N3Z4ASseYXJzx35yBisOzKGGLzzWXhk8PeQQ0wJPTT6PufvQYfF25rDdFtzuIHnFm5NXvPhi8GQEkumtEfrwdG3+cGUOyTeByY7a9+47KN747KPqsURVm9cGnVHjIy4ltXaA/0QbTsjdM/SUdGP9ZH8V3E8qPP+aBsPjlE981upltL8BH6Rf4E9N6Pun0DX/FvwnUoXmFH7b6PnDtX92+hRnxSdeGbVP1yfqyy9A+JUr6yyeKrzkyir/Gz0WatTzb66+s9FfV+meyqMVR3kz6qWei7GgVdqDfmbJdW/7qq68WJunMVOzI3liXUn2PGK+oorH3PjWy16TklHPKcoviOv0s0Ub5uW2lJdeFqdE8aptvuEqCfpfHXtBlV/EvON6mAZzS8/Jc5l/EXdO3X7858X9mr+T3Xd+f+wuocTdS8FmuPtMN1iE1vF+oww843uFPi8ybO3Zofo6r8Q9RQ865+nrf5m4QocpjqEJ6pOwc+rlnpBcfxF/rw9N45bqbJ5lZr07zXfJNbvk2qan6R7DZjcSK8Bk6M/2WpeTDUbXPdiWqlaaorB5uaXhylVUU/pmdmN7u5oE+7Q2BNuH2HCajWH1W6tilBecwbpGmhe8jW3G1P8GqzeS+bhdQ+P0KJnSiM9iQ9vtZju4C92+qhOUPvx1yCl3fFLXHccWffwqMZzx5G6xY6Kd1eTbB/d6/6LJu6o2SG6+i/ZuONI1fn7KNWL6ouqpV5SHH/R3TGFWzFyx9TSbeVUzeei70XtXbYyP2sP9z10N/H5WbVpplm184u2nT117fyiaudoq3Z+1bazl66dX1XtHGPVzm/advbWtfObqp3pVu38rm2nn66d31XtHGvVzh/adnTfwmT+ULVznFU7f2rb2VfXzp+qdo63aucvbTv76dr5S9XOCVbtLNC2s7+unQWqdk40aifbRNvOAbobtTRRtXOSVTuetp0Dde14qnZOtmrH17bTX9eOr2rnFKt2Am07B+naCVTtnGrVTkrbzgBdOylVO6dZtZPWtjNQ105a1c7pVu1ktO0M0rWTUbVTZdVOVtvOYF07WVU7M6zayWnbqdC1k1O1U23VTl7bzhBdO3lVOzOt2ilo2xmqa6egameWVTtNte0M07XTVNXObKt2mmnbGa5rp5mqnTOs2mmubedgXTvNVe2cadXOEtp2DtG1s4SqnbOs2mmhbWeErp0WqnbOtmpnSW07I3XtLKlq5xyrdpbStjNK185SqnbOtWpnaW07o3XtLK1q5zyrdpbRtjNG184yqnbOt2pnWW07h+raWVbVzgVW7SynbadS185yqnYutGpneW07Y3XtLK9q5yKrdlbQtqP7yVx2BVU7F1u1s6K2nfG6dlZUtXOJVTsraduZoGtnJVU7l1q1s7K2ncN07aysaucyq3ZW0bYzUdfOKqp25li101LbziRdOy1V7cy1amdVbTuTde2sqmrncqt2VtO2M0XXzmqqdq6wamd1bTuH69pZXdXOlVbttNK2c4SunVaqdq6yamcNbTtH6tpZQ9XO1VbtrKlt5yhdO2uq2rnGqp3W2nam6tpprWrnWqt21tK2M03Xzlqqdq6zamdtbTtH69pZW9XO9VbtrKNt5xhdO+uo2rnBqp11te1M17WzrqqdG63aWU/bzrG6dtZTtXOTVTvra9s5TtfO+qp2brZqZwNtO8fr2tlA1c4tVu1sqG3nBF07G6raudWqnTbadk7UtdNG1c5tVu1spG3nJF07G6naud2qnY217Zysa2djVTt3WLWzibadU3TtbKJq506rdjbVtnOqrp1NVe3cZdXOZtp2TtO1s5mqnbut2mmrbed0XTttVe3cY9VOO207Vbp22qnaudeqnc217czQtbO5qp37rNppr22nWtdOe1U791u1s4W2nZm6drZQtfOApp16/6RJdn6THSg3jXJHU+4Yyk2n3LGUO45yx1PuBMqdSLmTKHcy5U6h3KmUO41yp1OuinIzKFdNuZmUm0W52ZQ7g3JnUu4syp3NX53z1838FS1/rclfBfLXZ/yVE39Nw19t8NcB/BE6f+zMH9Xyx5v8kSB/jMYfPfHHNfwRB38swG+l+e0nv2Xjtzn81oA5zQRltjF1mAf8ksovQ3zq5tMdnyL4acWHIu8+bjn2P9lRc1HWVN310NFuV5atuU3Vg5R7KPIdk2pWSnOE1az6Q7qbTzykavDhiA0+vLDBh2NudN2aT1Gt+SPRd80jlHs08q7pFGHXPKpr8FFVg49F3zXc4GN2u8bX7prHo++axyn3RORds0OEXfOEbtc8oWrwyei7hht80m7XBNpd81T0XfMU5Z5usOalKgVdNXe3Vl0vr+qraPF6XrP1n9bupqLuAHta1Q5FP8B4N5HdAZbSHmDPRD/AnqHcvMjP/e0jPPfn6XbNPFWDz0bfNdzgs3a7Jq3dNc9F3zXPUe756Ld/rFnzI7Q753ndznle1eIL0XcOt/iC3c7JaHfOi9F3zouUeynOjQNe1mzwRrutXszz7kvavfCy7vh5SbVpXol+/PBeeMXu+Mlqj59Xox8/r1LutXhP7sO1e/E13c55TdXi69F3Drf4epynyBuqg79RbixSs1C84+cN3XvY+YrNprmRzfxW8Vbz8MZ81/dmIzXzZivn2ZBan3JvuWPdKfe2O9aTcu+4YztS7l13bGfKveeO7Uq5992x3pT7wB3rQ7kP3bE9KPeRO7YX5T52x/pR7hN3bF/KfeqO7U+5z9yxAyn3uTt2EOW+cMcGUu5Ld2ww5b5yx4ZQ7mt3bBjlvnHHDqbct+7YCMp9546Notz37tgYyv3gjlVS7kd3bBzlfnLHJlDuZ3dsIuV+cccmU+5Xd+xwyv3mjh1Jud/dsamU+8Md40/d/nTH+DO4v9wx/kRugTt2AuXdM3nqJMp77tgplPfdsdMoH7hjVZRPuWPVlE+7Y7Mon3HHzqB81h07i/I5d+wcyufdsfMoX3DHLqB8U3fsIso3c8cuoXxzd+wyyi/hjs2lfAt37ArKL+mOXUX5pdyxayi/tDt2HeWXccduoPyy7thNlF/OHbuF8su7Y7dRfgV37A7Kr+iO3UX5ldyxeyi/sjt2H+VXccceoHxLd+whyq8a42Uxv5rm3YjmVpfp6Dcs1d7qMr+a6mUxv3rE+rp7x+tuPJlvZWGC/Oo8sa75NSJRquafX8ivQfk143yuPUFhxS7am1TnTf6Fowgbbq3oG24tyq8d4z0QH8lrag/51ipi5VW/O82vE7lFtlN+XXesO+XXc8d6Un59d2xHym/gju1M+Q3dsV0p38Yd6035jdyxPpTf2B3bg/KbuGN7UX5Td6wf5Tdzx/alfFt3bH/Kt3PHDqT85u7YQZRv744NpPwW7thgym/pjg2hfAd3bBjlt3LHDqZ8R3dsBOW3dsdGUX4bd2wM5bd1xyopv507xofY9u7YBMrv4I5NpHwnd2wy5Tu7Y4dTvos7diTlu7pjUynfzR07mvLd3bHplO/hjh1H+Z7uGNuplzvGdtrRHWM77eSOsZ12dsfYTru4Y2ynXd0xttNu7hjbqbc7xnba3R1jO/Vxx9hOfd0xttMe7hjbaU93jO20lzvGdtrbHWM79XPH2E77uGNsp33dMbbTfu4Y22l/d4ztdIA7xnY60B1jO/V3x9hOB7ljbKcB7hjbaaA7xnYa5I6xnQa7Y2ynCneMz+hDnLH095Qf6o79SPlh7tjPlB/ujv1K+YPdsd8pf4g79iflR7hjCyg/0hnL8Hl+lDsWUH60O5am/Bh3LEv5Q92xPOUr3bGmlB/rjjWn/Dh3rAXlx7tjS1F+gju2DOUPc8eWo/xEd2wFyk9yx1ai/GR3bBXKT3HHVqX84e4Yv+4f4Y6xc450x1pT/ih3bG3KT3XH1qX8NHeMXxuPdsc2pPwx7thGlJ/ujm1C+WPdsc0of5w71o7yx7tj7Sl/gju2JeVPdMe2ovxJ7tjWlD/ZHduW8qe4Y9tT/lR3rBPlT3PHulD+dHesG+Wr3LEelJ/hjvWifLU7thPlZ7pju1B+lju2G+Vnu2O7U/4Md6wv5c90x/ak/Fnu2N6UP9sd24fy57hj+1H+XHfsAMqf5471p/z57tgAyl/gjg2i/IXuWAXlL3LHhlL+YndsOOUvcccOofyl7thIyl/mjo2m/Bx37FDKz3XHxlL+cndsPOWvcMcOo/yV7tgkyl/ljk2h/NXu2BGUv8YdO4ry17pj0yh/nTt2DOWvd8eOpfwN7tjxlL/RHTuR8je5YydT/mZ37FTK3+KOnU75W92xGZS/zR2bSfnb3bHZlL/DHTuT8ne6Y2dT/i537FzK3+2OnU/5e9yxCyl/rzt2MeXvc8cupfz97tgcyj/gjl1O+QfdsSsp/5A7djXlH3bHrqX8I+7Y9ZR/1B27kfKPLfJbttz8JuwcPvWux+8u+M0Ev3fgtwr8zoDfCLD7mfmsekY8m52JziJngLO3mdesacYzW5lpzBJm+LJzmbWsWEYrG5VJygJlcLIvmZOsR8Yi25ApyPJj6LHrmHGsNkYam4wJxuJiYLGnmE+sJcYRW4jpw9Jh2LBjmC2sFEYJG4TJwcJgULAfmAusA8YAv/bzSz2/svMLOb9u88s0vyrzizC/5vJLLL+i8gsov17yyyO/GvKLH7/W8Usbv5LxCxe/TvHLEr8K8YsOv8bwSwq/gvALBr8+8MsBn/35ZM/ndj6V85mbT9R8XubTMJ91+STL51Q+hfIZk0+QfD7k0x+f7fjkxucyPnXxmYpPTHwe4tMOn2X4pMLnED5l8BmCTwj8/OenOz+7+cnMz11+qvIzk5+I/Lzjpxk/q/hJxM8ZforwM4KfAHy88+HNRzMfvHys8qHJRyIfeHyc8WHFRxEfNHyM8CHBRwDv8Ni/9cu34je0qrf2zQ6J8dGC4pMefvev+ofe86oL9fKPa+ZS9VL3vMrxV2U1H1M8HuczwSf+1c8E4/3zN/kndJ/uPGny6RIfAk/q6j8Vcbfxc+Qpyj9tuk7F6OtUpDzF+Z3lOO0HY0/rPu9S/dYq/4zVTn9Gd94ZbXXeId15h1RbaZ7qvDM6+nmHD5Z5cc47z/6r5x0/3nnn2VJfGny9YMEC5T8UmH/OYi1rDpTnVGuZV91UIv+8Yi2d88XzlH8h5prrzmEvRj+HvUj5l2L8OIa/ZS5qz2Iv6M5iL6hafNnqLPay7iw21uos9pLuLKb6fVf+FdVZbGz0sxgfLq/EOYu9+q+exYJ4Z7FXdc+y16wOwdd09V+P/ix/nfJvmK7T/OjrNJ/yb8b5ObRaT2/ozjtvqBp8y2qnv6U77xxmdd55U3feeVO1ld5WnXcOi37e4YPl7TjnnXf+1fNOKt555x2FS/7U6uldi7WsOVDeVa2lUk/vKdbSOV+8R/n340llvPYnnG/qTnYf2PykRvXL0PyHET87UD5RPvpXfwls++OVj6P/eOVjyn8S48nLH1Z+otq5+U8NPs/yas6MvOafmn4w8ln0rfkZ5T+PtzU/123NLwzepS/cmrzmXyzGm8sSS/ra3819GX2bf0n5rxKw5l+b/NyRj4yvdEfGNwbvfBYeGV/z3KaE/jb6Pv+W8t/F25rf6bbm9waeW7g1ec2/XwyGlFgypT1af4i+zX+g/I/xGPKy9o3L+7o3Lu+rWvzJ6o1Lo+6InyOuZbX2QP9R285PumfpL9GP9Z/5r+J4UOf9X208+JtKes+rlor6E/gq3a74/Z+n3XatI9+OM+0f4rR+7do2vPTqlt6jx1YMHzx6VNveFZUjx48bMG746FHVs+ouxcr/Xvu4W91oav16S/zB30rzO6i/KL+ACk0W/UfpszPq/lX4GarTw5+lt3qVbq4eRq/pOeVnrkdbncI+0NWP+g85655iBU/14nq0aqljIp4FNJuoB6+iagMVfMUGUlytWPBbRT9P9lCtYWByliyk/tVdGHI9QiHtjnWnQsYd60mFrDu2IxVy7tjOVMi7Y7tSoeCO9aZCU3esDxWauWN7UKG5O7YXFZZwx/pRoYU7ti8VlnTH9qfCUu7YgVRY2h07iArLuGMDqbCsOzaYCsu5Y0OosLw7NowKK7hjB1NhRXdsBBVWcsdGUWFld2wMFVZxxyqp0NIdG0eFVd2xCVRYzR2bSIXV3bHJVGjljh1OhTXcsSOpsKY7NpUKrd2xo6mwljs2nQpru2PHUWEdd+wEKjS4buYkKjS4buYUKjS4buY0KjS4bqaKCg2um6mmQoPrZmZRocF1M2dQocF1M2dRocF1M+dQocF1M+dRocF1MxdQocF1MxdRocF1M5dQocF1M5dRocF1M3Op0OC6mSuo0OC6mauo0OC6mWuo0OC6meuo0OC6mRuo0OC6mZuo0OC6mVuo0OC6mduo0OC6mTuo0OC6mbuo0OC6mXuo0OC6mfuo0OC6mQeo0OC6mYeo4F43k/6eCu51M+kfqeBeN5P+mQrudTPpX6ngXjeT/p0K7nUz6T+p4F43k2aeudfNZDwquNfNZAIquNfNZNJUcK+byWSp4F43k8lTwb1uJtOUCu51M5nmVHCvm8m0oIJ73UxmKSq4181klqGCe91MZjkquNfNZFaggnvdTGYlKrjXzWRWoYJ73UxmVSq4181kVqeCe91MZg0quNfNZFpTwb1uJrM2FdzrZjLrUsG9bibDr43udTOZDangXjeT2YgK7nUzmU2o4F43k9mMCu51M5l2VHCvm8m0p4J73UxmSyq4181ktqKCe91MZmsquNfNZLalgnvdTGZ7KrjXzWQ6UcG9bibThQoNrpvpRoUG182w9BpcN9OLCg2um9mJCg2um9mFCg2um9mNCg2um9mdCg2um+lLhQbXzexJhQbXzexNhQbXzexDhQbXzexHhQbXzRxAhQbXzfSnQoPrZgZQocF1M4Oo0OC6mQoqNLhuZigVGlw3M5wKDa6bOYQKDa6bGUmFBtfNjKZCg+tmDqVCg+tmmMwNrpsZT4UG180cRoUG181MokKD62amUKHBdTNHUKHBdTNHUaHBdTPTqNDgupljqNDgupljqdDgupnjqdDgupkTqdDgupmTqdDguplTqdDgupnTqdDgupkZVGhw3cxMKjS4bmY2FRpcN3MmFRpcN3M2FRpcN3MuFRpcN3M+FRpcN3MhFRpcN3MxFRpcN3MpFRpcNzOHCg2um7mcCg2um7mSCg2um7maCg2um7mWCg2um7meCg2um7mRCpdFf3fWRPHWp6fF16maN9e9LAr7isI7WhTW3GRypziFS026s+atcvBmnA8BS5XexWJDat7U72pROK0ovJtF4YyicG+LwllF4d0tCucUhftYFM4rCve1KFxQFN7DonBTReE9LQo3UxTey6Jwc0XhvS0KL6Eo3M+icAtF4X0sCi+pKLyvReGlFIX3syi8tKLw/haFl1EUPsCi8LKKwgdaFF5OUbi/ReHlFYUPsii8gqLwAIvCKyoKD7QovJKi8CCLwisrCg+2KLyKonCFReGWisJDLAqvqig81KKw4j6C3jCLwqsrCg+3KNxKUfhgi8JrKAofYlF4TUXhERaFWysKj7QovJai8KgYP9ko/RnCBxR8oflYIM6lxqXmXFj9G83FMmNUn4d8oFrqG4sPbA5VlX7P4thZW7F6lTF+C1jyVyJU8DWHWIG/sktpDrGxMVay1Jy8uykVqJ4JvGBas6tVvyFMBSbN/EzBH6pmfqZUStPMeNVx+4fFB40TLCY9zGLSiRaTTrKYdLLFpFMsJj3cYtIjLCY90mLSoywmLU41mXWayaxHm8x6jMms001mPdZk1uNMZj3eZNYTTGY90WTWk0xmPdlk1lNMZj3VZNbTTGY93WTWKpNZZ5jMWm0y60yTWWeZzDrbZNYzTGY902TWs0xmPdtk1nNMZj3XZNbzTGY932TWC0xmvdBk1otMZr3YZNZLTGa91GTWy0xmnWMy61yTWS83mfUKk1mvNJn1KpNZrzaZ9RqTWa81mfU6k1mvN5n1BpNZbzSZ9SaTWW82mfUWk1lvNZn1NpNZbzeZ9Q6TWe80mfUuk1nvNpn1HpNZ7zWZ9T6TWe83mfUBk1kfNJn1IZNZHzaZ9RGTWR81mfUxk1kfN5n1CZNZnzSZ9SmTWZ82mbVoMiuZzPqMyazzTGZ91mTW50xmfd5k1hdMZn3RZNaXTGZ92WTWV0xmfdVk1tdMZn3dZNY3TGadbzKryeV0xbdMZn3bZNZ3TGZ912TW90xmfd9k1g9MZv3QZNaPTGb92GTWT0xm/dRk1s9MZv3cZNYvTGb90mTWr0xm/dpk1m9MZv3WZNbvTGb93mTWH0xm/dFk1p9MZv3ZZNZfTGb91WTW30xm/d1kVpPfUxf/NJn1L5NZF1jMSl4Tm2k9m2l9m2kDm2lTNtOmbabN2EybtZk2F3Fa3b26p1BumuoG6bzgW6obpHs199ooPd80q3aO1rbztq6dgqqdo63aOUbbzju6dpqq2jnGqp3p2nbe1bXTTNXOdKt2jtW2856uneaqdo61auc4bTu6fyvBW0LVznFW7RyvbecDXTstVO0cb9XOCdp2PtS1s6SqnROs2jlR285HunaWUrVzolU7J2nb+VjXztKqdk6yaudkbTuf6NpZRtXOyVbtnKJt51NdO8uq2jnFqp1Tte18pmtnOVU7p1q1c5q2nc917Syvauc0q3ZO17bzha6dFVTtnG7VTpW2nS917ayoaqfKqp0Z2na+0rWzkqqdGVbtVGvb+VrXzsqqdqqt2pmpbecbXTurqNqZadXOLG073+raaalqZ5ZVO7O17Xyna2dVVTuzrdo5Q9vO97p2VlO1c4ZVO2dq2/lB187qqnbOtGrnLG07P+raUf0bybmzrNo5W9vOT7p21lC1c7ZVO+do2/lZ186aqnbOsWrnXG07v+jaaa1q51yrds7TtvOrrp21VO2cZ9XO+dp2ftO1s7aqnfOt2rlA287vunbWUbVzgVU7F2rb+UPXzrqqdi60aucibTt/6tpZT9XORVbtXKxt5y9dO+ur2rnYqp1LtO0s0LWzgaqdS6zauVTZTr6Jrp0NVe1catXOZdp2PF07bVTtXGbVzhxtO76unY1U7cyxameutp1A187GqnbmWrVzubadlK6dTVTtXG7VzhXadtK6djZVtXOFVTtXatvJ6NrZTNXOlVbtXKVtJ6trp62qnaus2rla205O1047VTtXW7VzjbadvK6dzVXtXGPVzrXadgq6dtqr2rnWqp3rtO001bWzhaqd66zauV7bTjNdO1uq2rneqp0btO0017XTQdXODVbt3KhtZwldO1up2rnRqp2btO200LXTUdXOTVbt3KxtZ0ldO1ur2rnZqp1btO0spWtnG1U7t1i1c6u2naV17WyraudWq3Zu07azjK6d7VTt3GbVzu3adpbVtbO9qp3brdq5Q9vOcrp2dlC1c4dVO3dq21le104nVTt3WrVzl7adFXTtdFa1c5dVO3dr21lR104XVTt3W7Vzj7adlXTtdFW1c49VO/dq21lZ1043VTv3WrVzn7adVXTtdFe1c59VO/dr22mpa6eHqp37rdp5QNvOqrp2eqraeSBGO6rvOeZrFsx/SPmPdBcaxfr3uUtPu6NmKxXSNsV3UhXP2BRX/UvdhaxN8V1UxXM2xXdVFc/bFN9NVbxgU7y3qnhTm+K7q4o3syneR1W8uU3xvqriS9gU30NVvIVN8T1VxZe0Kb6XqvhSNsX3VhVf2qZ4P1XxZWyK76MqvqxN8X1VxZezKb6fqvjyNsX3VxVfwab4AariK9oUP1BVfCWb4v1VxVe2KX6QqvgqNsUHqIq3tCk+UFV8VZvig1TFV7MpPlhVfHWb4hWq4q1sig9RFV/DpvhQVfE1bYoPUxVvbVN8uKr4WjbFD1YVX9um+CGq4uvYFB+hKr6uTfGRquLr2RQfpSq+vk3x0ariG9gUV/1r4YUNbYofqirexqZ4par4RjbFx6qKb2xTXPWvchc2sSmu+le0C5vaFJ+gKr6ZTfHDVMXb2hSfqCrezqb4JFXxzW2KT1YVb29TfIqq+BY2xQ9XFd/SpvgRquIdbIofqSq+lU3xo1TFO9oUn6oqvrVN8Wmq4tvYFD9aVXxbm+LHqIpvZ1N8uqr49jbFj1UV38Gm+HGq4p1sih+vKt7ZpvgJquJdbIqfqCre1ab4Sari3WyKn6wq3t2m+Cmq4j1sip+qKt7TpvhpquJGP9g4XVV8R5viVariO9kUn6EqvrNN8WpV8V1sis9UFd/VpvgsVfHdbIrPVhXvbVP8DFXx3W2Kn6kq3sem+Fmq4n1tip+tKr6HTfFzVMX3tCl+rqr4XjbFz1MV39um+Pmq4v1sil+gKr6PTfELVcX3tSl+kar4fjbFL1YV39+m+CWq4gfYFL9UVfxAm+KXqYr3tyk+R1X8IJvic1XFB9gUv1xVfKBN8StUxQfZFL9SVXywTfGrVMUrbIpfrSo+xKb4NariQ22KX6sqPsym+HWq4sNtil+vKn6wTfEbVMUPsSl+o6r4CJviN6mKj7QpfrOq+Cib4reoio+2KX6rqvgYm+K3qYofalP8dlXxSpvid6iKj7Upfqeq+Dib4nepio+3KX63qvgEm+L3qIofZlP8XlXxiTbF71MVn2RT/H5V8ck2xR9QFZ9iU/xBVfHDbYo/pCp+hE3xh1XFj7Qp/oiq+FE2xR9VFZ9qU/wxVfFpNsUfVxU/2qb4E6rix9gUf1JVfLpN8adUxY+1Kf60qvhxNsWLquLH2xQnVfETbIo/oyp+ok3xeariJ9kUf1ZV/GSb4s+pip9iU/x5VfFTbYq/oCp+mk3xF1XFT7cp/pKqeJVN8ZdVxWfYFH9FVbzapvirquIzbYq/pio+y6b466ris22Kv6EqfoZN8fmq4mfaFH9TVfwsm+JvqYqfbVP8bVXxc2yKv6Mqfq5N8XdVxc+zKf6eqvj5NsXfVxW/wKb4B6riF9oU/1BV/CKb4h+pil9sU/xjVfFLbIp/oip+qU3xT1XF4/xjKyVnzY2j3GTVjex+pfxvuhvZfRZ1K+mm/dxm2i9spv3SZtqvbKb92mbab2ym/dZm2u9spv3eZtofbKb90Wban2ym/dlm2l9spv3VZtrfbKb93WbaP2ym/dNm2r9spl1gMq3fxGZaz2Za32bawGbalM20aZtpMzbTZm2mzdlMm7eZtmAzbVObaZvZTNvcZtolbKaNevPXGYq3RD0o/6eu+pI2TS1l0lQhpau+tE1Ty9hMu6zNtMvZTLu8zbQr2Ey7os20K9lMu7LNtKvYTNvSZtpVbaZdzWba1W2mbWUz7Ro2065pM21rm2nXspl2bZtp17GZdl2badezmXZ9m2k3sJl2Q5tp29hMu5HNtBvbTLuJzbSb2ky7mc20bW2mbWcz7eY207a3mXYLm2m3tJm2g820W9lM29Fm2q1tpt3GZtptbabdzmbaWLfKK/lOXlV6B5uOOtlM29lm2i4203a1mbabzbTdbabtYTNtT5tpe9lMu6PNtDvZTLuzzbS72Ey7q820u9lM29tm2t1tpu1jM21fm2n3sJl2T5tp97KZdm+bafvZTLuPzbT72ky7n820+9tMe4DNtAfaTNvfZtqDbKYdYDPtQJtpB9lMO9hm2gqbaYfYTDvUZtphNtMOt5n2YJtpD7GZdoTNtCNtph1lM+1om2nH2Ex7qM20lTbTjrWZdpzNtONtpp1gM+1hNtNOtJl2ks20k22mnWIz7eE20x5hM+2RNtMeZTPtVJtpp9lMe7TNtMfYTDvdZtpjbaY9zmba422mPcFm2hNtpj3JZtqTbaY9xWbaU22mPc1m2tNtpq2ymXaGzbTVNtPOtJl2ls20s22mPcNm2jNtpj3LZtqzbaY9x2bac22mPc9m2vNtpr3AZtoLbaa9yGbai22mvcRm2kttpr3MZto5NtPOtZn2cptpr7CZ9kqbaa+ymfZqm2mvsZn2Wptpr7OZ9nqbaW+wmfZGm2lvspn2Zptpb7GZ9labaW+zmfZ2m2nvsJn2Tptp77KZ9m6bae+xmfZem2nvs5n2fptpH7CZ9kGbaR+ymfZhm2kfsZn2UZtpH7OZ9nGbaZ+wmfZJm2mfspn2aZtpizbTks20z9hMO89m2mdtpn3OZtrnbaZ9wWbaF22mfclm2pdtpn3FZtpXbaZ9zWba122mfcNm2vk2075pM+1bNtO+bTPtOzbTvmsz7Xs2075vM+0HNtN+aDPtRzbTfmwz7Sc2035qM63NHXd9mzvu+jZ33PVt7rjr29xx17e5465vc8dd3+aOu/53NtPa3HHXt7njrm9zx13f5o67vs0dd32bO+76Nnfc9W3uuOvb3HHXt7njrm9zx13f5o67vs0ddwObO+4GNnfcDWzuuBvY3HE3sLnjbmBzx93A5o67gc0ddwObO+4GNnfcDWzuuBvY3HE3sLnjbmBzx93A5o67QQubaW1upRssZTPt0jbT2twjN7C5R25gc4/cwOYeuYHNPXIDm3vkBjb3yA1s7pEb2NwjN7C5R25gc4/cwOYeuYHNPXIDm3vkBjb3yA1s7pEb2NwjN7C5R25gc4/cwOYeuYHNPXIDm3vkBjb3yA1s7pEb2NwjN7C5R25gc4/cwOYeuYHNPXIDm3vkBjb3yA3a2kxrc4/cwOYeuYHNPXIDm3vkBjb3yA1s7pEb2NwjN7C5R25gc4/cwOYeuYHNPXIDm3vkBtvbTGtz/9vA5v63gc39bwOb+98GNve/DWzufxvY3P82sLn/bWBz/9vA5v63gc39bwOb+98GNve/DWzufxvY3P82sLn/bWBz/9vA5v63QR+baW3ufxvY3P82sLn/bWBz/9vA5v63gc39bwOb+98GNve/DWzufxvY3P82sLn/bWBz/9vA5v63gc39bwOb+98GNve/DWzufxvY3P82sLn/bWBz/9vA5v63gc39bwOb+98GNve/DWzufxvY3P82sLn/bWBz/9vA5v63gc39bwOb+98GlTbT2tz/NrC5/21gc//bwOb+t4HN/W8Dm/vfBjb3vw1s7n8b2Nz/NrC5/21gc//bwOb+t4HN/W8Dm/vfBjb3vw1s7n8b2Nz/NrC5/21gc//bwOb+t4HN/W8Dm/vfBjb3vw1s7n8b2Nz/NrC5/21gc//bIPL9bzX/+OM6qtKqe+TuUjFydOWkXqOGj5uZnx/07Nlrx5123mXX3Xrv3qfvHnvutXe/ffbdb/8DDux/0ICBgwZXDBk6bPjBh4wYOWr0mEMrx44bP+GwiZMmTzn8iCOPKk4tTiseXTymOL14bPG44vHFE4onFk8qnlw8pXhq8bTi6cWq4oxidXFmcVZxdvGM4pnFs4pnF88pnls8r3h+8YLihcWLihcXLyleWrysOKc4t3h58YrilcWrilcXryleW7yueH3xhuKNxZuKNxdvKd5avK14e/GO4p3Fu4p3F+8p3lu8r3h/8YHig8WHig8XHyk+Wnys+HjxieKTxaeKTxeLRSo+U5xXfLb4XPH54gvFF4svFV8uvlJ8tfha8fXiG8X5xTeLbxXfLr5TfLf4XvH94gfFD4sfFT8uflL8tPhZ8fPiF8Uvi18Vvy5+U/y2+F3x++IPxR+LPxV/Lv5S/LX4W/H34h/FP4t/FReQ14Q8jzyfvIC8FHlp8jLkZcnLkZcnr0BeU/KakdecvCXIa0HekuQtRd7S5C1D3rLkLUfe8uStQN6K5K1E3srkrUJeS/JWJW818lYnrxV5a5C3JnmtyVuLvLXJW4e8dclbj7z1yduAvA3Ja0PeRuRtTN4m5G1K3mbktSWvHXmbk9eevC3I25K8DuRtRV5H8rYmbxvytiVvO/K2J28H8jqR15m8LuR1Ja8bed3J60FeT/J6kbcjeTuRtzN5u5C3K3m7kdebvN3J60NeX/L2IG9P8vYib2/y+pG3D3n7krcfefuTdwB5B5LXn7yDyBtA3kDyBpE3mLwK8oaQN5S8YeQNJ+9g8g4hbwR5I8kbRd5o8saQdyh5leSNJW8ceePJm0DeYeRNJG8SeZPJm0Le4eQdQd6R5B1F3lTyppF3NHnHkDedvGPJO46848k7gbwTyTuJvJPJO4W8U8k7jbzTyasibwZ51eTNJG8WebPJO4O8M8k7i7yzyTuHvHPJO4+888m7gLwLybuIvIvJu4S8S8m7jLw55M0l73LyriDvSvKuIu9q8q4h71ryriPvevJuIO9G8m4i72bybiHvVvJuI+928u4g707y7iLvbvLuIe9e8u4j737yHiDvQfIeIu9h8h4h71HyHiPvcfKeIO9J8p4i72nyiuQRec+QN4+8Z8l7jrznyXuBvBfJe4m8l8l7hbxXyXuNvNfJe4O8+eS9Sd5b5L1N3jvkvUvee+S9T94H5H1I3kfkfUzeJ+R9St5n5H1O3hfkfUneV+R9Td435H1L3nfkfU/eD+T9SN5P5P1M3i/k/Ureb+T9Tt4f5P1J3l/kLSC/Cfke+T75Afkp8tPkZ8jPkp8jP09+gfym5Dcjvzn5S5DfgvwlyV+K/KXJX4b8ZclfjvzlyV+B/BXJX4n8lclfhfyW5K9K/mrkr05+K/LXIH9N8luTvxb5a5O/Dvnrkr8e+euTvwH5G5LfhvyNyN+Y/E3I35T8zchvS3478jcnvz35W5C/JfkdyN+K/I7kb03+NuRvS/525G9P/g7kdyK/M/ldyO9Kfjfyu5Pfg/ye5Pcif0fydyJ/Z/J3IX9X8ncjvzf5u5Pfh/y+5O9B/p7k70X+3uT3I38f8vclfz/y9yf/APIPJL8/+QeRP4D8geQPIn8w+RXkDyF/KPnDyB9O/sHkH0L+CPJHkj+K/NHkjyH/UPIryR9L/jjyx5M/gfzDyJ9I/iTyJ5M/hfzDyT+C/CPJP4r8qeRPI/9o8o8hfzr5x5J/HPnHk38C+SeSfxL5J5N/Cvmnkn8a+aeTX0X+DPKryZ9J/izyZ5N/Bvlnkn8W+WeTfw7555J/Hvnnk38B+ReSfxH5F5N/CfmXkn8Z+XPIn0v+5eRfQf6V5F9F/tXkX0P+teRfR/715N9A/o3k30T+zeTfQv6t5N9G/u3k30H+neTfRf7d5N9D/r3k30f+/eQ/QP6D5D9E/sPkP0L+o+Q/Rv7j5D9B/pPkP0X+0+QXySfynyF/HvnPkv8c+c+T/wL5L5L/Evkvk/8K+a+S/xr5r5P/BvnzyX+T/LfIf5v8d8h/l/z3yH+f/A/I/5D8j8j/mPxPyP+U/M/I/5z8L8j/kvyvyP+a/G/I/5b878j/nvwfyP+R/J/I/5n8X8j/lfzfyP+d/D/I/5P8v8hfQEETCvg116cgoCBFQZqCDAVZCnIU5CkoUNCUgmYUNKdgCQpaULAkBUtRsDQFy1CwLAXLUbA8BStQsCIFK1GwMgWrUNCSglUpWI2C1SloRcEaFKxJQWsK1qJgbQrWoWBdCtajYH0KNqBgQwraULARBRtTsAkFm1KwGQVtKWhHweYUtKdgCwq2pKADBVtR0JGCrSnYhoJtKdiOgu0p2IGCThR0pqALBV0p6EZBdwp6UNCTgl78FT9/Hc9fnfPX3PyVNH99zF/18tey/BUqf93JX03y14j8lR9/PcdfpfHXXvwVFX+dxF/98Nc0/JUKf/3BX1Xw1wr8FQB/XM8frfPH4PyRNX+8zB8F88e2/BErfxzKH13yx4z8kSB/fMcftfHHYvwRFn/cxB8N8cc4/JELfzzCH2Xwxw78EQG/nee33vw2md/S8ttPfqvIb+v4LRi/XeK3Nvw2hN8yMO+Z4sxmJi5zlOnIzGOSMY2u6lMxbnzlqK4Dxg2Y36RnE88PUulMNpcvNG3WfIkWSy619DLLLrf8CiuutPIqLVddbfVWa6zZeq2111l3vfU32LDNRhtvsulmbdtt3n6LLTts1XHrbbbdbvsdOnXu0rVb9x5VVfO956qnXdZp0PDKParnPZv9/IenHxtaVfWfob0aDg2qnte39Tkf/t5x4tb/HRrScKlhDYeKJzf8y+KskOXOqp53+uufvzW9cNpXtWPnhSx3ZcjYDdXzbm7fpmPzfutMrR27KWS+O0OWe7R63hH9D3jnmrXf4y281bSruk0cU1kxduzw0aNmVpX+ZxZ6Rf2DUVH/YHDUP6iI+gcTo/5Bq6h/MDrqH4yP+gfjktfDEPNVGpi8/WB/eI+N+gdtzPfDgKh/UGn+B5FXaZL5Vhpm3sNY8x4iVxge9Q8mm5/uIzfdIXnPuIHTyv8FZXjyzq0JpMNh/wfOGlOi/sERUf/AW/QPVB/5phQ3iPgvkp8EkoFkIDk8QDKQLARIBpKFAMlAshAguSyRTEAykAwkhwdIBpKFAMlAshAgGUgWAiSXJZKfA5KBZCA5PEAykCwESAaShQDJQLIQILkskfwykAwkA8nhAZKBZCFAMpAsBEgGkoUAyWWJ5NeBZCAZSA4PkAwkCwGSgWQhQDKQLARILkskvwUkA8lAcniAZCBZCJAMJAsBkoFkIUByWSL5fSAZSAaSwwMkA8lCgGQgWQiQDCQLAZLLEskfh9x3+RPAGXAGnMMDOAPOQgBnwFkI4Aw4CwGc/w04l/6DWhJ/Bv6Cv+BveMBf8FcI+Av+CgF/wV8h4G/C+PsF+Av+gr/hAX/BXyHgL/grBPwFf4WAvwnj71fgL/gL/oYH/AV/hYC/4K8Q8Bf8FQL+Joy/34C/4C/4Gx7wF/wVAv6Cv0LAX/BXCPibMP5+B/6Cv+BveMBf8FcI+Av+CgF/wV8h4G/C+PsD+Av+gr/hAX/BXyHgL/grBPwFf4WAvwnj70/gL/gL/oYH/AV/hYC/4K8Q8Bf8FQL+Joy/v4C/4C/4Gx7wF/wVAv6Cv0LAX/BXCPibDP56/+Xvb+Av+Av+hgf8BX+FgL/grxDwF/wVAv4mjL9/gL/gL/gbHvAX/BUC/oK/QsBf8FcI+Jsw/v4F/oK/4G94wF/wVwj4C/4KAX/BXyHgb7L4S14T+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5PmXx/+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPk3Bf/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/JuBf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+zcG/8C/8Gx74F/4VAv/Cv0LgX/hXCPybDP/6tf4twL/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/zaDf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+XQL+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3SfgX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t+l4V/4F/4ND/wL/wqBf+FfIfAv/CsE/k2af5eFf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+XR7+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3RfgX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T4d+g1r8rw7/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/7aEf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+XQ3+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPm3FfwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8++a8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv2vBv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/rgP/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vy7HvwL/8K/4YF/4V8h8C/8KwT+hX+FwL/J8G+q1r8bwL/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/7aBf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+3Rj+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3U/gX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t+28C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv5vDv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/bgH/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vzbAf6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N9k+Ddd69+O8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv9vAv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/bgf/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vy7A/wL/8K/4YF/4V8h8C/8KwT+hX+FwL9J829n+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm367wL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/3eFf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn97wr/wL/wbHvgX/hUC/8K/QuBf+FcI/JsM/2Zq/bsj/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz787wL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/u8K/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP/2hn/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/u0D/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L8uwf8C//Cv+GBf+FfIfAv/CsE/oV/hcC/SfPvXvAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb/94F/4F/4ND/wL/wqBf+FfIfAv/CsE/k2Gf7O1/t0X/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T5d3/4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfA+Ff+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn8Pgn/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/h0I/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L8Oxj+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3CPwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8++Y6nmP3fveXXvf1Pmh+U06wr/wbyP1AP/Cv0LgX/hXSAL92y7qH7QFmAHm8ADMSQTzjJml/4BSeUqtMKO65JJNeLHSC9X6ezr8DX/D3+GBv+FvIfA3/C0E/oa/hcDf5e3v0jPXyfoMyBqyhqzDA1lD1kIga8haCGQNWQuBrP//kfXt1fOezX7+w9OPDa2qqh28r3reze3bdGzeb52pdYMPhi35cPW801///K3phdO+qht8KuTP/c1C/txvFza4OX7GDewD++EB9oF9IcD+/y/Yx8+4YXchsHsS7a74g1qS++3hX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/t4B/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af7dEv6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+bcD/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz71bwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/HeFf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn+3hn/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/t0G/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg32T416v177bwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/28G/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP9uD//Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/LsD/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nzbyf4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfzvAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb9d4F/4F/4ND/wL/wqBf+FfIfAv/CsE/k2af7vCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mwz/+rX+7Qb/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vzbHf6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+bcH/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nzb0/4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfXvAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb87wr/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/+4E/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L8uzP8C//Cv+GBf+FfIfAv/CsE/oV/hcC/yfBvUOvfXeBf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn93hX/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/t0N/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T5tzf8C//Cv+GBf+FfIfAv/CsE/oV/hcC/SfPv7vAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb994F/4F/4ND/wL/wqBf+FfIfAv/CsE/k2af/vCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/7gH/wr/wb3jgX/hXCPwL/wqBf+FfIfBvMvybqvXvnvAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb97wb/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/+4N/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L82w/+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3H/gX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t994V/4F/4ND/wL/wqBf+FfIfAv/CsE/k2af/eDf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+3R/+hX/h3/DAv/CvEPgX/hUC/8K/QuDfZPg3XevfA+Bf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn8PhH/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/u0P/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L8exD8C//Cv+GBf+FfIfAv/CsE/oV/hcC/SfPvAPgX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t+B8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv4PgX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/B8O/8C/8Gx74F/4VAv/Cv0LgX/hXCPybDP9mav1bAf/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/DsE/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T5dyj8C//Cv+GBf+FfIfAv/CsE/oV/hcC/SfPvMPgX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t/h8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNvwfDv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/HgL/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vw7Av6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N9k+Ddb69+R8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv6PgX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/R8O/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP+OgX/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/j0U/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T5txL+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3LPwL/8K/4YF/4V8h8C/8KwT+hX+FwL8J82/wePW8Z7Of//D0Y0OrqmoHn62ed3P7Nh2b91tnat3gC2FLvlQ97/TXP39reuG0r+oG3wr589SagDagDWiHB9AGtIUA2oC2EEAb0BYCaP8L0K6eWfoPKJ2l9DDNgpnnKPN86VVoUivqbiEgT/UIG+wJe8PesHd4YG/YWwjsDXsLgb1hbyGw979gb8Uf1Em5F/wL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8++O8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNvzvBv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/7gz/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vy7C/wL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8++u8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv7vBv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/9oZ/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3Gf71av27O/wL/8K/4YF/4V8h8C/8KwT+hX+FwL9J828f+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm377wL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/e8C/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP/uCf/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/LsX/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz797wL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2//eBf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nhn/9Wv/uA//Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/Lsv/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz737wL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/+8O/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP8eAP/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/Hsg/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nzb3/4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfg+Bf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nhn+DWv8OgH/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/h0I/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L8Owj+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3MPwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J828F/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz7xD4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfofAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb/D4F/4F/4ND/wL/wqBf+FfIfAv/CsE/k2Gf1O1/h0O/8K/8G944F/4Vwj8C/8KgX/hXyHwb9L8ezD8C//Cv+GBf+FfIfAv/CsE/oV/hcC/SfPvIfAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb8j4F/4F/4ND/wL/wqBf+FfIfAv/CsE/k2af0fCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/joJ/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af4dDf/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/DsG/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg32T4N13r30PhX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/K+Ff+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn/Hwr/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/46Df+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+HQ//wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vw7Af6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+fcw+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm34nwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/JsO/mVr/ToJ/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af6dDP/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/DsF/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T593D4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfI+Bf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn+PhH/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/j0K/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T5dyr8C//Cv+GBf+FfIfAv/CsE/oV/hcC/yfBvtta/0+Bf+Bf+DQ/8C/8KgX/hXyHwL/wrBP5Nmn+Phn/hX/g3PPAv/CsE/oV/hcC/8K8Q+Ddp/j0G/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T5dzr8C//Cv+GBf+FfIfAv/CsE/oV/hcC/SfPvsfAv/Av/hgf+hX+FwL/wrxD4F/4VAv8mzb/Hwb/wL/wbHvgX/hUC/8K/QuBf+FcI/Js0/x4P/8K/8G944F/4Vwj8C/8KgX/hXyHwb8L8m55SPe/Z7Oc/PP3Y0Kqq2sHp1fNubt+mY/N+60ytGzw+bMkTq+ed/vrnb00vnPZV3WB12J+/DGgD2oB2eABtQFsIoA1oCwG0AW0hgPa/AO3qmaX/gDLfUraPZsHcfpTbv/QqNKkV9a9hIP89bPAP2Bv2hr3DA3vD3kJgb9hbCOwNewuBvf8Feyv+oE7Kf8K/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP/+Bf/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/LsA/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg34T5N9ME/oV/4d/wwL/wrxD4F/4VAv/Cv0Lg36T514N/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af714V/4F/4ND/wL/wqBf+FfIfAv/CsE/k2afwP4F/6Ff8MD/8K/QuBf+FcI/Av/CoF/k+bfFPwL/8K/4YF/4V8h8C/8KwT+hX+FwL/J8K9X6980/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nzbwb+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPk3C//Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/JuDf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+zcO/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP8W4F/4F/4ND/wL/wqBf+FfIfAv/CsE/k2af5vCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/NoN/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3Gf71a/3bHP6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+XcJ+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm3xbwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/S8K/8C/8Gx74F/4VAv/Cv0LgX/hXCPybNP8uBf/Cv/BveOBf+FcI/Av/CoF/4V8h8G/S/Ls0/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz7zLwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/y8K/8C/8Gx74F/4VAv/Cv0LgX/hXCPybDP8Gtf5dDv6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+Xd5+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm3xXgX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/V4R/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af5dCf6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+Xdl+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm31XgX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/W8K/8C/8Gx74F/4VAv/Cv0LgX/hXCPybDP+mav27KvwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8+9q8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv6vDv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/toJ/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af5dA/6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+XdN+Bf+hX/DA//Cv0LgX/hXCPwL/wqBf5Pm39bwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Js2/a8G/8C/8Gx74F/4VAv/Cv0LgX/hXCPybDP+ma/27NvwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8+868C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv+vCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/rgf/wr/wb3jgX/hXCPwL/wqBf+FfIfBv0vy7PvwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8+8G8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNvxvCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/toF/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3Gf7N1Pp3I/gX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t+N4V/4F/4ND/wL/wqBf+FfIfAv/CsE/k2afzeBf+Ff+Dc88C/8KwT+hX+FwL/wrxD4N2n+3RT+hX/h3/DAv/CvEPgX/hUC/8K/QuDfpPl3M/gX/oV/wwP/wr9C4F/4Vwj8C/8KgX+T5t+28C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv+3gX/gX/g0P/Av/CoF/4V8h8C/8KwT+TZp/N4d/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3Gf7N1vq3PfwL/8K/4YF/4V8h8C/8KwT+hX+FwL9J8+8W8C/8C/+GB/6Ff4XAv/CvEPgX/hUC/ybNv1vCv/Av/Bse+Bf+FQL/wr9C4F/4Vwj8mzT/doB/4V/4NzzwL/wrBP6Ff4XAv/CvEPg3af7dCv6Ff+Hf8MC/8K8Q+Bf+FQL/wr9C4N+k+bcj/Av/wr/hgX/hXyHwL/wrBP6Ff4XAv0nz79bwL/wL/4YH/oV/hcC/8K8Q+Bf+FQL/Jsy/2U2q5z2b/fyHpx8bWlVVO9i2et5j97531943dX5ofpOOQDFQ3Eg9AMVAsRCgGCgWkkAUt4v6B22haCg6PFB0mSq6SS2Y2wHMADPAHB6AGWAWAjADzEIAZoBZCMBc9mDeHGAGmAHm8ADMALMQgBlgFgIwA8xCAOayB3N7gBlgBpjDAzADzEIAZoBZCMAMMAsBmMsezFsAzAAzwBwegBlgFgIwA8xCAGaAWQjAXPZg3hJgBpgB5vAAzACzEIAZYBYCMAPMQgDmMgWzVwvmDgAzwAwwhwdgBpiFAMwAsxCAGWAWAjCXPZi3ApgBZoA5PAAzwCwEYAaYhQDMALMQgLnswdwRYAaYAebwAMwAsxCAGWAWAjADzEIA5rIH89YAM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YtwGYAWaAOTwAM8AsBGAGmIUAzACzEIC5TMHs14J5W4AZYAaYwwMwA8xCAGaAWQjADDALAZjLHszbAcwAM8AcHoAZYBYCMAPMQgBmgFkIwFz2YN4eYAaYAebwAMwAsxCAGWAWAjADzEIA5rIH8w4AM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YOwHMADPAHB6AGWAWAjADzEIAZoBZCMBcpmAOasHcGWAGmAHm8ADMALMQgBlgFgIwA8xCAOayB3MXgBlgBpjDAzADzEIAZoBZCMAMMAsBmMsezF0BZoAZYA4PwAwwCwGYAWYhADPALARgLnswdwOYAWaAOTwAM8AsBGAGmIUAzACzEIC57MHcHWAGmAHm8ADMALMQgBlgFgIwA8xCAOYyBXOqFsw9AGaAGWAOD8AMMAsBmAFmIQAzwCwEYC57MPcEmAFmgDk8ADPALARgBpiFAMwAsxCAuezB3AtgBpgB5vAAzACzEIAZYBYCMAPMQgDmsgfzjgAzwAwwhwdgBpiFAMwAsxCAGWAWAjCXPZh3ApgBZoA5PAAzwCwEYAaYhQDMALMQgLlMwZyuBfPOADPADDCHB2AGmIUAzACzEIAZYBYCMJc9mHcBmAFmgDk8ADPALARgBpiFAMwAsxCAuezBvCvADDADzOEBmAFmIQAzwCwEYAaYhQDMZQ/m3QBmgBlgDg/ADDALAZgBZiEAM8AsBGAuezD3BpgBZoA5PAAzwCwEYAaYhQDMALMQgLlMwZypBfPuADPADDCHB2AGmIUAzACzEIAZYBYCMJc9mPsAzAAzwBwegBlgFgIwA8xCAGaAWQjAXPZg7gswA8wAc3gAZoBZCMAMMAsBmAFmIQBz2YN5D4AZYAaYwwMwA8xCAGaAWQjADDALAZjLHsx7AswAM8AcHoB5psUpF2A26QFgNmkaYE7GKxDArPkDgFnzB5HBnK0F814AM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2Y9waYAWaAOTwAM8AsBGAGmIUAzACzEIC57MHcD2AGmAHm8ADMALMQgBlgFgIwA8xCAOayB/M+ADPADDCHB2AGmIUAzACzEIAZYBYCMJc9mPcFmAFmgDk8ADPALARgBpiFAMwAsxCAuUzBnKsF834AM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2Y9weYAWaAOTwAM8AsBGAGmIUAzACzEIC57MF8AMAMMAPM4QGYAWYhADPALARgBpiFAMxlD+YDAWaAGWAOD8AMMAsBmAFmIQAzwCwEYC57MPcHmAFmgDk8ADPALARgBpiFAMwAsxCAuUzBnK8F80EAM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YBwDMADPAHB6AGWAWAjADzEIAZoBZCMBc9mAeCDADzABzeABmgFkIwAwwCwGYAWYhAHPZg3kQwAwwA8zhAZgBZiEAM8AsBGAGmIUAzGUP5sEAM8AMMIcHYAaYhQDMALMQgBlgFgIwlymYC7VgrgCYAWaAOTwAM8AsBGAGmIUAzACzEIC57ME8BGAGmAHm8ADMALMQgBlgFgIwA8xCAOayB/NQgBlgBpjDAzADzEIAZoBZCMAMMAsBmMsezMMAZoAZYA4PwAwwCwGYAWYhADPALARgLnswDweYAWaAOTwAM8AsBGAGmIUAzACzEIC5TMHctBbMBwPMADPAHB6AGWAWAjADzEIAZoBZCMBc9mA+BGAGmAHm8ADMALMQgBlgFgIwA8xCAOayB/MIgBlgBpjDAzADzEIAZoBZCMAMMAsBmMsezCMBZoAZYA4PwAwwCwGYAWYhADPALARgLnswjwKYAWaAOTwAM8AsBGAGmIUAzACzEIC5TMHcrBbMowFmgBlgDg/ADDALAZgBZiEAM8AsBGAuezCPAZgBZoA5PAAzwCwEYAaYhQDMALMQgLnswXwowAwwA8zhAZgBZiEAM8AsBGAGmIUAzGUP5kqAGWAGmMMDMAPMQgBmgFkIwAwwCwGYyx7MYwFmgBlgDg/ADDALAZgBZiEAM8AsBGAuUzA3rwXzOIAZYAaYwwMwA8xCAGaAWQjADDALAZjLHszjAWaAGWAOD8AMMAsBmAFmIQAzwCwEYC57ME8AmAFmgDk8ADPALARgBpiFAMwAsxCAuezBfBjADDADzOEBmAFmIQAzwCwEYAaYhQDMZQ/miQAzwAwwhwdgBpiFAMwAsxCAGWAWAjCXKZiXqAXzJIAZYAaYwwMwA8xCAGaAWQjADDALAZjLHsyTAWaAGWAOD8AMMAsBmAFmIQAzwCwEYC57ME8BmAFmgDk8ADPALARgBpiFAMwAsxCAuezBfDjADDADzOEBmAFmIQAzwCwEYAaYhQDMZQ/mIwBmgBlgDg/ADDALAZgBZiEAM8AsBGAuUzC3qAXzkQAzwAwwhwdgBpiFAMwAsxCAGWAWAjCXPZiPApgBZoA5PAAzwCwEYAaYhQDMALMQgLnswTwVYAaYAebwAMwAsxCAGWAWAjADzEIA5rIH8zSAGWAGmMMDMAPMQgBmgFkIwAwwCwGYyx7MRwPMADPAHB6AGWAWAjADzEIAZoBZCMBcpmBeshbMxwDMADPAHB6AGWAWAjADzEIAZoBZCMBc9mCeDjADzABzeABmgFkIwAwwCwGYAWYhAHPZg/lYgBlgBpjDAzADzEIAZoBZCMAMMAsBmMsezMcBzAAzwBwegBlgFgIwA8xCAGaAWQjAXPZgPh5gBpgB5vAAzACzEIAZYBYCMAPMQgDmMgXzUrVgPgFgBpgB5vAAzACzEIAZYBYCMAPMQgDmsgfziQAzwAwwhwdgBpiFAMwAsxCAGWAWAjCXPZhPApgBZoA5PAAzwCwEYAaYhQDMALMQgLnswXwywAwwA8zhAZgBZiEAM8AsBGAGmIUAzGUP5lMAZoAZYA4PwAwwCwGYAWYhADPALARgLlMwL10L5lMBZoAZYA4PwAwwCwGYAWYhADPALARgLnswnwYwA8wAc3gAZoBZCMAMMAsBmAFmIQBz2YP5dIAZYAaYwwMwA8xCAGaAWQjADDALAZjLHsxVADPADDCHB2AGmIUAzACzEIAZYBYCMJc9mGcAzAAzwBwegBlgFgIwA8xCAGaAWQjAXKZgXqYWzNUAM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YZwLMADPAHB6AGWAWAjADzEIAZoBZCMBc9mCeBTADzABzeABmgFkIwAwwCwGYAWYhAHPZg3k2wAwwA8zhAZgBZiEAM8AsBGAGmIUAzGUP5jMAZoAZYA4PwAwwCwGYAWYhADPALARgLlMwL1sL5jMBZoAZYA4PwAwwCwGYAWYhADPALARgLnswnwUwA8wAc3gAZoBZCMAMMAsBmAFmIQBz2YP5bIAZYAaYwwMwA8xCAGaAWQjADDALAZjLHsznAMwAM8AcHoAZYBYCMAPMQgBmgFkIwFz2YD4XYAaYAebwAMwAsxCAGWAWAjADzEIA5jIF83K1YD4PYAaYAebwAMwAsxCAGWAWAjADzEIA5rIH8/kAM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YLwCYAWaAOTwAM8AsBGAGmIUAzACzEIC57MF8IcAMMAPM4QGYAWYhADPALARgBpiFAMxlD+aLAGaAGWAOD8AMMAsBmAFmIQAzwCwEYC5TMC9fC+aLAWaAGWAOD8AMMAsBmAFmIQAzwCwEYC57MF8CMAPMAHN4AGaAWQjADDALAZgBZiEAc9mD+VKAGWAGmMMDMAPMQgBmgFkIwAwwCwGYyx7MlwHMADPAHB6AGWAWAjADzEIAZoBZCMBc9mCeAzADzABzeABmgFkIwAwwCwGYAWYhAHOZgnmFWjDPBZgBZoA5PAAzwCwEYAaYhQDMALMQgLnswXw5wAwwA8zhAZgBZiEAM8AsBGAGmIUAzGUP5isAZoAZYA4PwAwwCwGYAWYhADPALARgLnswXwkwA8wAc3gAZoBZCMAMMAsBmAFmIQBz2YP5KoAZYAaYwwMwA8xCAGaAWQjADDALAZjLFMwr1oL5aoAZYAaYwwMwA8xCAGaAWQjADDALAZjLHszXAMwAM8AcHoAZYBYCMAPMQgBmgFkIwFz2YL4WYAaYAebwAMwAsxCAGWAWAjADzEIA5rIH83UAM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YrweYAWaAOTwAM8AsBGAGmIUAzACzEIC5TMG8Ui2YbwCYAWaAOTwAM8AsBGAGmIUAzACzEIC57MF8I8AMMAPM4QGYAWYhADPALARgBpiFAMxlD+abAGaAGWAOD8AMMAsBmAFmIQAzwCwEYC57MN8MMAPMAHN4AGaAWQjADDALAZgBZiEAc9mD+RaAGWAGmMMDMAPMQgBmgFkIwAwwCwGYyxTMK9eC+VaAGWAGmMMDMAPMQgBmgFkIwAwwCwGYyx7MtwHMADPAHB6AGWAWAjADzEIAZoBZCMBc9mC+HWAGmAHm8ADMALMQgBlgFgIwA8xCAOayB/MdADPADDCHB2AGmIUAzACzEIAZYBYCMJc9mO8EmAFmgDk8ADPALARgBpiFAMwAsxCAuUzBvEotmO8CmAFmgDk8ADPALARgBpiFAMwAsxCAuezBfDfADDADzOEBmAFmIQAzwCwEYAaYhQDMZQ/mewBmgBlgDg/ADDALAZgBZiEAM8AsBGAuezDfCzADzABzeABmgFkIwAwwCwGYAWYhAHPZg/k+gBlgBpjDAzADzEIAZoBZCMAMMAsBmMsUzC1rwXw/wAwwA8zhAZgBZiEAM8AsBGAGmIUAzGUP5gcAZoAZYA4PwAwwCwGYAWYhADPALARgLnswPwgwA8wAc3gAZoBZCMAMMAsBmAFmIQBz2YP5IYAZYAaYwwMwA8xCAGaAWQjADDALAZjLHswPA8wAM8AcHoAZYBYCMAPMQgBmgFkIwFymYF61FsyPAMwAM8AcHoAZYBYCMAPMQgBmgFkIwFz2YH4UYAaYAebwAMwAsxCAGWAWAjADzEIA5rIH82MAM8AMMIcHYAaYhQDMALMQgBlgFgIwlz2YHweYAWaAOTwAM8AsBGAGmIUAzACzEIC57MH8BMAMMAPM4QGYAWYhADPALARgBpiFAMxlCubVasH8JMAMMAPM4QGYAWYhADPALARgBpiFAMxlD+anAGaAGWAOD8AMMAsBmAFmIQAzwCwEYC57MD8NMAPMAHN4AGaAWQjADDALAZgBZiEAc9mDuQgwA8wAc3gAZoBZCMAMMAsBmAFmIQBz2YOZAGaAGWAOD8AMMAsBmAFmIQAzwCwEYC5TMK9eC+ZnAGaAGWAOD8AMMAsBmAFmIQAzwCwEYC57MM8DmAFmgDk8ADPALARgBpiFAMwAsxCAuezB/CzADDADzOEBmAFmIQAzwCwEYAaYhQDMZQ/m5wBmgBlgDg/ADDALAZgBZiEAM8AsBGAuVzCfU/3aegPGjq2oHNd/0OiRYwaMGz5wREX/0ZUDBvH/M6Gismai/odVDhgzpqJyfpMlp83pMnrU2HEzp83tOryyYtA4f9rlvUaNqxhaUXnpnu3aKtbP+Xsv0t9P7eb+fZNo9btNu6zLgBEjZjStneeKPhUjuOkJFRE7adJwhiDqDNfUrMvgAeMGdBk9ZlJtS93qr1O9yf9e8yUWe827NcKaX9Z33OgxM6qFNXX2UZc53YdXjBiseD45f9hV+Yf+3D4V48ZXjpp2dffRlRXDh46q2VKz+biePK5iUP+Rw8cO6v/3Id6l9gjfbeEBvtffx3dVVfW0a3epGDm6clKnwYNrnj21qy6Md62eNrfv8JFjRlT8vYqL/v/+szrVr7UaPrZ/xcSKQePH1TyLho/qX1nBT6m/n2Jjhg0YW/F/4Rm1uEeT13CGVOM8k7rUX6d6k/Mzqf7hWfegftVpl+4yesIiR3jtYn8/E5v/Z4n/HhL1F13cbdJ1sbeJ1/A5usg2WPSpss7fT5UxlRP6Dx/b7b9HbK9RfWqP1941h+sM9+lQN/eM/z4Falfzkj03k5f3Gy4fvtHrKvz3WXXTiNFD//sCVfvCtPf/+Gk0bDGfRsMa7vB0tBnWbjhDptGfRun6k5d8Gl2yZwdnoa51D+SFutU9kBfqXvdAXqhH3QN5oZ51D+SFetU9kBfase6BvNBOdQ/khXaueyAvtEvdA3mhXeseyAvtVvdAXqh33QN5od3rHsgL9al7IC/Ut+6BvNAedQ/khfaseyAvtFfdA3mhveseyAv1q3sgL7RP3QN5oX3rHsgL7Vf3QF5o/7oH8kIH1D2QFzqw7oG8UP+6B/JCB9U9kBcaUPdAXmhg3QN5oUF1D+SFBtc9kBeqqHsgLzSk7kH9hWRUGJAh4vm/tbt26boXwwZzZ6PNvda0qzsPHzWgchL/0W5jZtdOfCnLYOELf22lehWu7TVq8N9bZ/FeGj2neF2J2vINe/YX5V1Qf8cs8l9S9Vd5kf/ivloyGnu42zioX3px0Td0sY8Bz/AY8P8PHQOpxjwGUvVL/71Mn8V+mz/M/G1+6N7MunszqNsSi2yYXN0Ci4zn67bpZTuOHzlmxm7TLtt59IDBtQtk6maYw+tXWdHwTzPh65Zz1y1Xt6ND/yDv/kG+xB8UrtiZ3+bsMWzAqNAy2Wlza1rqNaR2lQs7/fezizlWB3im4QEeSG3807MiVe+P6r95vK7exyz81qyqapb8rm/alT0rBozpVFk5YFK9oyrTWvyLdPhfZL1ZIe83O0yb8/eCYW9GO7QOf8fp/snfH+F4//huc/L/+N3myYv5bvPkxT7aeuLdJt5t4t0m3m3i3WaC320uutDQugfyQsPqHsgLDa97IC90cN0DeaFD6h7IC42oeyAvNLLugbzQqLoH8kKj6x7IC42peyAvdGjdA3mhyroH8kJj6x7IC42reyAvNL7ugbzQhLoH8kKH1T2QF5pY90BeaFLdA3mhyXUP5IWm1D2QFzq87oG80BF1D+SFjqx7IC90VN0DeaHi1HqP/mGxafUe/cNiR9d79A+LHVPv0T8sNr3eo39Y7Nh6j/5hsePqPfqHxY6v9+gfFjuh3qN/WOzEeo/K5QO57oYfxvTAB3ILP2g52PQDuZPwgdy/dAykGvMYCPlAbvxifyB38v+VD+Qq/09/IDcKH8hVZLr/Gx/IdY/1gdxrbUaNHjd8yKQGv6XqP3bcgMpxzmd1F/yPP6nrupif1HX9//bnVc0W+4Tb1f6Eu8iPqNaq+xHV34eo8+upvjXHZ1VV5B9F1R35//mh7oQBI4YP7j9m/MARwwf1H8S1+9fsG+fIPx9H/r9+5Jc6ppuW3THduu6Y/vvg26vm2Ou98ND776bRHdKL/jT2voWH7ZjK4RMGjKvoP2T8qEH/+YnsuIrKUQNGzG+y4v/48N1xMQ/fHRdb5yHvPnKNfvhm609e8tuThSfukt+MhCwV+tXIZv/wfGnwpqx2XRpQ/T//pZv4RqnB2+hM3dr8/bxcdlHx9qy/Sov8l171V2lxzy49F5uYfsPn8iJvXRZ5Lt9b91SuefL1/vu51/0/T71q8SmcFf9LrjpccIs842f/Az7FXxOL/yX1DzCV/ktmdviP9f9hpf9xkX8+hBu87wx7qcjVvqav/R/NDqqs4L0xuP+o8SNGDB8yvKLyvy/nYypHT5yEF3O8mIf3FOXFvJUL1C5/H3S7/veYi/NKfsPghVuFl+BX7xrvnu0eK8st5rG6bOPs5yZ161M7sfusUl5w1GTatX+/S1+4+G5jZtV+dDK326HjB4wY26Cm3+CDhiDX4DmprO5J1Ztc2nX4hLpneO06/PcYqW37vxui+q76O2/hJu5/6Hg+NCpGjTvLXb1C1Ncm5++bNvJuLNRNLGwP/6r/FKy3WZrUbR/hr7xLdxk/ot5+K7l43/EDQ2ZfxA31jgNnZzStbef/AXmS1CkjsBYA",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "entrypoint",
       "verification_key": "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"
@@ -10560,12 +10928,12 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "H4sIAAAAAAAA/+2cZ3hVRbuG8z5DRywIgkoJIIiKSrFXuqBSBFEsGEOygS0hCTs7QGiysQDWJIC9oBQVRLGLvWCfR+yKYsHexd79zgrRFAJmbeA5l8fz+YcYZu73XdPWrBmu2xUXXbSqQ1pa+sR4JCMtO5YWzY5HYtnpWXlpaeMiseiIgrTcWHRcejySlp4fHzU+Gl/tpiWWdc9KzxjdPWdC7/zsjB7pWVmJhYO69T+iV3HiuuOj8exIXh5SQxRyFqJQwzCkRl1DFGriw2TeNFSp5mGyahGmUMswhVLDFGoVKvPWoUq1CVVql1Cl2qYmlnSPRbOyoiNL/n5OSmHh7MLCFakpf/+fJRZ3y8uLxOInRmI5swuLilekdszsH1vTad5udw/sdWciMXRY+y4f9ylYnlvUY833s9cGVehy/x778p7vjd4U7Nhqs03ZFGxso1iUYau27+0Dc/Ii0cyc7M4DI7Ex+fH0eDQnu3hOWXsHrVD2864Vfju2ws+xOXTBH3G6fLpxlXMvLq6+b9qGer7xITq5+vETcFKTz7BRqAwnVAOyY6aFynBC18pj3IoSiwZHs0dmRUrHQnXZhmmrlHXMMblZEbqCcDMoTOoFVjl1J059YvKTv2h2qDQCdriEJ1U/NDYt/qTCJBeKcOSCgDw71HguCFVqUqhSkzdlia6uhgvR9JWGI4oTC7vFYukFRdWOmyNeZ1752A0Kt56+dME1774+49w1Xy5LefGiq68eckLH3hMubNT8neWnDm//3g0h30P/qzN7ypab2VM2cRYVhHt7TQ0x1jdzZZmaVNOdrlpZpgbscAlPk6wsQfxphcm2do3istYuiRJi7Qg6f0uMaFuXS8V5WF3h4vI+TJT/OH3LzYREuGLTU6t0TohNTsnbOFyz/f20Kl67rlQi1OSbHqILkh9o00rCh4ofLsszJNNxSgAOt0SduQmv4+qpJfGLQ/X4lFBZniXZNIRfyM/ezKWl+lwm/7m0bO4nw2YtLTPKf5y55ZaWGeGKzUzdtC6cHG7fF25pmRGKNVOytASTZka4Zwk3acI9y6xk97DhVr9ZoUqdo/rMmRxuLp2b5LpSHDb+maEKnhWsLOESPS/Z45Vwq2+4j6EpmxK8OmxKiATbKwJbiMC7KQIjRODdN+UYrTroHkluuUMNng6hhk6e4nn2XJHaYM28Zw/v/9i1HbKPrzVt6cP3z3zrwqZduq6Z0s4O6XL+q82GJt87NUIE3ksxLGqGCLy3InCtEIE7KgLXDhG4kyJwnRCBOysC1w0RuIsicL0QgfdRBK4fIvC+isBbhQi8nyJwgxCB91cE3jpE4AMUgbcJEfhAReBtQwQ+SBF4uxCBD1YEbhgi8CGKwNuHCHyoInCjEIEPUwRuHCLw4YrAO4QI3FURuEmIwN0UgZuGCNxdEXjHEIF7KALvFCJwT0XgnUME7qUI3CxE4N6KwM1DBD5CEbhFiMB9FIFbhgjcVxE4NUTgIxWBW4UIfJQicOsQgY9WBG4TInA/ReBdQgTur/jaH6CADlScpx2zRf5BTcqm9E7bEOkNUjzz4C1wZ1E1dHHYe8VZoQqeE5z0hhkVx0qOg4Nz/bPD3pqdF6bNh2yxO6uk581xCujxCuhQBfQEBfREBfQkBfRkBXSYAnqKApqmgJ6qgKYroMMV0AwFNFMBjSigIxTQkQroKAU0qoCepoCOVkCzFNAxCmi2ApqjgOYqoGMV0JgCKrlwjSug+QroOAV0vAI6QQEtUEAnKqCTFNDJCugUBXSqAnq6AuqnSagJCXW6hHqGhHqmhHqWhCo5S/AzJNSZEuosCfUcCfVcCfU8CfV8CfUCCfVCCbVQQi2SUIsl1NkS6hwJda6EepGEerGEeomEeqmEepmEermEeoWEeqWEepWEerWEOk9CvUZCvVZCnS+hLpBQF0qoiyTU6yTU6yXUGyTUxRLqEgn1Rgl1qYR6k4R6s4S6TEK9RUK9VUK9TUK9XUK9Q0K9U0K9S0K9W0JdLqHeI6HeK6HeJ6HeL6E+IKE+KKE+JKE+LKE+IqE+KqGukFAfk1Afl1CfkFCflFCfklCfllCfkVC9hEoJ9VkJdaWE+pyE+ryE+oKE+qKE+pKE+rKE+oqE+qqE+pqEukpCfV1CfUNCXS2hvimhviWhvi2hviOhrpFQ35VQ35NQ35dQP5BQP5RQP5JQP5ZQP5FQP5VQP5NQP5dQv5BQv5RQv5JQ10qoX0uo30io30qo30mo30uoP0ioP0qoP0moP0uov0iov0qov0mov0uof0io/1FQaSkarGmw0GCdBltDg62pwdbSYGtrsHU02LoabD0Ntr4Gu5UG20CD3VqD3UaD3VaD3U6DbajBbq/BNtJgG2uwO2iwTTTYphrsjhrsThrszhpsMw22uQbbQoNtqcGmarCtNNjWGmwbDXYXDbatBttOg91Vg22vwe6mwe6uwe6hwXbQYPfUYPfSYPfWYDtqsJ002M4abBcNdh8Ndl8Ndj8Ndn8N9gAN9kAN9iAN9mAN9hAN9lAN9jAN9nANtqsG202D7a7B9tBge2qwvTTY3hrsERpsHw22rwZ7pAZ7lAZ7tAbbT4Ptr8EO0GAHarDHaLCDNNjBGuyxGuwQDfY4DfZ4DXaoBnuCBnuiBnuSBnuyBjtMgz1Fg03TYE/VYNM12OEabIYGm6nBRjTYERrsSA12lAYb1WBP02BHa7BZGuwYDTZbg83RYHM12LEabEyDzdNg4xpsvgY7ToMdr8FO0GALNNiJGuwkDXayBjtFg52qwZ6uwU7TYBMa7HQN9gwN9kwN9iwN9mwNdoYGO1ODnaXBnqPBnqvBnqfBnq/BXqDBXqjBFmqwRRpssQY7W4Odo8HO1WAv0mAv1mAv0WAv1WAv02Av12Cv0GCv1GCv0mCv1mDnabDXaLDXarDzNdgFGuxCDXaRBnudBnu9BnuDBrtYg12iwd6owS7VYG/SYG/WYJdpsLdosLdqsLdpsLdrsHdosHdqsHdpsHdrsMs12Hs02Hs12Ps02Ps12Ac02Ac12Ic02Ic12Ec02Ec12BUa7GMa7OMa7BMa7JMa7FMa7NMa7DMarNdgqcE+q8Gu1GCf02Cf12Bf0GBf1GBf0mBf1mBf0WBf1WBf02BXabCva7BvaLCrNdg3Ndi3NNi3Ndh3NNg1Guy7Gux7Guz7GuwHGuyHGuxHGuzHGuwnGuynGuxnGuznGuwXGuyXGuxXGuxaDfZrDfYbDfZbDfY7DfZ7DfYHDfZHDfYnDfZnDfYXDfZXDfY3DfZ3DfYPDVbjv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fg01WI3/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv0VnDVbjv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G8xSIPV+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5bxDRYjf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/RbEGq/HfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t7hVg9X4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lu8oMFq/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tNP5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv4XGfwuN/xYa/y00/lto/LfQ+G+h8d9C47+Fxn8Ljf8WGv8tvtFgNf5baPy30PhvofHfQuO/hcZ/C43/Fhr/LTT+W2j8t9D4b6Hx30Ljv3Ua/63T+G+dxn/rNP5bp/HfOo3/1mn8t07jv3Ua/63T+G+dxn/rNP5bp/HfOo3/1mn8t07jv3Ua/63T+G9dQw1W4791Gv+t0/hvncZ/6zT+W6fx3zqN/9Zp/LdO4791Gv+t0/hvncZ/6zT+W6fx3zqN/9Zp/LdO4791Gv+t0/hvncZ/6zT+W6fx3zqN/9Zp/LdO4791Gv+t0/hvncZ/6zT+W6fx3zqN/9Z11mA1/lun8d86jf/Wafy3TuO/dRr/rdP4b53Gf+s0/lun8d86jf/Wafy3TuO/dRr/rdP4b53Gf+s0/lun8d86jf/Wafy3TuO/dRr/rdP4b53Gf+s0/lun8d86jf/Wafy3TuO/dRr/rdP4b90gDVbjv3Ua/63T+G+dxn/rNP5bp/HfOo3/1mn8t07jv3Ua/63T+G+dxn/rNP5bp/HfOo3/1mn8t07jv3Ua/63T+G+dxn/rNP5bp/HfOo3/1mn8t07jv3Ua/63T+G9d0v7b4gDbMbN/bE2nebvdPbDXnYnE0GHtu3zcp2B5blGPNd/PXhvUaBcqdChHbr/ImJxYQd/saHx2ymrXp/1uu+/RYc+99u7YqXOXffbdb/8DDjzo4EMOPezwrt269+jZq/cRffoeedTR/foPGHjMoMHHDjnu+KEnnHjSycNOSTs1fXhGZmTEyFHR00ZnjcnOyR0by4vnjxs/oWDipMlTpp7up/mEn+7P8Gf6s/zZfoaf6Wf5c/y5/jx/vr/AX+gLfZEv9rP9HD/XX+Qv9pf4S/1l/nJ/hb/SX+Wv9vP8Nf5aP98v8Av9In+dv97f4Bf7Jf5Gv9Tf5G/2y/wt/lZ/m7/d3+Hv9Hf5u/1yf4+/19/n7/cP+Af9Q/5h/4h/1K/wj/nH/RP+Sf+Uf9o/472nf9av9M/55/0L/kX/kn/Zv+Jf9a/5Vf51/4Zf7d/0b/m3/Tt+jX/Xv+ff9x/4D/1H/mP/if/Uf+Y/91/4L/1Xfq3/2n/jv/Xf+e/9D/5H/5P/2f/if/W/+d/9H/4/tBSa0UBztBq0mrRatNq0OrS6tHq0+rStaA1oW9O2oW1L247WkLY9rRGtMW0HWhNaU9qOtJ1oO9Oa0ZrTWtBa0lJprWitaW1ou9Da0trRdqW1p+1G2522B60DbU/aXrS9aR1pnWidaV1o+9D2pe1H2592AO1A2kG0g2mH0A6lHUY7nNaV1o3WndaD1pPWi9abdgStD60v7UjaUbSjaf1o/WkDaANpx9AG0QbTjqUNoR1HO542lHYC7UTaSbSTacNop9DSaKfS0mnDaRm0TFqENoI2kjaKFqWdRhtNy6KNoWXTcmi5tLG0GC2PFqfl08bRxtMm0ApoE2mTaJNpU2hTaafTptEStOm0M2hn0s6inU2bQZtJm0U7h3Yu7Tza+bQLaBfSCmlFtGLabNoc2lzaRbSLaZfQLqVdRrucdgXtStpVtKtp82jX0K6lzactoC2kLaJdR7uedgNtMW0J7UbaUtpNtJtpy2i30G6l3Ua7nXYH7U7aXbS7actp99Dupd1Hu5/2AO1B2kO0h2mP0B6lraA9Rnuc9gTtSdpTtKdpz9A8jbRnaStpz9Gep71Ae5H2Eu1l2iu0V2mv0VbRXqe9QVtNe5P2Fu1t2ju0NbR3ae/R3qd9QPuQ9hHtY9ontE9pn9E+p31B+5L2FW0t7WvaN7Rvad/Rvqf9QPuR9hPtZ9ovtF9pv9F+p/1B+w+RQhgBwhE1iJpELaI2UYeoS9Qj6hNbEQ2IrYltiG2J7YiGxPZEI6IxsQPRhGhK7EjsROxMNCOaEy2IlkQq0YpoTbQhdiHaEu2IXYn2xG7E7sQeRAdiT2IvYm+iI9GJ6Ex0IfYh9iX2I/YnDiAOJA4iDiYOIQ4lDiMOJ7oS3YjuRA+iJ9GL6E0cQfQh+hJHEkcRRxP9iP7EAGIgcQwxiBhMHEsMIY4jjieGEicQJxInEScTw4hTiDTiVCKdGE5kEJlEhBhBjCRGEVHiNGI0kUWMIbKJHCKXGEvEiDwiTuQT44jxxASigJhITCImE1OIqcTpxDQiQUwnziDOJM4iziZmEDOJWcQ5xLnEecT5xAXEhUQhUUQUE7OJOcRc4iLiYuIS4lLiMuJy4griSuIq4mpiHnENcS0xn1hALCQWEdcR1xM3EIuJJcSNxFLiJuJmYhlxC3ErcRtxO3EHcSdxF3E3sZy4h7iXuI+4n3iAeJB4iHiYeIR4lFhBPEY8TjxBPEk8RTxNPEN4gsSzxEriOeJ54gXiReIl4mXiFeJV4jViFfE68QaxmniTeIt4m3iHWEO8S7xHvE98QHxIfER8THxCfEp8RnxOfEF8SXxFrCW+Jr4hviW+I74nfiB+JH4ifiZ+IX4lfiN+J/4g/kOXQlfyT5jpHF0Nupp0tehq09Whq0tXj64+3VZ0Dei2ptuGblu67ega0m1P14iuMd0OdE3omtLtSLcT3c50zeia07Wga0mXSteKrjVdG7pd6NrStaPbla59cO0fXNEH1+nB1XdwTR1cKQfXv8FVbXCtGlyBBteVwdVicA0YXNkF12vBVVhwbRVcMQXXQcHVTXDNElyJBNcXwVVDcC0QHOEHx+3B0XhwjB0cOQfHw8FRbnDsGhyRBseZwdFjcEwYHOkFx2/BUVlwrBUcQQXHRcHRTnAMExyZBMcbwVFEcGwQfOIHn+PBp3PwmRt8kgafj8GnXvBZFnxCBZ87wadJ8BkRbPmD7XmwlQ62vcEWNdhOBlu/YJsWbKmCrc3iQZF4fiy7Z3o8fXVK+xSDq1GzVu06devV36rB1ttsu13D7Rs13qFJ0x132rlZ8xYtU1u1brNL23a7FhbOKU4s6JYRjTUuXvlc7c++e+bxkYWFf/6qSdVftShe+dqOjds0O/m1x//61X7FK7/I32a/F9gqa3VKRmJxrwm5sUheXjQne3Zh9XbVgclWGJVshfRkK+QlWyGSbIXUZCtk/PNaKTvZCiP/ec2aKU8pLo+Q8c9LKVPecTny0Zp0SiOSrZAvfwb90Ij+CzpuvPyh4/LVO+mHzv3va/cf8drVL/ejk62wl7xZ+8rX1tR/3hSNyudD6r8gpaTnwwT5yvf/ckfWQd7T+fLBp38/tEm2wknyt2iWvELSW7ikN1hp/93NKFrpv4cIYSoMS7ZCytziVe3T191XpmXkjMlNj0eHZ0XScmLpGcEf4yKxElDa+Fh6bm4ktjpl28TCHjnZefHZiUU9o7FIRhyJ6/pmxyMjI7H5Q7p0rv4ac/36llT9ab3Wr5+SXPxeiQU90rOyiuqXca4fFMkKHnpcJMknSalKcMkSbizJJTM48+yRk1tQ9ki9KuZUAV6a+dabnXmvLZD5gsHxnNyi4o1kul4f9VjYOxrJqv7fp7Rav2LPkBVTFpUeHyeW9M6JRaIjs0taam4wrifGIxlpY6J5GWmlQ7xH2QgfsG6AH1c6vksOiJeW3px3y8wsmT1lqW/k9z2LE4sGR8fkZkVKU6z8f3+mU7wqNZqXFpkQyciPl8yiaHZaLBJMqdIpljsqPS/yb5hRmzuarCqhxpaZST0q5lQBHsykisOz/IeKURPz++WMqzTCy4qVzsQGf5b4a0hULLq5bdJzs9vEqs7RSm1Qeaq0K50qubFxadG8Xn+N2L7Zg8rG68CS4Vq0/nQoZxf9NQXK0rx2SKeNl0fV8htu9PII5bMqLxJPC9IZFeQbiY5JH1n2vip7T7X9982qJPt/A2Ow5hafVTUqwjf3vdRjszO29YdPjfLuq8KulWx7LukezU4v+bdV8QG5c8vA84OhvW7klkWqEGFp3+zM0jbb3MlcOXh5iLLwVZ8ZldcnV7FjKv1NjYopV/qbmhW7onTVa/I3U7TG+n/nyhfH0tqt/w/sXjbYz7XX72dX3kaVmqxOeYFKv69b3toLjswfk1vUMrHg6Jz0zLICtcoJC4P8YpGqVWttOLc66+dWp3wIbLBC3fUr1K2mQr3rjw5W72NHpWdvMEztxKKSR+o7oizlejuXbck2PHBrVB24qJBExZfT8vJ3U7Dw9wnW/YF/Lvsl+7Yb+kTSc7vFYukFFee9bfxFVZxYWFq8qPKmzTa8h1tWOoGDmsH+reRleOn6S3vjzXy1NNoyy3JKeT5l4PVfgmH304mlpb22rviA3DllY3pRr7H56Vl5VWKiyghwdaq8QkNGt41FT5nfMzqufJ0ty+Gv6Vz22H81RPE9FTtvXROnjc3PiUcj2fFL1k+v3qa+X/+sX38Ld2O9cvBG2gOL/wxYoVlSyttnI7Vsfr/8rAr9Vm3xwfnDN0CvtLhVGAfrdUb9ssf5H6bWtIeeZAEA",
       "custom_attributes": [
         "abi_private",
         "abi_view"
       ],
-      "debug_symbols": "rZbbbqMwEIbfhetc2HPw2HmVVVXRlFZIiEQ0qbSq8u47TmwOqrBStjf5Y8Afc8Zf1Wvzcnl/bvu340e1//NVvQxt17Xvz93xUJ/bY69XvyoTfyxVe7zuKntbYLUHXUBcoN6xuwpZ5aoX897n89A08YEZTF9xqoemP1f7/tJ1u+qz7i63hz5OdX/Tcz3oXbOrmv5VVYFvbdfEf9fdtNusb2Uf0mYHMm63wT8KcAETQCiMAICHLbBsJBEsBzNDwKMIDw4SwiNMCAt2gaCCFeh9toJwkxVAJiOAGFetcAUEmJwOAOdHhJcFQQp+GCs5FtYobmRgWKbEr0NCsLmkQmBZRYR1BFIuCw3sBDDLaNpCONGRywjHtI0RLGVGmJXnNwaUGJLTSsbylFb5gRliRzNk3YxicXnOlcEYVovLcqk2AO1UG25KrPwEQjh2iqFAa5DS0GHOCJ63/DdnCjWKxkGOiP6XVTvKkCC50tEadBucIbS5ZwnFrTpTGoHTELUyK3XS9p0joFCmPKWFiacCIeIlAwsMZ/LsYGdpnVEYpIBmrFOYEdyjwRAwuWcFEFbjCaU5qtaP7eLArOYVpJTYjCBvt3waWUKeYOzBr3sSfqHMyxABGCEidiMkTBDPmy2xMwhvg/x/17LA2C7B0ZaulTB+aUW/mEvEky7rQzssD4dWj32aTevigUNVkvqk4a5g4kxQtUkhDgZVTEqxDlU5qfJALQVJ6pOG+35UXgw7Ki+6jRCDqIpJ43E1nUpv6pJKUuWh+orhrmSS2qSRp3YT3t9HlJSTRp42NUlSnzTclZO/nPxlSJp4HO2LpfJZD2390jUxmDHel/6QY6vL899TvpOP5qfheGheL0MT83BLwf0UrodrHYSIT9eYqn8=",
+      "debug_symbols": "rZbbbuIwEIbfJddceGY8HptXWVVVStMKKQKUQqUV4t13DHYOWtmi2b3hx0n8Zc7xtXnv3i6fr/vDx/Gr2f66Nm/Dvu/3n6/9cdee98eDXr02Jv6AbbZ02zRwX1CzRV1gXJDegU1DrHLTi3nv63nouvjADKavOLVDdzg328Ol7zfNd9tf7g99ndrDXc/toHfNpukO76oK/Nj3Xfx320y7TXkr+5A2O5RxO4TwLMAFSgCxYQQgwrMAYCOJABzMDEHPIjw6TAhPOCEAcYGwFSvI+2yFpVVWoDUZgZapaIWrINDkdCA6PyK8XxCk4ocBybEAo7iRQWGZEl+GhAC5pEJgKSJCGUE2l4UGdgRYu6wrqISThCEjhMMqhjWQ42kN2zIDK3YE8SMDeEqr/MAMcSPCl82oFpfnXBlMoVhcwLXaQIKpNtyUWIEfQCyNnWJssCVIbegwZwTPW/4vZyo1SsZhjoj+l6IddUiQXOkEhtwKZyxNNUbiis7URuA0REHmZQrLOY6VMuUpLWzn7cK8ZFCF4UyeHezAlhmVQYpkxjrFGcE9GwxBY/MXBQmL8cTaHFXrx3ZxaIp5RaklNiOshzWfRpaQ2549+rIn4T+UeR0iiCNEBFZCwgTxvNoSmEF4HeTfu5YFx3YJzq7pWgnjl1b0i7lEvOiy3e2H5eEQ9Nin2QQXDxyqktQnDQ9FE2eCKiTFOBhUKamNdajKSZWHailKUp80PPaT8mLYSXnRbcIYRFVKGo+r6VR6V5dUkiqP1FcKD7UmKSSNPLXb0uN91iblpJGnTW0lqU8aHsrJX07+MiZNPI72xVL5bod9+9Z3MZgx3pfDLsdWl+ffp3wnH81Pw3HXvV+GLubhnoLHKVwP1zoIiV5uMVV/AA==",
       "is_unconstrained": false,
       "name": "verify_private_authwit",
       "verification_key": "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"
@@ -10574,6 +10942,10 @@
       "abi": {
         "abi_version": 1,
         "error_types": {
+          "14732586658580788962": {
+            "error_kind": "string",
+            "string": "Option None payload must be zero"
+          },
           "14990209321349310352": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
@@ -10586,6 +10958,10 @@
             "error_kind": "string",
             "string": "offchain message anchor timestamp is implausibly far in the future"
           },
+          "8982672503184277440": {
+            "error_kind": "string",
+            "string": "BoundedVec length exceeds max"
+          },
           "9530675838293881722": {
             "error_kind": "string",
             "string": "Writer did not write all data"
@@ -10697,11 +11073,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "offchain_receive"
     },
@@ -10724,6 +11100,10 @@
             "error_kind": "string",
             "string": "extend_from_bounded_vec out of bounds"
           },
+          "12298769080096853643": {
+            "error_kind": "string",
+            "string": "BoundedVec length is not u32"
+          },
           "12706857619424059571": {
             "error_kind": "fmtstring",
             "item_types": [],
@@ -10745,10 +11125,32 @@
             "error_kind": "string",
             "string": "push out of bounds"
           },
+          "14732586658580788962": {
+            "error_kind": "string",
+            "string": "Option None payload must be zero"
+          },
           "14990209321349310352": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "16204057084063766501": {
+            "error_kind": "fmtstring",
+            "item_types": [
+              {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
+              }
+            ],
+            "length": 57
+          },
           "16431471497789672479": {
             "error_kind": "string",
             "string": "Index out of bounds"
@@ -10789,6 +11191,19 @@
             "error_kind": "string",
             "string": "get_shared_secrets: response length does not match request length"
           },
+          "8982672503184277440": {
+            "error_kind": "string",
+            "string": "BoundedVec length exceeds max"
+          },
+          "9469988605042831545": {
+            "error_kind": "fmtstring",
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ],
+            "length": 36
+          },
           "9530675838293881722": {
             "error_kind": "string",
             "string": "Writer did not write all data"
@@ -10826,11 +11241,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_utility"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "sync_state"
     },
@@ -11228,5 +11643,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "6.0.0-rc.3"
+  "aztec_version": "6.0.0"
 }