@aztec/protocol-contracts 0.0.1-commit.321f6a9 → 0.0.1-commit.330febf

package/artifacts/FeeJuice.json

@@ -597,7 +597,7 @@
           "start": 16359
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+      "path": "/home/aztec-dev/aztec-packages/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).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
     "188": {
@@ -675,7 +675,7 @@
           "start": 6512
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/merkle_tree.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/merkle_tree/merkle_tree.nr",
       "source": "use crate::{\n    constants::{\n        DOM_SEP__MERKLE_HASH, DOM_SEP__NULLIFIER_MERKLE, DOM_SEP__PUBLIC_DATA_MERKLE,\n        DOM_SEP__RETRIEVED_BYTECODES_MERKLE, DOM_SEP__WRITTEN_SLOTS_MERKLE,\n    },\n    hash::{accumulate_sha256, poseidon2_hash_with_separator},\n    traits::Empty,\n    utils::math::is_power_of_2_u32,\n};\n\n/// Merkle-node hash used by append-only trees.\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash_with_separator([left, right], DOM_SEP__MERKLE_HASH)\n}\n\n/// Merkle-node hash for the nullifier tree's sibling paths.\npub fn nullifier_merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash_with_separator([left, right], DOM_SEP__NULLIFIER_MERKLE)\n}\n\n/// Merkle-node hash for the public-data tree's sibling paths.\npub fn public_data_merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash_with_separator([left, right], DOM_SEP__PUBLIC_DATA_MERKLE)\n}\n\n/// Merkle-node hash for the AVM-internal written-public-data-slots tree's sibling paths.\npub fn written_slots_merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash_with_separator([left, right], DOM_SEP__WRITTEN_SLOTS_MERKLE)\n}\n\n/// Merkle-node hash for the AVM-internal retrieved-bytecodes (class-id) tree's sibling paths.\npub fn retrieved_bytecodes_merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash_with_separator([left, right], DOM_SEP__RETRIEVED_BYTECODES_MERKLE)\n}\n\npub fn sha_merkle_hash(left: Field, right: Field) -> Field {\n    accumulate_sha256(left, right)\n}\n\n/// A balanced Merkle tree over `N` leaves (`N` must be a power of 2).\n///\n/// Leaves are stored and consumed as-is; the internal nodes are built by `compute_merkle_tree_nodes`,\n/// which applies `hasher` at every layer with no domain separation between the leaf layer and the\n/// internal-node layers. Callers must therefore pass leaves that are already domain-separated from the\n/// node hashes (see the warning on `compute_merkle_tree_nodes`).\n#[derive(Eq)]\npub struct MerkleTree<let N: u32> {\n    pub leaves: [Field; N],\n    pub nodes: [Field; N - 1],\n}\n\nimpl<let N: u32> Empty for MerkleTree<N> {\n    fn empty() -> Self {\n        MerkleTree { leaves: [0; N], nodes: [0; N - 1] }\n    }\n}\n\nimpl<let N: u32> MerkleTree<N> {\n    pub fn new(leaves: [Field; N]) -> Self {\n        let nodes = compute_merkle_tree_nodes(leaves, merkle_hash);\n        MerkleTree { leaves, nodes }\n    }\n\n    pub fn new_with_hasher(leaves: [Field; N], hasher: fn(Field, Field) -> Field) -> Self {\n        let nodes = compute_merkle_tree_nodes(leaves, hasher);\n        MerkleTree { leaves, nodes }\n    }\n\n    pub fn new_sha(leaves: [Field; N]) -> Self {\n        let nodes = compute_merkle_tree_nodes(leaves, sha_merkle_hash);\n        MerkleTree { leaves, nodes }\n    }\n\n    pub fn get_root(self) -> Field {\n        self.nodes[N - 2]\n    }\n\n    pub fn get_sibling_path<let K: u32>(self, leaf_index: u32) -> [Field; K] {\n        assert_eq(2.pow_32(K as Field), N as Field, \"Invalid path length\");\n\n        let mut path = [0; K];\n        let mut current_index = leaf_index;\n        let mut subtree_width = N;\n\n        let mut current_sibling_index = sibling_index(current_index);\n\n        path[0] = self.leaves[current_sibling_index];\n\n        let mut subtree_offset: u32 = 0;\n\n        for i in 1..K {\n            current_index = current_index / 2;\n            subtree_width = subtree_width / 2;\n\n            current_sibling_index = sibling_index(current_index);\n\n            path[i] = self.nodes[subtree_offset + current_sibling_index];\n\n            subtree_offset += subtree_width;\n        }\n\n        path\n    }\n}\n\npub fn sibling_index(index: u32) -> u32 {\n    if index % 2 == 0 {\n        index + 1\n    } else {\n        index - 1\n    }\n}\n\n/// Computes the `N - 1` internal nodes of a balanced Merkle tree from its `N` leaves (root last);\n/// `N` must be a power of 2 greater than 1.\n///\n/// Leaves are consumed as-is: this helper does not hash leaf preimages, it only hashes pairs upward.\n/// The same `hasher` is applied at every layer (the leaf/base layer and all internal-node layers\n/// alike), so there is NO domain separation between the leaf hashing and the internal-node hashing. An\n/// internal node is therefore just `hasher(left, right)`, indistinguishable in form from a leaf.\n///\n/// WARNING: because of this, callers MUST pass leaves that are already domain-separated from this\n/// helper's internal-node hashes (i.e. produced by a hash whose domain differs from `hasher`), so that\n/// an internal-node value can never be a valid leaf. (Per-tree domain separation of the node hashing\n/// itself is likewise the caller's choice: pass the tree-specific hasher, e.g. `nullifier_merkle_hash`.)\npub fn compute_merkle_tree_nodes<let N: u32>(\n    leaves: [Field; N],\n    hasher: fn(Field, Field) -> Field,\n) -> [Field; N - 1] {\n    // Note: `N` must be a power of 2.\n    std::static_assert(is_power_of_2_u32(N), \"N must be a power of 2\");\n    std::static_assert(N != 1, \"2 must divide N\");\n\n    let mut nodes = [0; N - 1];\n\n    let total_nodes = N - 1;\n    let half_size = N / 2;\n\n    // Hash base layer.\n    for i in 0..half_size {\n        nodes[i] = hasher(leaves[2 * i], leaves[2 * i + 1]);\n    }\n\n    // Hash the other layers.\n    for i in 0..(total_nodes - half_size) {\n        nodes[half_size + i] = hasher(nodes[2 * i], nodes[2 * i + 1]);\n    }\n\n    nodes\n}\n\nmod tests {\n    use super::{compute_merkle_tree_nodes, MerkleTree};\n\n    // A trivial, collision-prone hasher that makes the absence of leaf/internal-node domain separation\n    // observable: each node is simply the sum of its two children.\n    fn add_hasher(left: Field, right: Field) -> Field {\n        left + right\n    }\n\n    #[test]\n    fn leaves_and_internal_nodes_share_one_hasher() {\n        // base layer: 1+2=3, 3+4=7 ; internal layer (root last): 3+7=10\n        let nodes = compute_merkle_tree_nodes([1, 2, 3, 4], add_hasher);\n        assert_eq(nodes, [3, 7, 10]);\n    }\n\n    #[test]\n    fn internal_node_value_hashes_identically_as_a_leaf() {\n        // Feeding the internal-node values 3 and 7 back in as *leaves* yields the same root (10): the\n        // helper hashes the leaf layer and the internal-node layers with one hasher, so an internal\n        // node is indistinguishable in form from a leaf. Callers must pass domain-separated leaves.\n        let nodes = compute_merkle_tree_nodes([3, 7, 0, 0], add_hasher);\n        assert_eq(nodes[nodes.len() - 1], 3 + 7);\n    }\n\n    #[test]\n    fn merkle_tree_root_is_last_node() {\n        let tree = MerkleTree::new_with_hasher([1, 2, 3, 4], add_hasher);\n        assert_eq(tree.get_root(), 10);\n        assert_eq(tree.get_root(), tree.nodes[tree.nodes.len() - 1]);\n    }\n}\n"
     },
     "190": {
@@ -721,7 +721,7 @@
           "start": 3093
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
       "source": "use crate::merkle_tree::merkle_tree::{compute_merkle_tree_nodes, merkle_hash, sha_merkle_hash};\n\n/// Calculate the Merkle tree root from the sibling path and leaf, using the default merkle hash.\npub fn root_from_sibling_path<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n) -> Field {\n    root_from_sibling_path_with_hasher(leaf, leaf_index, sibling_path, merkle_hash)\n}\n\n/// Calculate the Merkle tree root from the sibling path and leaf, using a custom hasher.\n///\n/// The leaf is hashed with its sibling, the result is then hashed with the next sibling in the path. and so on.\n/// The last hash is the root.\npub fn root_from_sibling_path_with_hasher<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n    hasher: fn(Field, Field) -> Field,\n) -> Field {\n    let mut node = leaf;\n    let indices: [bool; N] = leaf_index.to_le_bits();\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = hasher(hash_left, hash_right);\n    }\n    node\n}\n\npub fn compute_tree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    compute_tree_root_with_hasher(leaves, merkle_hash)\n}\n\npub fn compute_sha_tree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    compute_tree_root_with_hasher(leaves, sha_merkle_hash)\n}\n\npub fn compute_tree_root_with_hasher<let N: u32>(\n    leaves: [Field; N],\n    hasher: fn(Field, Field) -> Field,\n) -> Field {\n    compute_merkle_tree_nodes(leaves, hasher)[N - 2]\n}\n\npub fn compute_empty_tree_root<let TreeHeight: u32>() -> Field {\n    compute_empty_tree_root_with_hasher::<TreeHeight>(merkle_hash)\n}\n\npub fn compute_empty_sha_tree_root<let TreeHeight: u32>() -> Field {\n    compute_empty_tree_root_with_hasher::<TreeHeight>(sha_merkle_hash)\n}\n\npub fn compute_empty_tree_root_with_hasher<let TreeHeight: u32>(\n    hasher: fn(Field, Field) -> Field,\n) -> Field {\n    let mut hashes = [0; TreeHeight + 1];\n    for i in 1..TreeHeight + 1 {\n        hashes[i] = hasher(hashes[i - 1], hashes[i - 1]);\n    }\n    hashes[TreeHeight]\n}\n\n#[test]\nfn test_merkle_roots_match_typescript() {\n    // The following hardcoded values are generated from yarn-project/foundation/src/trees/balanced_merkle_tree_root.test.ts\n\n    let root = compute_tree_root([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);\n    let expected_tree_root_from_ts =\n        0x2bc86dba04dfdd6352c3b1c66b2300445964e2888aa52fdb023d2e645a3d3399;\n    assert_eq(root, expected_tree_root_from_ts);\n\n    let empty_root = compute_tree_root([0; 16]);\n    let expected_empty_root_from_ts =\n        0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da;\n    assert_eq(empty_root, expected_empty_root_from_ts);\n\n    let sha_root = compute_sha_tree_root([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);\n    let expected_sha_root_from_ts =\n        0x00b007869b8a5e2a9b3b580a318e702cea04b2f5438f2e26743f545e4d1ecbdb;\n    assert_eq(sha_root, expected_sha_root_from_ts);\n}\n\n#[test]\nfn test_empty_tree_root() {\n    assert_eq(compute_empty_tree_root::<0>(), 0);\n\n    assert_eq(\n        compute_empty_tree_root::<1>(),\n        0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb,\n    );\n\n    assert_eq(\n        compute_empty_tree_root::<2>(),\n        0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d,\n    );\n\n    assert_eq(\n        compute_empty_tree_root::<6>(),\n        0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f,\n    );\n\n    assert_eq(\n        compute_empty_tree_root::<10>(),\n        0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f,\n    );\n}\n"
     },
     "213": {
@@ -735,7 +735,7 @@
           "start": 587
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{\n    constants::DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, hash::poseidon2_hash_with_separator,\n    traits::ToField,\n};\n\n// TODO: Move this to src/public_data/storage/map.nr\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash_with_separator(\n        [storage_slot, key.to_field()],\n        DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,\n    )\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x2d225f361108379adc2da91378b9702675c5546b57e78bafc1e74ec7fec55967;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
     "221": {
@@ -885,7 +885,7 @@
           "start": 6145
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
+      "path": "/home/aztec-dev/aztec-packages/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"
     },
     "240": {
@@ -977,7 +977,7 @@
           "start": 1426
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
+      "path": "/home/aztec-dev/aztec-packages/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"
     },
     "244": {
@@ -1003,7 +1003,7 @@
           "start": 12477
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/serialization.nr",
       "source": "use crate::{reader::Reader, writer::Writer};\n\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n///     let N: u32 = N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         let bytes = self.as_bytes();\n///         for i in 0..bytes.len() {\n///             writer.write(bytes[i] as Field);\n///         }\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n    let N: u32;\n\n    fn serialize(self) -> [Field; Self::N];\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n///     fields: [Field; N],\n///     length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n///     let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     #[inline_always]\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         Serialize::stream_serialize(self.fields, writer);\n///         Serialize::stream_serialize(self.length, writer);\n///     }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n\n    // We care only about the name and type so we drop the last item of the tuple\n    let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Serialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_serialize_clause = get_where_trait_clause(s, quote { Serialize });\n\n    let params_len_quote = get_params_len_quote(params);\n\n    let function_body = params\n        .map(|(name, _typ): (Quoted, Type)| {\n            quote {\n                $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n            }\n        })\n        .join(quote {});\n\n    quote {\n        impl$generics_declarations $crate::serialization::Serialize for $typ\n            $where_serialize_clause\n        {\n            let N: u32 = $params_len_quote;\n\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n                writer.finish()\n            }\n\n\n            #[inline_always]\n             fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n///     let N: u32 = M;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let mut bytes = [0 as u8; M];\n///         for i in 0..M {\n///             bytes[i] = reader.read() as u8;\n///         }\n///         str::<M>::from(bytes)\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n    let N: u32;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self;\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n///     let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     #[inline_always]\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n///         let y = <Field as Deserialize>::stream_deserialize(reader);\n///         Self { x, y }\n///     }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Deserialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_deserialize_clause = get_where_trait_clause(s, quote { Deserialize });\n\n    // The following will give us:\n    // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n    // (or 0 if the struct has no members)\n    let right_hand_side_of_definition_of_n = if params.len() > 0 {\n        params\n            .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n            <$param_type as $crate::serialization::Deserialize>::N\n        }\n            })\n            .join(quote {+})\n    } else {\n        quote { 0 }\n    };\n\n    // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let function_body = if params.len() > 1 {\n        // This generates deserialization code for each struct member and concatenates them together.\n        let deserialization_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            $deserialization_of_struct_members\n\n            Self { $struct_members }\n        }\n    } else if params.len() == 1 {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n        }\n    } else {\n        quote {\n            Self {}\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::serialization::Deserialize for $typ\n            $where_deserialize_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_n;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n\n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n///              to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n                    <$param_type as $crate::serialization::Serialize>::N\n                }\n            })\n            .join(quote {+});\n        quote { ($params_quote_without_parentheses) }\n    }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n    let generics = s.generics();\n\n    if generics.len() > 0 {\n        let generics_declarations_items = generics\n            .map(|(name, maybe_integer_typ)| {\n                // The second item in the generics tuple is an Option of an integer type that is Some only if\n                // the generic is numeric.\n                if maybe_integer_typ.is_some() {\n                    // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n                    let integer_type = maybe_integer_typ.unwrap();\n                    quote {let $name: $integer_type}\n                } else {\n                    // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n                    quote { $name }\n                }\n            })\n            .join(quote {,});\n        quote {<$generics_declarations_items>}\n    } else {\n        // The struct doesn't have any generics defined, so we just return an empty quote.\n        quote {}\n    }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n    let generics = s.generics();\n\n    // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n    // numeric.\n    let non_numeric_generics =\n        generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations =\n            non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n        quote {where $non_numeric_generics_declarations}\n    } else {\n        // There are no non-numeric generics, so we return an empty quote.\n        quote {}\n    }\n}\n"
     },
     "246": {
@@ -1317,7 +1317,7 @@
           "start": 21246
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
+      "path": "/home/aztec-dev/aztec-packages/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"
     },
     "256": {
@@ -2477,7 +2477,7 @@
           "start": 747
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/fee_juice_contract/src/lib.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/fee_juice_contract/src/lib.nr",
       "source": "use aztec::context::PublicContext;\nuse aztec::protocol::address::AztecAddress;\nuse aztec::protocol::hash::sha256_to_field;\nuse aztec::protocol::traits::ToField;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\n/// Computes the content hash for an L1-to-L2 \"bridge gas\" message, matching the hash produced on L1 by\n/// `FeeJuicePortal.depositToAztecPublic`: `sha256ToField(abi.encodeWithSignature(\"claim(bytes32,uint256)\", to,\n/// amount))`.\n///\n/// The 68-byte buffer is: [4-byte selector of \"claim(bytes32,uint256)\"][32-byte recipient][32-byte amount], hashed\n/// with `sha256_to_field` to produce a single Field.\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: u128) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = (amount as Field).to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { keccak256::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     },
     "53": {
@@ -2488,35 +2488,35 @@
         },
         {
           "name": "FeeJuice::claim",
-          "start": 4253
+          "start": 4451
         },
         {
           "name": "FeeJuice::claim_and_end_setup",
-          "start": 5883
+          "start": 6279
         },
         {
           "name": "FeeJuice::_increase_public_balance",
-          "start": 7124
+          "start": 7520
         },
         {
           "name": "FeeJuice::check_balance",
-          "start": 8477
+          "start": 8873
         },
         {
           "name": "FeeJuice::balance_of_public",
-          "start": 9518
+          "start": 9914
         },
         {
           "name": "FeeJuice::public_dispatch",
-          "start": 10440
+          "start": 10836
         },
         {
           "name": "FeeJuice::Storage<Context>::init",
-          "start": 13029
+          "start": 13425
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/fee_juice_contract/src/main.nr",
-      "source": "/// Protocol contract that manages the native gas token (\"Fee Juice\") used to pay transaction fees.\n///\n/// Fee Juice is minted on L2 by bridging from L1: a user deposits ERC-20 tokens into the L1 FeeJuicePortal, which\n/// sends an L1-to-L2 message. On L2, `claim` or `claim_and_end_setup` consumes that message and credits the\n/// recipient's balance via an enqueued public call to `_increase_public_balance`.\n///\n/// The protocol's base rollup circuits read directly from this contract's `balances` storage map (at slot 1) to verify\n/// fee payers can cover their transaction costs. This storage layout is protocol-critical and must not change without\n/// updating the base rollup circuits.\n///\n/// There is no withdrawal mechanism -- Fee Juice can only be bridged in, not withdrawn or transferred by users. Tokens\n/// leave the L1 portal only via `distributeFees` called by the Rollup contract to pay sequencers.\n\nmod lib;\n\npub contract FeeJuice {\n    use crate::lib::get_bridge_gas_msg_hash;\n    use aztec::{\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, EthAddress},\n            constants::FEE_JUICE_ADDRESS,\n            traits::{Deserialize, ToField},\n        },\n        state_vars::{Map, PublicMutable},\n    };\n    use std::ops::Add;\n\n    struct Storage<Context> {\n        // contract address --> public fee juice balance\n        balances: Map<AztecAddress, PublicMutable<u128, Context>, Context>,\n    }\n\n    global INCREASE_PUBLIC_BALANCE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"_increase_public_balance((Field),u128)\").to_field() };\n\n    global CHECK_BALANCE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"check_balance(u128)\").to_field() };\n\n    global BALANCE_OF_PUBLIC_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"balance_of_public((Field))\").to_field() };\n\n    /// A helper implementing the core L1-to-L2 message claim logic shared by `claim` and `claim_and_end_setup`.\n    /// Computes the expected content hash, consumes the L1-to-L2 message (emitting a nullifier to prevent\n    /// double-claiming), and enqueues a public call to `_increase_public_balance` to credit the recipient.\n    #[contract_library_method]\n    fn claim_helper(\n        context: &mut aztec::context::PrivateContext,\n        to: AztecAddress,\n        amount: u128,\n        secret: Field,\n        message_leaf_index: Field,\n    ) {\n        let content_hash: Field = get_bridge_gas_msg_hash(to, amount);\n        // The Inbox changes the sender's address to `FEE_JUICE_ADDRESS` if it's from the FeeJuicePortal.\n        // This avoids the need to store the L1 address on L2 and prevents friction if the address changes.\n        let portal_address: EthAddress = EthAddress::from_field(FEE_JUICE_ADDRESS.to_field());\n        assert(!portal_address.is_zero());\n\n        // Consume the L1-to-L2 message (verifies existence + emits nullifier to prevent replay).\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // Enqueue a public call to _increase_public_balance to credit the recipient.\n        let serialized_params: [Field; 2] = [to.to_field(), amount.to_field()];\n        let calldata: [Field; 1 + 2] = [INCREASE_PUBLIC_BALANCE_SELECTOR].concat(serialized_params);\n        let calldata_hash: Field = aztec::hash::hash_calldata_array(calldata);\n        aztec::oracle::execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(context.this_address(), calldata_hash, false, false);\n    }\n\n    /// Claims Fee Juice by consuming an L1-to-L2 message from the FeeJuicePortal.\n    ///\n    /// Use this variant when the claimed Fee Juice is NOT intended to pay for the current transaction's fees (e.g.,\n    /// pre-funding an account for future transactions).\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn claim(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        to: AztecAddress,\n        amount: u128,\n        secret: Field,\n        message_leaf_index: Field,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // nor in the claim helper function or the enqueued public function call, I have removed that check.\n        aztec::oracle::version::assert_compatible_oracle_version();\n        let serialized_params: [Field; 4] = [to.to_field(), amount.to_field(), secret, message_leaf_index];\n        let args_hash: Field = aztec::hash::hash_args(serialized_params);\n        let mut context: aztec::context::PrivateContext = aztec::context::PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        claim_helper(&mut context, to, amount, secret, message_leaf_index);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Claims Fee Juice and ends the transaction setup phase.\n    ///\n    /// Use this variant when the claimed Fee Juice is intended to pay for THIS transaction's fees. By ending setup\n    /// after the claim, the balance increase is placed in the non-revertible phase, ensuring the fee payer's balance\n    /// is credited even if the revertible portion of the transaction fails. This guarantees the sequencer can collect\n    /// fees.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn claim_and_end_setup(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        to: AztecAddress,\n        amount: u128,\n        secret: Field,\n        message_leaf_index: Field,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        aztec::oracle::version::assert_compatible_oracle_version();\n        let serialized_params: [Field; 4] = [to.to_field(), amount.to_field(), secret, message_leaf_index];\n        let args_hash: Field = aztec::hash::hash_args(serialized_params);\n        let mut context: aztec::context::PrivateContext = aztec::context::PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        claim_helper(&mut context, to, amount, secret, message_leaf_index);\n\n        // MACRO CODE START\n        // End setup: everything before this point (including the enqueued _increase_public_balance\n        // call) is non-revertible. Everything after is revertible.\n        context.end_setup();\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Internal function that credits a recipient's Fee Juice balance. Only callable by this contract itself\n    /// (`#[only_self]`), enqueued by `claim` / `claim_and_end_setup` after consuming an L1-to-L2 message.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_only_self]\n    unconstrained fn _increase_public_balance(to: AztecAddress, amount: u128) {\n        // MACRO CODE START\n        let context: aztec::context::PublicContext = aztec::context::PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 2] = aztec::oracle::avm::calldata_copy(\n                    1,\n                    <AztecAddress as aztec::protocol::traits::Serialize>::N\n                        + <u128 as aztec::protocol::traits::Serialize>::N,\n                );\n                aztec::hash::hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<aztec::context::PublicContext> = Storage::<aztec::context::PublicContext>::init(context);\n\n        assert(\n            context.maybe_msg_sender().unwrap() == context.this_address(),\n            \"Function _increase_public_balance can only be called by the same contract\",\n        );\n        // MACRO CODE END\n\n        let new_balance = storage.balances.at(to).read().add(amount);\n        storage.balances.at(to).write(new_balance);\n    }\n\n    /// Asserts the caller has at least `fee_limit` Fee Juice. Used during transaction validation to verify the fee\n    /// payer can cover the transaction's fee limit.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn check_balance(fee_limit: u128) {\n        // MACRO CODE START\n        let context: aztec::context::PublicContext = aztec::context::PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    aztec::oracle::avm::calldata_copy(1, <u128 as aztec::protocol::traits::Serialize>::N);\n                aztec::hash::hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<aztec::context::PublicContext> = Storage::<aztec::context::PublicContext>::init(context);\n\n        assert(context.is_static_call(), \"Function check_balance can only be called statically\");\n        // MACRO CODE END\n\n        assert(storage.balances.at(context.maybe_msg_sender().unwrap()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    /// Returns the Fee Juice balance of the given address.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn balance_of_public(owner: AztecAddress) -> pub u128 {\n        // MACRO CODE START\n        let context: aztec::context::PublicContext = aztec::context::PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    aztec::oracle::avm::calldata_copy(1, <AztecAddress as aztec::protocol::traits::Serialize>::N);\n                aztec::hash::hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<aztec::context::PublicContext> = Storage::<aztec::context::PublicContext>::init(context);\n\n        assert(context.is_static_call(), \"Function balance_of_public can only be called statically\");\n        // MACRO CODE END\n\n        storage.balances.at(owner).read()\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == INCREASE_PUBLIC_BALANCE_SELECTOR {\n            let input_calldata: [Field; 2] = aztec::oracle::avm::calldata_copy(\n                1,\n                <AztecAddress as aztec::protocol::traits::Serialize>::N\n                    + <u128 as aztec::protocol::traits::Serialize>::N,\n            );\n            let mut reader: aztec::protocol::utils::reader::Reader<2> =\n                aztec::protocol::utils::reader::Reader::<2>::new(input_calldata);\n            let arg0: AztecAddress = <AztecAddress as Deserialize>::stream_deserialize(&mut reader);\n            let arg1: u128 = <u128 as Deserialize>::stream_deserialize(&mut reader);\n            _increase_public_balance(arg0, arg1);\n            aztec::oracle::avm::avm_return([].as_vector());\n        };\n        if selector == CHECK_BALANCE_SELECTOR {\n            let input_calldata: [Field; 1] =\n                aztec::oracle::avm::calldata_copy(1, <u128 as aztec::protocol::traits::Serialize>::N);\n            let mut reader: aztec::protocol::utils::reader::Reader<1> =\n                aztec::protocol::utils::reader::Reader::<1>::new(input_calldata);\n            let arg0: u128 = <u128 as Deserialize>::stream_deserialize(&mut reader);\n            check_balance(arg0);\n            aztec::oracle::avm::avm_return([].as_vector());\n        };\n        if selector == BALANCE_OF_PUBLIC_SELECTOR {\n            let input_calldata: [Field; 1] =\n                aztec::oracle::avm::calldata_copy(1, <AztecAddress as aztec::protocol::traits::Serialize>::N);\n            let mut reader: aztec::protocol::utils::reader::Reader<1> =\n                aztec::protocol::utils::reader::Reader::<1>::new(input_calldata);\n            let arg0: AztecAddress = <AztecAddress as Deserialize>::stream_deserialize(&mut reader);\n            let return_value: [Field; 1] =\n                <u128 as aztec::protocol::traits::Serialize>::serialize(balance_of_public(arg0));\n            aztec::oracle::avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    pub struct StorageLayoutFields {\n        pub balances: aztec::state_vars::Storable,\n    }\n\n    pub struct StorageLayout<let N: u32> {\n        pub contract_name: str<N>,\n        pub fields: StorageLayoutFields,\n    }\n\n    #[abi(storage)]\n    pub global STORAGE_LAYOUT_FeeJuice: StorageLayout<8> = StorageLayout::<8> {\n        contract_name: \"FeeJuice\",\n        fields: StorageLayoutFields { balances: aztec::state_vars::Storable { slot: 1 } },\n    };\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                balances: <Map<AztecAddress, PublicMutable<u128, Context>, Context> as aztec::state_vars::StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    pub struct _increase_public_balance_parameters {\n        pub _to: AztecAddress,\n        pub _amount: u128,\n    }\n\n    pub struct balance_of_public_parameters {\n        pub _owner: AztecAddress,\n    }\n\n    pub struct check_balance_parameters {\n        pub _fee_limit: u128,\n    }\n\n    pub struct claim_and_end_setup_parameters {\n        pub _to: AztecAddress,\n        pub _amount: u128,\n        pub _secret: Field,\n        pub _message_leaf_index: Field,\n    }\n\n    pub struct claim_parameters {\n        pub _to: AztecAddress,\n        pub _amount: u128,\n        pub _secret: Field,\n        pub _message_leaf_index: Field,\n    }\n\n    #[abi(functions)]\n    pub struct _increase_public_balance_abi {\n        parameters: _increase_public_balance_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct balance_of_public_abi {\n        parameters: balance_of_public_parameters,\n        return_type: u128,\n    }\n\n    #[abi(functions)]\n    pub struct check_balance_abi {\n        parameters: check_balance_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct claim_abi {\n        parameters: claim_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct claim_and_end_setup_abi {\n        parameters: claim_and_end_setup_parameters,\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/fee_juice_contract/src/main.nr",
+      "source": "/// Protocol contract that manages the native gas token (\"Fee Juice\") used to pay transaction fees.\n///\n/// Fee Juice is minted on L2 by bridging from L1: a user deposits ERC-20 tokens into the L1 FeeJuicePortal, which\n/// sends an L1-to-L2 message. On L2, `claim` or `claim_and_end_setup` consumes that message and credits the\n/// recipient's balance via an enqueued public call to `_increase_public_balance`.\n///\n/// The protocol's base rollup circuits read directly from this contract's `balances` storage map (at slot 1) to verify\n/// fee payers can cover their transaction costs. This storage layout is protocol-critical and must not change without\n/// updating the base rollup circuits.\n///\n/// There is no withdrawal mechanism -- Fee Juice can only be bridged in, not withdrawn or transferred by users. Tokens\n/// leave the L1 portal only via `distributeFees` called by the Rollup contract to pay sequencers.\n\nmod lib;\n\npub contract FeeJuice {\n    use crate::lib::get_bridge_gas_msg_hash;\n    use aztec::{\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, EthAddress},\n            constants::FEE_JUICE_ADDRESS,\n            traits::{Deserialize, ToField},\n        },\n        state_vars::{Map, PublicMutable},\n    };\n    use std::ops::Add;\n\n    struct Storage<Context> {\n        // contract address --> public fee juice balance\n        balances: Map<AztecAddress, PublicMutable<u128, Context>, Context>,\n    }\n\n    global INCREASE_PUBLIC_BALANCE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"_increase_public_balance((Field),u128)\").to_field() };\n\n    global CHECK_BALANCE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"check_balance(u128)\").to_field() };\n\n    global BALANCE_OF_PUBLIC_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"balance_of_public((Field))\").to_field() };\n\n    /// A helper implementing the core L1-to-L2 message claim logic shared by `claim` and `claim_and_end_setup`.\n    /// Computes the expected content hash, consumes the L1-to-L2 message (emitting a nullifier to prevent\n    /// double-claiming), and enqueues a public call to `_increase_public_balance` to credit the recipient.\n    #[contract_library_method]\n    fn claim_helper(\n        context: &mut aztec::context::PrivateContext,\n        to: AztecAddress,\n        amount: u128,\n        secret: Field,\n        message_leaf_index: Field,\n    ) {\n        let content_hash: Field = get_bridge_gas_msg_hash(to, amount);\n        // The Inbox changes the sender's address to `FEE_JUICE_ADDRESS` if it's from the FeeJuicePortal.\n        // This avoids the need to store the L1 address on L2 and prevents friction if the address changes.\n        let portal_address: EthAddress = EthAddress::from_field(FEE_JUICE_ADDRESS.to_field());\n        assert(!portal_address.is_zero());\n\n        // Consume the L1-to-L2 message (verifies existence + emits nullifier to prevent replay).\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // Enqueue a public call to _increase_public_balance to credit the recipient.\n        let serialized_params: [Field; 2] = [to.to_field(), amount.to_field()];\n        let calldata: [Field; 1 + 2] = [INCREASE_PUBLIC_BALANCE_SELECTOR].concat(serialized_params);\n        let calldata_hash: Field = aztec::hash::hash_calldata_array(calldata);\n        aztec::oracle::execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(context.this_address(), calldata_hash, false, false);\n    }\n\n    /// Claims Fee Juice by consuming an L1-to-L2 message from the FeeJuicePortal.\n    ///\n    /// Use this variant when the claimed Fee Juice is NOT intended to pay for the current transaction's fees (e.g.,\n    /// pre-funding an account for future transactions).\n    // Mirrors the private entrypoint the aztec-nr macro generates: PrivateCircuitPublicInputs has constant fields\n    // that cannot be dropped from the protocol ABI.\n    #[allow(constant_return)]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn claim(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        to: AztecAddress,\n        amount: u128,\n        secret: Field,\n        message_leaf_index: Field,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // nor in the claim helper function or the enqueued public function call, I have removed that check.\n        aztec::oracle::version::assert_compatible_oracle_version();\n        let serialized_params: [Field; 4] = [to.to_field(), amount.to_field(), secret, message_leaf_index];\n        let args_hash: Field = aztec::hash::hash_args(serialized_params);\n        let mut context: aztec::context::PrivateContext = aztec::context::PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        claim_helper(&mut context, to, amount, secret, message_leaf_index);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Claims Fee Juice and ends the transaction setup phase.\n    ///\n    /// Use this variant when the claimed Fee Juice is intended to pay for THIS transaction's fees. By ending setup\n    /// after the claim, the balance increase is placed in the non-revertible phase, ensuring the fee payer's balance\n    /// is credited even if the revertible portion of the transaction fails. This guarantees the sequencer can collect\n    /// fees.\n    // Mirrors the private entrypoint the aztec-nr macro generates: PrivateCircuitPublicInputs has constant fields\n    // that cannot be dropped from the protocol ABI.\n    #[allow(constant_return)]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn claim_and_end_setup(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        to: AztecAddress,\n        amount: u128,\n        secret: Field,\n        message_leaf_index: Field,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        aztec::oracle::version::assert_compatible_oracle_version();\n        let serialized_params: [Field; 4] = [to.to_field(), amount.to_field(), secret, message_leaf_index];\n        let args_hash: Field = aztec::hash::hash_args(serialized_params);\n        let mut context: aztec::context::PrivateContext = aztec::context::PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        claim_helper(&mut context, to, amount, secret, message_leaf_index);\n\n        // MACRO CODE START\n        // End setup: everything before this point (including the enqueued _increase_public_balance\n        // call) is non-revertible. Everything after is revertible.\n        context.end_setup();\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Internal function that credits a recipient's Fee Juice balance. Only callable by this contract itself\n    /// (`#[only_self]`), enqueued by `claim` / `claim_and_end_setup` after consuming an L1-to-L2 message.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_only_self]\n    unconstrained fn _increase_public_balance(to: AztecAddress, amount: u128) {\n        // MACRO CODE START\n        let context: aztec::context::PublicContext = aztec::context::PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 2] = aztec::oracle::avm::calldata_copy(\n                    1,\n                    <AztecAddress as aztec::protocol::traits::Serialize>::N\n                        + <u128 as aztec::protocol::traits::Serialize>::N,\n                );\n                aztec::hash::hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<aztec::context::PublicContext> = Storage::<aztec::context::PublicContext>::init(context);\n\n        assert(\n            context.maybe_msg_sender().unwrap() == context.this_address(),\n            \"Function _increase_public_balance can only be called by the same contract\",\n        );\n        // MACRO CODE END\n\n        let new_balance = storage.balances.at(to).read().add(amount);\n        storage.balances.at(to).write(new_balance);\n    }\n\n    /// Asserts the caller has at least `fee_limit` Fee Juice. Used during transaction validation to verify the fee\n    /// payer can cover the transaction's fee limit.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn check_balance(fee_limit: u128) {\n        // MACRO CODE START\n        let context: aztec::context::PublicContext = aztec::context::PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    aztec::oracle::avm::calldata_copy(1, <u128 as aztec::protocol::traits::Serialize>::N);\n                aztec::hash::hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<aztec::context::PublicContext> = Storage::<aztec::context::PublicContext>::init(context);\n\n        assert(context.is_static_call(), \"Function check_balance can only be called statically\");\n        // MACRO CODE END\n\n        assert(storage.balances.at(context.maybe_msg_sender().unwrap()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    /// Returns the Fee Juice balance of the given address.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn balance_of_public(owner: AztecAddress) -> pub u128 {\n        // MACRO CODE START\n        let context: aztec::context::PublicContext = aztec::context::PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    aztec::oracle::avm::calldata_copy(1, <AztecAddress as aztec::protocol::traits::Serialize>::N);\n                aztec::hash::hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<aztec::context::PublicContext> = Storage::<aztec::context::PublicContext>::init(context);\n\n        assert(context.is_static_call(), \"Function balance_of_public can only be called statically\");\n        // MACRO CODE END\n\n        storage.balances.at(owner).read()\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == INCREASE_PUBLIC_BALANCE_SELECTOR {\n            let input_calldata: [Field; 2] = aztec::oracle::avm::calldata_copy(\n                1,\n                <AztecAddress as aztec::protocol::traits::Serialize>::N\n                    + <u128 as aztec::protocol::traits::Serialize>::N,\n            );\n            let mut reader: aztec::protocol::utils::reader::Reader<2> =\n                aztec::protocol::utils::reader::Reader::<2>::new(input_calldata);\n            let arg0: AztecAddress = <AztecAddress as Deserialize>::stream_deserialize(&mut reader);\n            let arg1: u128 = <u128 as Deserialize>::stream_deserialize(&mut reader);\n            _increase_public_balance(arg0, arg1);\n            aztec::oracle::avm::avm_return([].as_vector());\n        };\n        if selector == CHECK_BALANCE_SELECTOR {\n            let input_calldata: [Field; 1] =\n                aztec::oracle::avm::calldata_copy(1, <u128 as aztec::protocol::traits::Serialize>::N);\n            let mut reader: aztec::protocol::utils::reader::Reader<1> =\n                aztec::protocol::utils::reader::Reader::<1>::new(input_calldata);\n            let arg0: u128 = <u128 as Deserialize>::stream_deserialize(&mut reader);\n            check_balance(arg0);\n            aztec::oracle::avm::avm_return([].as_vector());\n        };\n        if selector == BALANCE_OF_PUBLIC_SELECTOR {\n            let input_calldata: [Field; 1] =\n                aztec::oracle::avm::calldata_copy(1, <AztecAddress as aztec::protocol::traits::Serialize>::N);\n            let mut reader: aztec::protocol::utils::reader::Reader<1> =\n                aztec::protocol::utils::reader::Reader::<1>::new(input_calldata);\n            let arg0: AztecAddress = <AztecAddress as Deserialize>::stream_deserialize(&mut reader);\n            let return_value: [Field; 1] =\n                <u128 as aztec::protocol::traits::Serialize>::serialize(balance_of_public(arg0));\n            aztec::oracle::avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    pub struct StorageLayoutFields {\n        pub balances: aztec::state_vars::Storable,\n    }\n\n    pub struct StorageLayout<let N: u32> {\n        pub contract_name: str<N>,\n        pub fields: StorageLayoutFields,\n    }\n\n    #[abi(storage)]\n    pub global STORAGE_LAYOUT_FeeJuice: StorageLayout<8> = StorageLayout::<8> {\n        contract_name: \"FeeJuice\",\n        fields: StorageLayoutFields { balances: aztec::state_vars::Storable { slot: 1 } },\n    };\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                balances: <Map<AztecAddress, PublicMutable<u128, Context>, Context> as aztec::state_vars::StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    pub struct _increase_public_balance_parameters {\n        pub _to: AztecAddress,\n        pub _amount: u128,\n    }\n\n    pub struct balance_of_public_parameters {\n        pub _owner: AztecAddress,\n    }\n\n    pub struct check_balance_parameters {\n        pub _fee_limit: u128,\n    }\n\n    pub struct claim_and_end_setup_parameters {\n        pub _to: AztecAddress,\n        pub _amount: u128,\n        pub _secret: Field,\n        pub _message_leaf_index: Field,\n    }\n\n    pub struct claim_parameters {\n        pub _to: AztecAddress,\n        pub _amount: u128,\n        pub _secret: Field,\n        pub _message_leaf_index: Field,\n    }\n\n    #[abi(functions)]\n    pub struct _increase_public_balance_abi {\n        parameters: _increase_public_balance_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct balance_of_public_abi {\n        parameters: balance_of_public_parameters,\n        return_type: u128,\n    }\n\n    #[abi(functions)]\n    pub struct check_balance_abi {\n        parameters: check_balance_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct claim_abi {\n        parameters: claim_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct claim_and_end_setup_abi {\n        parameters: claim_and_end_setup_parameters,\n    }\n}\n"
     },
     "58": {
       "function_locations": [
@@ -2617,7 +2617,7 @@
           "start": 15805
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
       "source": "use crate::{\n    context::{inputs::PrivateContextInputs, NullifierExistenceRequest, ReturnsHash},\n    hash::hash_args,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        call_private_function::call_private_function_internal,\n        public_call::validate_public_calldata,\n        tx_phase::{in_revertible_phase, notify_revertible_phase_start},\n        execution_cache,\n        logs::notify_created_contract_class_log,\n        nullifiers::notify_created_nullifier,\n    },\n};\nuse crate::protocol::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, MAX_CONTRACT_CLASS_LOGS_PER_CALL,\n        MAX_ENQUEUED_CALLS_PER_CALL, MAX_TX_LIFETIME, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        NULL_MSG_SENDER_CONTRACT_ADDRESS, PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    hash::poseidon2_hash,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    side_effect::{Counted, scoped::Scoped},\n    traits::Empty,\n    utils::arrays::{ClaimedLengthArray, trimmed_array_length_hint},\n};\n\n/// Minimal PrivateContext for protocol contracts going to audit.\n/// Contains only the methods actually used by: fee_juice, auth_registry, contract_class_registry, contract_instance_registry\n#[derive(Eq)]\npub struct PrivateContext {\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub expiration_timestamp: u64,\n\n    pub nullifier_read_requests: BoundedVec<Scoped<Counted<Field>>, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n\n    pub nullifiers: BoundedVec<Counted<Nullifier>, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub anchor_block_header: BlockHeader,\n\n    pub private_logs: BoundedVec<Counted<PrivateLogData>, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    pub expected_non_revertible_side_effect_counter: u32,\n    pub expected_revertible_side_effect_counter: u32,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            expiration_timestamp: inputs.anchor_block_header.global_variables.timestamp\n            + MAX_TX_LIFETIME,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            anchor_block_header: inputs.anchor_block_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call (similar to msg.sender in Solidity).\n    pub fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.inputs.call_context.msg_sender;\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the contract address of the current function being executed.\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    /// Returns the protocol version.\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    /// Returns the gas settings for the current transaction.\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    /// Returns the function selector of the currently executing function.\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    /// Returns the anchor block header.\n    pub fn get_anchor_block_header(self) -> BlockHeader {\n        self.anchor_block_header\n    }\n\n    /// Sets the hash of the return values for this private function.\n    pub fn set_return_hash<let N: u32>(&mut self, serialized_return_values: [Field; N]) {\n        let return_hash = hash_args(serialized_return_values);\n        self.return_hash = return_hash;\n        execution_cache::store(serialized_return_values, return_hash);\n    }\n\n    /// Builds the PrivateCircuitPublicInputs for this private function.\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            expiration_timestamp: self.expiration_timestamp,\n            note_hash_read_requests: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifier_read_requests: ClaimedLengthArray::from_bounded_vec(\n                self.nullifier_read_requests,\n            ),\n            key_validation_requests_and_separators: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            note_hashes: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifiers: ClaimedLengthArray::from_bounded_vec(self.nullifiers),\n            private_call_requests: ClaimedLengthArray::from_bounded_vec(self.private_call_requests),\n            public_call_requests: ClaimedLengthArray::from_bounded_vec(self.public_call_requests),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: ClaimedLengthArray::from_bounded_vec(self.l2_to_l1_msgs),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: ClaimedLengthArray::from_bounded_vec(self.private_logs),\n            contract_class_logs_hashes: ClaimedLengthArray::from_bounded_vec(\n                self.contract_class_logs_hashes,\n            ),\n            anchor_block_header: self.anchor_block_header,\n            tx_context: self.inputs.tx_context,\n            expected_non_revertible_side_effect_counter: self\n                .expected_non_revertible_side_effect_counter,\n            expected_revertible_side_effect_counter: self.expected_revertible_side_effect_counter,\n            tx_request_salt: self.inputs.tx_request_salt,\n        }\n    }\n\n    /// Declares the end of the \"setup phase\" of this tx. Used by fee_juice.\n    pub fn end_setup(&mut self) {\n        self.side_effect_counter += 1;\n        self.min_revertible_side_effect_counter = self.next_counter();\n        notify_revertible_phase_start(self.min_revertible_side_effect_counter);\n    }\n\n    pub fn in_revertible_phase(&mut self) -> bool {\n        let current_counter = self.side_effect_counter;\n\n        // Safety: Kernel will validate that the claim is correct by validating the expected counters.\n        let is_revertible =\n            unsafe { in_revertible_phase(current_counter) };\n\n        if is_revertible {\n            if (self.expected_revertible_side_effect_counter == 0)\n                | (current_counter < self.expected_revertible_side_effect_counter) {\n                self.expected_revertible_side_effect_counter = current_counter;\n            }\n        } else if current_counter > self.expected_non_revertible_side_effect_counter {\n            self.expected_non_revertible_side_effect_counter = current_counter;\n        }\n\n        is_revertible\n    }\n\n    /// Sets a deadline for when this transaction must be included in a block.\n    pub fn set_expiration_timestamp(&mut self, expiration_timestamp: u64) {\n        self.expiration_timestamp = std::cmp::min(self.expiration_timestamp, expiration_timestamp);\n    }\n\n    /// Pushes a new nullifier. Used by class_registry and instance_registry.\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(Nullifier { value: nullifier, note_hash: 0 }.count(self.next_counter()));\n    }\n\n    /// Asserts that a nullifier has been emitted. Used by instance_registry.\n    pub fn assert_nullifier_exists(\n        &mut self,\n        nullifier_existence_request: NullifierExistenceRequest,\n    ) {\n        let nullifier = nullifier_existence_request.nullifier();\n        let contract_address =\n            nullifier_existence_request.maybe_contract_address().unwrap_or(AztecAddress::zero());\n\n        let request = Scoped::new(\n            Counted::new(nullifier, self.next_counter()),\n            contract_address,\n        );\n\n        self.nullifier_read_requests.push(request);\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2). Used by fee_juice.\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let nullifier = process_l1_to_l2_message(\n            self.anchor_block_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n\n    /// Emits a private log. Used by instance_registry.\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0 }\n            .count(counter);\n        self.private_logs.push(private_log);\n    }\n\n    /// Emits a contract class log. Used by class_registry.\n    pub fn emit_contract_class_log<let N: u32>(&mut self, log: [Field; N]) {\n        let contract_address = self.this_address();\n        let counter = self.next_counter();\n\n        let log_to_emit: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS] =\n            log.concat([0; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - N]);\n        // Safety: The below length is constrained in the base rollup, which will make sure that all the fields beyond\n        // length are zero. However, it won't be able to check that we didn't add extra padding (trailing zeroes) or\n        // that we cut trailing zeroes from the end.\n        let length = unsafe { trimmed_array_length_hint(log_to_emit) };\n        // We hash the entire padded log to ensure a user cannot pass a shorter length and so emit incorrect shorter\n        // bytecode.\n        let log_hash = poseidon2_hash(log_to_emit);\n        // Safety: the below only exists to broadcast the raw log, so we can provide it to the base rollup later to be\n        // constrained.\n        unsafe {\n            notify_created_contract_class_log(contract_address, log_to_emit, length, counter);\n        }\n\n        self.contract_class_logs_hashes.push(LogHash { value: log_hash, length: length }.count(\n            counter,\n        ));\n    }\n\n    /// Makes a read-only call to a private function. Used by auth_registry for authwit.\n    pub fn static_call_private_function<let ArgsCount: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ArgsCount],\n    ) -> ReturnsHash {\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    /// Enqueues a call to a public function with a calldata hash. Used by fee_juice and auth_registry.\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n        hide_msg_sender: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        validate_public_calldata(calldata_hash);\n\n        let msg_sender = if hide_msg_sender {\n            NULL_MSG_SENDER_CONTRACT_ADDRESS\n        } else {\n            self.this_address()\n        };\n\n        let call_request =\n            PublicCallRequest { msg_sender, contract_address, is_static_call, calldata_hash };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            expiration_timestamp: 0,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            anchor_block_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n}\n"
     },
     "59": {
@@ -2747,7 +2747,7 @@
           "start": 10892
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/public_context.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/context/public_context.nr",
       "source": "use crate::{\n    context::gas::GasOpts,\n    hash::{\n        compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n        compute_siloed_nullifier,\n    },\n    oracle::avm,\n};\nuse crate::protocol::{\n    abis::function_selector::FunctionSelector,\n    address::{AztecAddress, EthAddress},\n    constants::{MAX_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS},\n    traits::{Empty, FromField, Packable, Serialize, ToField},\n};\n\n/// Minimal PublicContext for protocol contracts going to audit.\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n    fn eq(self, other: Self) -> bool {\n        (self.args_hash == other.args_hash)\n        // Can't compare the function compute_args_hash\n    }\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    /// Emits a _public_ log that will be visible onchain to everyone.\n    pub fn emit_public_log<T>(_self: Self, log: T)\n    where\n        T: Serialize,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_public_log(Serialize::serialize(log).as_vector()) };\n    }\n\n    /// Checks if a given note hash exists in the note hash tree at a particular leaf_index.\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::note_hash_exists(note_hash, leaf_index) }\n    }\n\n    /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message tree at a particular leaf index.\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n        unsafe { avm::l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64) }\n    }\n\n    /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.\n    pub fn nullifier_exists_unsafe(\n        _self: Self,\n        unsiloed_nullifier: Field,\n        contract_address: AztecAddress,\n    ) -> bool {\n        let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::nullifier_exists(siloed_nullifier) }\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2).\n    pub fn consume_l1_to_l2_message(\n        self: Self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists_unsafe(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    /// Sends an \"L2 -> L1 message\".\n    pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::send_l2_to_l1_msg(recipient, content) };\n    }\n\n    /// Calls a public function on another contract.\n    pub unconstrained fn call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Makes a read-only call to a public function on another contract.\n    pub unconstrained fn static_call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Adds a new note hash to the Note Hash Tree.\n    pub fn push_note_hash(_self: Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_note_hash(note_hash) };\n    }\n\n    /// Adds a new nullifier to the Nullifier Tree.\n    pub fn push_nullifier(_self: Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_nullifier(nullifier) };\n    }\n\n    /// Returns the address of the current contract being executed.\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::address()\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    pub fn maybe_msg_sender(_self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = unsafe { avm::sender() };\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the function selector of the currently-executing function.\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { avm::calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n\n    /// Returns the \"transaction fee\" for the current transaction.\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::transaction_fee()\n        }\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::chain_id()\n        }\n    }\n\n    /// Returns the protocol version.\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::version()\n        }\n    }\n\n    /// Returns the current block number.\n    pub fn block_number(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::block_number()\n        }\n    }\n\n    /// Returns the timestamp of the current block.\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::timestamp()\n        }\n    }\n\n    /// Returns the fee per unit of L2 gas.\n    pub fn min_fee_per_l2_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_l2_gas()\n        }\n    }\n\n    /// Returns the fee per unit of DA gas.\n    pub fn min_fee_per_da_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_da_gas()\n        }\n    }\n\n    /// Returns the remaining L2 gas available.\n    pub fn l2_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::l2_gas_left()\n        }\n    }\n\n    /// Returns the remaining DA gas available.\n    pub fn da_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::da_gas_left()\n        }\n    }\n\n    /// Checks if the current execution is within a staticcall context.\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::is_static_call() }\n    }\n\n    /// Reads raw field values from public storage.\n    pub fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe {\n                avm::storage_read(storage_slot + i as Field, self.this_address().to_field())\n            };\n        }\n        out\n    }\n\n    /// Reads a typed value from public storage.\n    pub fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    /// Writes raw field values to public storage.\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { avm::storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    /// Writes a typed value to public storage.\n    pub fn storage_write<T>(self, storage_slot: Field, value: T)\n    where\n        T: Packable,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n"
     },
     "62": {
@@ -2777,7 +2777,7 @@
           "start": 2994
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/hash.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/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,\n        DOM_SEP__PUBLIC_CALLDATA, DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the separator.\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"
     },
     "69": {
@@ -2787,7 +2787,7 @@
           "start": 560
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/messaging.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/messaging.nr",
       "source": "use crate::{\n    hash::{compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash},\n    oracle::get_l1_to_l2_membership_witness::get_l1_to_l2_membership_witness,\n};\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    merkle_tree::root::root_from_sibling_path,\n};\n\npub fn process_l1_to_l2_message(\n    l1_to_l2_root: Field,\n    contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    version: Field,\n    content: Field,\n    secret: Field,\n    leaf_index: Field,\n) -> Field {\n    let secret_hash = compute_secret_hash(secret);\n    let message_hash = compute_l1_to_l2_message_hash(\n        portal_contract_address,\n        chain_id,\n        contract_address,\n        version,\n        content,\n        secret_hash,\n        leaf_index,\n    );\n\n    // We prove that `message_hash` is in the tree by showing the derivation of the tree root, using a merkle path we\n    // get from an oracle.\n    // Safety: The witness is only used as a \"magical value\" that makes the merkle proof below pass. Hence it's safe.\n    let (_leaf_index, sibling_path) =\n        unsafe { get_l1_to_l2_membership_witness(contract_address, message_hash, secret) };\n\n    let root = root_from_sibling_path(message_hash, leaf_index, sibling_path);\n    assert_eq(root, l1_to_l2_root, \"Message not in state\");\n\n    compute_l1_to_l2_message_nullifier(message_hash, secret)\n}\n"
     },
     "72": {
@@ -3025,7 +3025,7 @@
           "start": 7247
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
       "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> bool {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> bool {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> bool {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> bool {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> bool {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> bool {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
     "76": {
@@ -3051,7 +3051,7 @@
           "start": 1083
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/execution_cache.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\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 { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper<let N: u32>(\n    values: [Field; N],\n    hash: Field,\n) {\n    store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n// TODO(F-498): review naming consistency\n#[oracle(aztec_prv_setHashPreimage)]\nunconstrained fn store_in_execution_cache_oracle<let N: u32>(_values: [Field; N], _hash: Field) {}\n\n// TODO(F-498): review naming consistency\n#[oracle(aztec_prv_getHashPreimage)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
     "77": {
@@ -3065,7 +3065,7 @@
           "start": 828
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/get_l1_to_l2_membership_witness.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/get_l1_to_l2_membership_witness.nr",
       "source": "use crate::protocol::{address::AztecAddress, constants::L1_TO_L2_MSG_TREE_HEIGHT};\n\n/// Returns the leaf index and sibling path of an entry in the L1 to L2 messaging tree, which can then be used to prove\n/// its existence.\npub unconstrained fn get_l1_to_l2_membership_witness(\n    contract_address: AztecAddress,\n    message_hash: Field,\n    secret: Field,\n) -> (Field, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {\n    get_l1_to_l2_membership_witness_oracle(contract_address, message_hash, secret)\n}\n\n// Obtains membership witness (index and sibling path) for a message in the L1 to L2 message tree.\n#[oracle(aztec_utl_getL1ToL2MembershipWitness)]\nunconstrained fn get_l1_to_l2_membership_witness_oracle(\n    _contract_address: AztecAddress,\n    _message_hash: Field,\n    _secret: Field,\n) -> (Field, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {}\n"
     },
     "80": {
@@ -3095,7 +3095,7 @@
           "start": 2433
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
       "source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns true if the nullifier has been emitted in the same transaction, i.e. if [notify_created_nullifier] has 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(\n    inner_nullifier: Field,\n    contract_address: AztecAddress,\n) -> bool {\n    is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(\n    _inner_nullifier: Field,\n    _contract_address: AztecAddress,\n) -> bool {}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before\n/// the current transaction is included in a block. While this might seem of little use at first, certain design\n/// patterns benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier)\n}\n\n// TODO(F-498): review naming consistency\n#[oracle(aztec_utl_doesNullifierExist)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n"
     },
     "81": {
@@ -3113,7 +3113,7 @@
           "start": 838
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/public_call.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/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 validate_public_calldata(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        validate_public_calldata_wrapper(calldata_hash)\n    }\n}\n\nunconstrained fn validate_public_calldata_wrapper(calldata_hash: Field) {\n    validate_public_calldata_oracle(calldata_hash)\n}\n\n// TODO(F-498): review naming consistency\n#[oracle(aztec_prv_assertValidPublicCalldata)]\nunconstrained fn validate_public_calldata_oracle(_calldata_hash: Field) {}\n"
     },
     "83": {
@@ -3139,7 +3139,7 @@
           "start": 1146
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/tx_phase.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/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 in_revertible_phase(current_counter: u32) -> bool {\n    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// TODO(F-498): review naming consistency\n#[oracle(aztec_prv_isExecutionInRevertiblePhase)]\nunconstrained fn in_revertible_phase_oracle(current_counter: u32) -> bool {}\n"
     },
     "84": {
@@ -3165,7 +3165,7 @@
           "start": 2151
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/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 = 30;\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::{\n        assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR,\n    };\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"
     },
     "86": {
@@ -3183,7 +3183,7 @@
           "start": 1189
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/map.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/map.nr",
       "source": "use crate::protocol::{storage::map::derive_storage_slot_in_map, traits::ToField};\nuse crate::state_vars::StateVariable;\n\n/// A key-value container for state variables.\n///\n/// A key-value storage container that maps keys to state variables, similar to Solidity mappings.\npub struct Map<K, V, Context> {\n    pub context: Context,\n    storage_slot: Field,\n}\n\n// Map reserves a single storage slot regardless of what it stores because nothing is stored at said slot: it is only\n// used to derive the storage slots of nested state variables.\nimpl<K, V, Context> StateVariable<1, Context> for Map<K, V, Context> {\n    fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot }\n    }\n\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    /// Returns the state variable associated with the given key.\n    ///\n    /// This is equivalent to accessing `mapping[key]` in Solidity.\n    pub fn at<let N: u32>(self, key: K) -> V\n    where\n        K: ToField,\n        V: StateVariable<N, Context>,\n    {\n        V::new(\n            self.context,\n            derive_storage_slot_in_map(self.storage_slot, key),\n        )\n    }\n}\n"
     },
     "88": {
@@ -3209,7 +3209,7 @@
           "start": 1334
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/public_mutable.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/public_mutable.nr",
       "source": "use crate::context::{PublicContext, UtilityContext};\nuse crate::protocol::traits::Packable;\nuse crate::state_vars::StateVariable;\n\n/// Mutable public values.\n///\n/// This is one of the most basic public state variables. It is equivalent to a non-`immutable` non-`constant` Solidity\n/// state variable.\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n\nimpl<T, Context, let M: u32> StateVariable<M, Context> for PublicMutable<T, Context>\nwhere\n    T: Packable<N = M>,\n{\n    fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T> PublicMutable<T, PublicContext> {\n    /// Returns the current value.\n    pub fn read(self) -> T\n    where\n        T: Packable,\n    {\n        self.context.storage_read(self.storage_slot)\n    }\n\n    /// Stores a new value.\n    pub fn write(self, value: T)\n    where\n        T: Packable,\n    {\n        self.context.storage_write(self.storage_slot, value);\n    }\n}\n\nimpl<T> PublicMutable<T, UtilityContext> {\n    /// Returns the value at the anchor block.\n    pub unconstrained fn read(self) -> T\n    where\n        T: Packable,\n    {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     }
   },
@@ -3264,7 +3264,7 @@
         "abi_public",
         "abi_only_self"
       ],
-      "debug_symbols": "pVjdbuowDH6XXnMR/+SPVzmaJrZ1E1IFqIMjHU28+3EgTgtSomrdxfLVpR+289kO/ek++rfL1+v+8Hn87rZ/frq3cT8M+6/X4fi+O++PB7H+dCb9A8BuSxtZfbe1siLm1d3tBHmVay8rQ17zteW8xvvqqNuCSSAIAAGeMgigQJ6FICDCHaAxGaBa0GZAeovUwmrhYokZWFIQMnCowGfg9St8dgODEKJJgBXEDKJaYraQYQVqAXEDJS5Co6BY0mckfUSsIFlYAHMGFhWIh5QIk8+EArwQUrrlbQZBLSFZnIBoFGQLG1IgSWD5Uk6bfAc+g5RntgnYDFKe70Ac45iAuGrxet10qpvX89j3STYzIYm8TruxP5y77eEyDJvu72643D70fdodbut5N8pdiaw/fMgqhJ/7oU/oupmeNvVHvfzlp30wUAgsPTBAncFxCunG4NjhxBAfGLDOQIWAHJfnPS73oMTgLMaaB1xnYNQUWjAzgl9lEUwti67OEE3IBHEWAdNiDwK44gG5mgehkUVpJ5pFCL6WxVhnQK8xSHHX9rGZRVuyGCnUYmgxxKgxiJixquaGGAFTqd4oAKMtFME9UlAjD0HVRHGKAuHJiYYeIxl1IhJPcUB4LGywLUWx5iKaaOocrlWZSkFhFgk/MfhGLsCrLhEC/44DSd1AdA0/GtqkWMTJBqZtBb/YDaGAsq8+1t1oqQui9jog42rqwgaFDaVMzbSrsj2LCcqOOGdrBEuLDKsjA1vaZC306LEaQ0OYYJA0CsG22q6wsaExRl84DHCVY33XxLVtsx2HxSkODDUnqDFDydoibmew6kZ7T3C2J756FKBW77SkzRMtT/mU4+vv9Olr+qSGPrFUKcEkcF58qgqmDJFgZmeaZxf86jlEYe0corh+DrFZP4cY1s4hxvVzqMmxcA4xr55DS7Xlq9riVqVC2VaQn6G1BswteZqQDjC52ANWmye3BMqodYY8k9dzsbcdmc7egmP1+G9Ni8Ty1EJtrLZQ2xKpC8pBHumhhb7I1e59Pz68J7gmrnG/exv6fPl5ObzP7p7/nfSOvmc4jcf3/uMy9olp/rJBfi4Guwn+5Zq+7T8=",
+      "debug_symbols": "pVjbbuIwEP2XPPPgufjGr6yqirZphRQBSmGlVcW/7xg8TkCyFTUv9cmkORzPnBkHfrqP/u3y9bo/fB6/u+2fn+5t3A/D/ut1OL7vzvvjQaI/nUl/ALDb0kZW322trIh5dfc4QV7l2svKkNd8bTmv8b466rZgEggCQICnDAIokGchCIhwB2hMBqgRtBmQ3iKNsEa4RGIGlhSEDBwq8Bl4/QifZWAQQjQJsIKYQdRIzBEyrEAjIDJQ9kVoFJRI+h9JHxErSBEWwJyBRQWikBJh0kwowAshpVveZhA0ElLECYhGQY6wIQWSBJYP5VTkO/AZpDyzTcBmkPJ8ByKMYwIi1eL1uunUN6/nse+TbWZGEnuddmN/OHfbw2UYNt3f3XC5/dP3aXe4refdKHdlZ/3hQ1Yh/NwPfULXzfS0qT8axET56QDRFwJLDwxQZ3CctnRjcOxwYogPDFhnoEJAjsvzHpcr8F4VWIw1BVxnYNQUWjAzgt9kEY2rZdHVGaIJmSDOdsC0WAECFgWENQWhkcVpDw6Cr2Ux1hnQ6x6kuWt1bGbRlixKW9f20GKgoFYK0qNVNzfMCJha9UYBGG2hCO6Rghp5COomipMGhCcRDT9GMioiEk/VhPDY2GBbjmLNZjTR1DlcqzOVgsJsJ/zE4Bu5AO/UFBD4dxxIKgPRNXQ0vEmxmJMNTGUFv1iGUECpq491GS13QVSDAs0GxZO7sEFhQ2lTM1VVyrOYoFTEOVsjWNpkUD0ysOVN1oEdPVb30DAmGCTdhWBbHVfYKGiM0RcOA1zlWD81ce3YbO/D4rQPDDUR1DhDydpibmewKqNdE5zVxFdfBag1Oy3p8ETLUz7l9fVX/kSq+ZMa/sTSpQQwncbL36qYoUhwpirBrz6HKKw9hyiuP4fYrD+HGNaeQ4zrz6Emx8JziHn1ObTUW77qLW51KpSygnwNrQ1gbtnThPQCk5s9YHV4csugjNpnyDN7PTd7W4j30xT3sfr6b02LxPI0Qm2sjlDbMqkLykF+NnfSCH2Rq937fnz4neCauMb97m3o8+Xn5fA+u3v+d9I7+jvDaTy+9x+XsU9M8x8b5OtisJvgX67p0/4D",
       "is_unconstrained": true,
       "name": "_increase_public_balance"
     },
@@ -3312,7 +3312,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "nZbdjuIwDIXfJde9iJ1f8yqjESpQRpWqgjqw0gr13TeBOmlXSpadG3Jwmq/HsZv2IU7d4f6178fz5VvsPh7iMPXD0H/th8uxvfWXMUQfQsYfq8VONcKS2OlGOP0cPL4GJ3YAjSD7GkHCIhBZ8JTiKcURzRHNESNZaBa0CKtY+EU4voVbXICPQBWFWQRJFksEpWTBEeAIRBshK0RgwREVr7FRmEXoGHFRmEUYjhi/iOgZIzl6RhOEC0CMU9HqSzwj89wI3vr9beq6uPOrWoQKXdupG29iN96HoRG/2uH+vOj72o7P8dZOYVY2ohtPYQzAcz90Uc1NXi3LS0FKbZblQVuXEEZtGFBmkI2FeCLIKswE2hCw5sJbNgGSEsHhf+ShfMoDlCzlUWWAdZnhbYlhKgzM24lkEiHA1gRbJqDnciryaT3C1oKrlENJtkBK53KA33aFryCkVoyQJIsIKiNUIii/SkNvAVApB4LjpkDw+mcMVGwjPNcVH5XmVOS4s7SEXFJwb9sICEhFdVS0UWssIOLGUtKWGgsqCON5L6zMNQ3VeRuQCmKtKQHef8BW7f33YVPrTc0IcljMgmouUKXTRqJxxQOrkgoR5Uwk6CKjcm5acKkg4Ms2Kr2JqTWRdOnYrOdhMOeBvmhCV7rbmNTdVmLJxj9qgquauPJLpHZyGsVHJxqd9zO82uf5M/xtj/20+diZI2zq28PQLX/P9/G4mr39vvIMfyxdp8uxO92nLpLyFxOEd/uH8Y2Vn3O82x8=",
+      "debug_symbols": "nZbdjuIwDIXfJde9iJ1f8yqjESpQRpWqgjqw0gr13TeBOG1XSpadG3Jwmq/HsZv2IU7d4f6178fz5VvsPh7iMPXD0H/th8uxvfWXMUQfQsYfq8VONcKS2OlGOP0cPL4GJ3YAjSD7GkFCEogseErxlOKI5ojmiJEsNAtKwioWPgnHt3DJBfgIVFGYJEiySBGUkgVHgCMQbYSsEIEFR1S8xkZhktAx4qIwSRiOGJ9E9IyRHD2jCcIFIMapaPUlnpF5bgRv/f42dV3c+VUtQoWu7dSNN7Eb78PQiF/tcH9e9H1tx+d4a6cwKxvRjacwBuC5H7qo5mZZLctLQWoNaXnQVmWEURsGlBlkgRFkFS4E2hCw5sJbNgGSMsHhf+ShdM7DoC3lUWUYqxaGxxLDVBihNRiBZDLB2w3BlgnouZyKfF6PsLXgKuVQki2Q0ksS4Ldd4SuIsJuMkCSLCCojVCYov0pDbwFQKQeC46ZA8PpnDFRsIzzXFR+V5lTkfGJoCUtJwb1tIyAgF9VR0UatsYCIG0tJW2osqCCM572wcqlpqM7bgFwQa00J8P4DRrp42NR6UztuTYfFLKjmAlU+bSQaVzywKqkQkcsMCbrIqJybFlwuCPiyjUpvYm5NXO3mX8dmPQ+DSx7oiyZ0pbuNyd1tJZZs/KMmuKqJK79EaienUXx0otHLfoZX+zx/hr/tsZ82HztzhE19exi69Pd8H4+r2dvvK8/wx9J1uhy7033qImn5YoLwbv8wvrHyc453+wM=",
       "is_unconstrained": true,
       "name": "balance_of_public"
     },
@@ -3350,7 +3350,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "nVbbauMwEP0XP+dBM6Pb5FdKKW7qFoNxgpssLCX/vqNaYzsBiWxeouNRfHzmKv00H9375eutHz+P383+5ad5n/ph6L/ehuOhPffHUaw/jUk/YGKzp10DQM3epjXOK/p5JWj2Ia3yzLJayKub7c7kVZ4BBHijQC2BFMQMIgqIAhgU+BkghAwQFOgWqYXUYtWS1MyAM3BWQczAkwL9REAFQohGQDQKXAasFs4WMkaBWkBkICTgM0C1YPqPxJfIKEgWiSxZoyBm4EQhJcKkmVCAF0JKWwEUqCUmi0sgWbyAFMwZcALX667RhL+dp65L+d5UgNTFqZ268dzsx8sw7Jo/7XD5/dP3qR1/13M7ya4o6sYPWYXwsx+6hK679W1TfjUy+/w2G4gLgaMbBigzsE8VMzN4wpWBbxiwzCAlrhoADC8MAR/3IvLiRQglLyoMLH2jDNIYJQZXZvDWqgZvfTEOvsxACwF5W4pCVUEIqsAhlxTEMoNFLSW3TYR7KorBFqupRmGiMmxcsP+RSFwlWFOUUKtHmVZajzJVForobymoTCFzSlPJa1Mh3ImwFT9keqkfZNdygnjb2+BqsbS0tAWbMke1KJWC4sYTe8cQKrGAoO2NEO1zHEgqQ46big6ueMJBS8saWNMK4WEZQgFLXgOXZdSqC1jbHMj4UnVhhcJFDYY3a1YlPQ8TLBnxm1l3R/Bok0UsNRnWatPqrOKARR987dRAWo4Ngy4UT55KQpk5LBwGbJGjMjS93J80mhDLMiqliUtlIhcnf90Ph6sfGEsiqHKQk3NLcXuDRRn1nOAmJ6F4ClJtdjrS4SmXxDWecuF8qj75uftAGs75HIJbhld5ag/9dHNbvyauqW/fhy4/fl7Gw2b3/PekO3rbP03HQ/dxmbrEtLnyyzXxRWoquNdr+to/",
+      "debug_symbols": "nZbbjuIwDIbfpddcxHaOvMpoNCpQRpWqgjqw0grx7utM47QgJWK5IX9d+HDsP4dbc+h21++vfjyefprtx63ZTf0w9N9fw2nfXvrTyNFbo+IHKN9sadMAULPVcfTziHYeCZqtiyM/Bx41pNHMcaPSyM8ALKwSIRFHInwSHll4FgFE2FkguCQQRMgrkghJREskZjOLkITRInwSlkTIXzgUwUBULLwSYZIIEgkpQkqJkAhwGghR2CRQIhi/w/UlUiJihCtLWonwSRjOkCIw5kzIwjKQ4isHIiTiY8REESOWRSzmLEIU9/umkYZ/Xaaui/1eOYB9cW6nbrw02/E6DJvmTztcf7/0c27H3/HSTvyWM+rGA48MPPZDF9V9s/xalX8aKGD6ddCgM8DQAwEqBBsdMxMs4UIIDwQsE9jiNhEAVMgEh6/Pwps8C0elWdQIhpwQjIUSwZQJVuuQCFbbYh1smUAZQFaXqlDNwMkcrMFQysCXCRrFSmbdCPNWFZ0quqmGUF4Iqyno/2gkLCnwGiulUPMj71biR95VMsLbRwSVEbxPSSuDzwCEpyR0zdIqW5r0Yifwj2sbTK2WmoShgiozqqYUBPnVTPQTwVVqAU6WN4LX7zGQJA0+bip5hMpMghNraQVLW8G9nAYjIPfVhXIaNXdBkGUOpGzJXVhBGC/FsGrpKrfnZUDuiLWmBHh1kTlfWmRY86bOBIfFOdjaqYGUjw2FxhVPnkpDQwguM9T6/HtiVDZNy/cnqSb4choVa2J2Jobizl+fh8FlHuhLSVDlICdjsrmtwmIa9Z7gqieueApSbe80JJsnXxKXevKF8y1/hvfuA6DyrQYeCZ/81O776eG2fo+sqW93Q5cej9dxv3p7+XuWN3LbP0+nfXe4Tl0kra78fE38YE8583mP//YP",
       "is_unconstrained": true,
       "name": "check_balance"
     },
@@ -5192,7 +5192,7 @@
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "tb3djiW5cbV9L3M8B0kGGUHqVgxBkGXZGGAgGWPpBT4YuvdvJ4OLT2uMytmuap9orx51xSIjMp7Kn+jc//3Dv/35X//+H3/46S///tf/+uF3//LfP/zrLz/9/PNP//GHn//6pz/+7ae//uX1X//7h+v+n9J++F21f/z4Q1l/KvHD7/rrD2Xsz5mf9dqfZX/W/Wn7s+3Pvj99f+54dcerO57tePaK5/fn6+/H/Rn7c+zPmZ/t9ffH/fnym/dn2599f3p+9te6ynULk2gSXeL1d0u5RUgMibmFXxKvBZb6EnELu8UdsN2iS7hESAyJO+C90XEv7N7pMIkm0SXuOPduR0gMibnFvCSKxP3jd27m/eN3EmZIDImZol5Xrqdeexn1ahJdwiX2Muo1JPYyarkkikSVeP14vW4REkNibnEfTilKLr7eB1QttzCJJtEl9gZrDYkhoQ2aNmjaoGmDpg2aNmjaoGmDpg02bbBpg00bbNpg0wabNti0wa4Ndm2wa4NdG+zaYNcGuzbYtcGuDXZt0LVB1wZdG3Rt0LVB1wZdG3RtMLTB0AZDGwxtMLTB0AZDGxza4NAGhzY4tMGhDQ5t8D7Ca71FSAyJucV9hKcoElXCJJpEl1iRXxyrN8dqJJdqtP3Z96fvz9ifY38ml9a2+t5V35vqe099b6nvHfW9ob7343upsVcae6Gx1xl7mXey7oZ8VdPuflyfZX/W/TkSVrY67har45YoEjUZZcUkmkSXcIlIjtnqnRfHbHVKu0WRqBIm0SR6HnW2OsVvMbdYnbJEkdgHkt20TtEkuoRL7EPU1Cm2GH4nYTF8iSbRJXyvp2sZrmW4luFVQstwLcO1DNcy1CmmTrG7He4j3O5jKUWT6BIuEXvxq1PuhK9OucXqlCWKhDY4tMGhDQ5tcGiDQxuc2uDUBqc2OLXBqQ1ObXBqg1MbnHuD7dobbJdJNIku4RJ7g+3aG2zX3mArl0SR2BtsxSSaRJfYG2xlb7DVS6JIVIm9wVabRJdwiZDQBk0bNG3QtEHTBk0bNG3QtEHTBps22LTBtonUmkk0iS7hEiExJDbrWr8kikTdHLPFsdd/bvevt/yw/Gj50fPjZdNef7/l+dsPv7tP5vr9h7XZu0VeH6//5voL5R+vP+lM8A9/++XPf77/n29ODV8njP/5x1/+/Je//fC7v/z9559//OH//fHnv6+/9F//+ce/rM+//fGX1//7ytuf//Jvr89XwH//6ec/3+ofP/LT18c/6jX2D3vY+fFR3v35HlU/X+L8fPi7P/+FpbcbqOuH25hYx9tLL5ftAC/ZToTXr/+3Q9S7hzJEbfapEG2oAr1f83MhThE+HaLX64Ron8tFRFOImP7VEOO6PhniFHWU+qkQw8oJ0T61Cr/qaYvL2udCxHVCjP6pEOUapzlr+WSIRohPpdNrOat4XQ18PZ3jc6u4yllFaZ8McX11I6+rjhPCP1XU0i/x4nWZzNE52tvcjKIILYJFdPunCLU9LMKGavq6FfCpRQw7ixi9frgI/zjEOOUY5Ztq1Pd/gcz7pCbXMHt8uIbxcYjXVbYS8bp0JoTXfw4xPw4x7eo7xHydsp8QZfzzRuxhJ/NqOq7m9c1B8T9ilI9j2AnxKi7pbL+KUB8iXOfAel1A9c/FKKeqr+uphxgPR+frHFtFaVchRon3l+FNh8brIqV9bivex4nhn0zpLOLv66Jifhxj/N+mY0Y5y4iPl/H0W5WD40Ww8lGztacj9HWHRqt43ZUgxHg/RHP9JnldzfaPQjyfNY5z1hjtw308HJ+v21MHGv2bXyS/DtEf2HfOO0f7Blz/TJ3mT2eu56Dor7sjHBT//IuoxcMvszjnjB7NPwzxtIrXL0Stwr/JxGdDtPK5EOEnxPxkCJ+EqJ8K0b85i4/P5SJm5/y5fxji6cAa4s385pfqrw6s3r98YHX/8oH1uIr3Dqy3Q3x8YD2HeOvAeg7x1oH1GOK9A+sxxNcPrGL1nDLaN0X9NbMeQ0w/Z531w6PTn0K87jCfVVzjwxMlfzo8naPz42sRfyDnaCrImB9fBPjD7/TXDTgt4nWf7SHGw4mnz65lxPVw/+MpRnBsRZ/jkzHO7+Tw8skY41z2x5jXJ2PYPDHiO8T47Dq+yenrLsDnjg87p0qv+6fzczH61Dqa949vH8T4+jH2FOPd2j7HeK+2b8f47Dre7Jd3YzwdH88x3uy5eLroVIjZP74zNB5IWkoBx6W2j28ajod1vG5RFa3kpev45Fqq97MWKx/f3xkPvTvcFGS8Lv8+GeP8yh/+cCP1eTd2zqFeun98tM6Hy77XUR7nF9XD7e2nGJO77PNV76/HqNdnY1TObB/28vWLpvn1i6bnnRwuz3p93HmP50Fm51Tq9fT0w/OgdTfmQ4icbIxvMVTH+yHGuY84v71Z/78LESfEJ1cRcQ7zz64izg2S8fmNXF/dyPRz9TbaZ0OcVvvmqdr/LkSPr4Z4/Z8gvVyfXAeXC08xHm/VzNm4pekf3aoppT7txc+97nLNb37b/uquU7nnQT5+KsWDGCjq81cR2hO9uIbzj+5Ul9K/fqu6FP/6vepS4qs3q0sZX7/F+xzkzfuzpV5fvkH7Gwt57w7t4zHm55fCqO3DY6w+RJjtAMjbh8dYbV/+HVtq//Iv2ed1vHcH6f0YH99C+o0Yb91D+o0Yb91Eeo7x3l2k5xjv3UZ6PMJexG8HpvYxx8y+fow9PWR69xh7XMebx9jbMR6OsecY7x1jzzHeO8YeY7x5jD3G+C7HWHCMTfvwGGv168dYs68fY4/rePMYezvGwzH2HOO9Y+w5xnvH2GOMN4+xxxjf4xgrZ8rodc51fXiM9fL1Y6zXrx9jj+t48xh7O8bDMfYc471j7DnGe8fYY4w3j7HHGN/lGDt3Ckr95sTy18eYX18/xrx8/Rh7XMebx9jbMR6OsecY7x1jzzHeO8YeY7x5jD3G+B7HWO3nKrt+8zzsfxxj8+vHWFzf4Rib3+EYm9/hGJvf4Rib3+EYm9/hGJv/x8dYn+cGipePz/kfY3g/v2/94TiN+fWnx2VcX318XEb56vPjMurXHyCXYV9/uvcY5N1HYr8R5L3nWc9B3nzQ+BtB3nvS+H6QT6/kzeeEz8fJmw+Sn4O8+SS5PD32ePtgewrydomfg7xZ4reDfHol7/bOu0Eej5PnIO82YPnqE+X6+ODg7UfK6x8EfP2Z8m+s5t2HyvWyrz9V/o0g7z1W/o0NvftcuV7+9QfLj0HefbL8fpB6fTrIW8+Wa/n6hVYtX7/Q+o3NvPd4+flM6c3ny/XpgdV7z5cfQ7z3fPk3QrzzfPk3NvLO8+XfCFG+GuK958uPId57vvwbId55vvwc4q3ny48h3n2+/LyO954vPz5yez2x7dyi8Y8f7D5egtNs9ZuzgF/FqPXpgeq5am3fnFuV+at2ffq3UIOj/JtF/M8QjxdY7QwJV/+YX0/L+OYYjU/uZM7zO+769pL1fxPj9eCgch5SPg7y9DCjVf3Kbt9c6JXxq4P06TnVu8/sq/WvP7NfB+LXntlXezpK3/wXZs9B3vwnZtXml5/ZPy/k7QmEp+Y3nodaH58DiHGW2uqH0yX16VlVGafvymwf3muu7Xscq+17HKvt68dq+x7Havsex2r7Dsdq+y7H6tMk1Ov3JJdD3/7D+F9NQtWnJ1bTazlDJt0/jvE4TXX+Tfo3MwS/PkIeVxF2Ti2j949X8TSF+bryPr8kXto+ivLUNFbPLxqzj/81Ye3xeLOYm9bf3JV8/980mg39qnr1Tvl4FQ/H6eu3x/l3kc0+fOxenx5pvI0QL98BIV6/jBC374CQxyDvIuRpXvhdhDwu5E2E/EaQ9/5R9XOQN6f2qs//45S8ObX32HmtnRj9+rj/4/Hfd+tYbd/cNfjVW3weF9HLOdq7Xx8v4umarF/cuuvX/Jjs8T2Y+htrKTxy6tUe1vKA1XbI3I3i/i9erlRPVvu3b5e4s/r715/++Keffvnnd4mulz7e77mMuxD3Cyv358zP+91e92nt/UKr9Vn35/1Kq7rfaVX3S61sv9Xq/oz7PR33C/b258zP++V167Psz7o/bX+2/dn3p+/PHc92PNvx2o7Xdry247Udr+14bcdrO17b8dqO13a8vuP1Ha/veH3H6zte3/H6jtd3vL7j9R3Pdzzf8XzHu19t11+VvN9stz77/rzfS/hqz/u1dutz7M+Zn/fbH++zjPvlj/ffv192tz53vPXexPvv9f2548WOt96beP/8zM+x440db+x4Y8cbe31jr2/seGPHG3t9Y69v7nj3u+7WZ92fO97c8eaOd7/mbn3G/hz7c+ZnuV+0eAcu95sWU1QJk2hpUu7X36VwiVCcIaHI9+vvUhSJKmESO52ldAmXCImd0nznbtVLd6veunvptbuX3rt76cW7l968e+nVu5fevXvp5btFb98tev1u2e/fTbETXO4OSqFsmCKbIpsim7JhykZTNprW3JTnpjw3ZaMpG015vvsphbLRFLkrclfkrmx0ZaMrG11r7spzV567stGVDVeevUgoG+qvogYr6rDiyoYrG65suNYcynMoz6FshLIRynPoqAtlIxQ5FDkUeSgb6riilivqufWG4WUxlGe1XVHfrTcML6+ho06tt94wvOJMRVb3FbVfUf8VNWBRB66XDy+LufNc1YNVPVivnef1OuIUTWJHXq8jThESQ2Jno6oHq3pwvY54WRSTaBJdYud5vak4xZBQ5KrI6sGqHqzqwaoerOrB9abiZVFDYkgoG7bzXK1IKBumyKbI6sGqHqzqwaoerOrB9e7iZdGUZ/VgVQ/Wpjy3LqFsNEVuiqwerOrBqh6s6sGqHlyvNe56rXHXa41TKBtdee77qKvqweqK7IqsHqzqwaoerOrBqh6s+kVX9ZuuqgerenC96Hh5hY469WC+J/jSi4IvvSn40quCL70r+NLLgi+9LfjS64L1DuSudyB3vQO56x3Iy2voqFMPrncgrzhTkdWDVT1Y1YNVPVjVg+vlwstiKs/qwaoeXC8cvr3WG4dTVIkd2a4m0SVcIiSGxF7zekHxsihFokqYxM7zekFxCpdQ5KLI6kFTD5p60NSDph60uvNstUu4REjsPFvdR52pB9c7kFccU2T1oKkHTT1o6kFTD663Ii8LU57Vg6YeXG9FXl7NJJSNpshNkdWDph409aCpB009uF6YvCy68qweNPXgemHy8uohoWx0RXZFVg+aetDUg6YeNPWg6VTTdK5p6kFTD5pONy101KkHTWec6+3KKRRZPWjqQVMPmnpwvV15WQzlWT1o6sH1duXlNXTUqQdtKPJQZPWgqQdNPWjqQVMPrvctL4upPKsHTT243re8vOY+6pp6sF078noVcwqTaBJdwiVCYud5vYp5CfVgUw+uVzEvr2ISTUKRiyKrB5t6sKkHm3qwqQfXy5mXRTWJJtEldp7Xy5lTDAlFNkVWDzb1YFMPNvVgUw+u9zYvCwsJZUM9uN7bvLxakVA2miI3RVYPNvVgUw829WBTD673Ni+LrjyrB5t6sHXluXcJZaMrcldk9WBTDzb1YFMPNvVgc0VWDzb9Hmz6Pdh0Ltp0LtrUg03XfE0XfU092NSDTT3YdC7aQhVUDzb1YFs92G5xR77fvL16cAmTaBJdwiVCYkjMLVYPLqHIU5GnIk9Fnoo8FXkq8lTkuSP365IoElXCJJpEl3CJkBgSilwUuShyUeSiyEWRiyIXRV49OG8xJOYWdw/e96D73YMpqoRJtPsfat+i66dcQpHvHsy/PLcwRTZFvntwxbl7MIUimyKbIpsim9ZsWnNT5KbITWtuWnNT5LsHU7iEIjdFboq8enCJIlElTKJti7sHU7hESIztdffgEncPplBkV2RX5NWDSygbrmy41uzKsyvPoWyEshHKcyjPoWyEIocihyKHshHKxlA2htY8lOehPA9lYygbQ3le31+xhLIxFHkq8lTkqWxMZWMqG1NrnsrzVJ6nsjF3Nvzaefa7B1NUiR3ZrybRJVwiJIbEXrOXnWcvRaJKmMTOs5cu4RKKrB509aDXS6JIVAmtue48e+0SLhESO89e91HnpmyYIpsimyKbsqEedPWgqwfddp7dlGf1oKsHvSnPzSSUjabITZHVg64edPWgqwddPehdee7Ks3rQ1YPeleceEspGV2RXZPWgqwddPejqQVcPuivPrjyrB1096KE8h4469aCHIociqwddPejqQVcPunrQh/I8lGf1oKsHfSjPQ0edetCHIg9FVg+6etDVg64edPWgT+V5Ks/qQVcP+lSe5z7qQj0Y144cV5UwiSbRJVwiJHae49p5DvVgqAej7DxHMYkmochFkdWDoR4M9WCoB0M9GPo9GPo9GOrBUA9G3XmOGhJDQpFNkdWDoR4M9WCoB0M9GLbzHBYSyoZ6MJry3IqEstEUuSmyejDUg6EeDPVgqAejK89deVYPhnowuvLcu4Sy0RW5K7J6MNSDoR4M9WCoB8OVZ1ee1YOhHgxXnl1HnXowQpFDkdWDoR4M9WCoB0M9GKE8h/KsHgz1YAzleeioUw/GUOShyOrBUA+GejDUg6EejKk8T+VZPRjqwZjK89RRpx6MuSOP65IoElXCJJpEl9h5HldIDImdjVF2nkcpElVCkYsiqweHenCoB4d6cKgHh85Fh85Fh3pwqAeHzkVH7RIuochVkdWDQz041INDPTjUg8N2nod1CWVDPThs53nYPuqGenA0RW6KrB4c6sGhHhzqwaEeHE15bsqzenCoB0dXnrtJKBtdkbsiqweHenCoB4d6cKgHhyvPrjyrB4d6cLjy7CGhbLgihyKrB4d6cKgHh3pwqAdHKM+hPKsHh3pwDOV56KhTD46hyEOR1YNDPTjUg0M9ONSDYyrPU3lWDw714JjK89RRpx4cU5GnIqsHp3pwqgenenCqB+e18zyvLuESIbHzPK991E314CyKXBRZPTjVg1M9ONWDUz04iyKrB6d+D079Hpw6F506F53qwanrwanrwakenOrBqR6cOhedViQUWT04Vw/aLe7vtrv3vr7Ec4mQGBJzi7sHUxSJKmESTUKRmyI3RW6K3BS5K/Ldg/fQybx7MIVJNIku4RIhMSTmFncPplBkV2RXZFdkV2RX5LsH72mNefdgirnF3YMpikSVMIkm0SVc4o581+LuwRSvyKPfz78viSJRJUyiSXQJlwiJIaHIU5GnIk9Fnoo8FfnuwXvGZ949mCIkhsT9XYhjPaO/jipH1aPsqHZUP8qPiqPGUcejHI9yPMrxKMejHI9yPMrxKMejHI9yPOrxqMejHo96POrxqMejHo96POrxqMfDjocdDzsedjzseNjxsONhx8OOhx2Pdjza8WjHox2Pdjza8WjHY33D4z06+5IDOY+8O7fc37jzkgVZkYZsyI50ZCAHch7puDlujpvj5rg5bo6b4+a4OW6BW+AWuAVugVvgFrgFboFb4DZwG7gN3AZuA7eB2/reybrqtr6FeMuBXG7zlusbKbcsyIq09e8Elmwnwvpuyi1xW99PuX9sII/bmuCRLIq7pngkDXnc1iyPpCMDOZC4FdxKQVYkbuvLLbfsSNwKbgW39cWXKddXX25ZkBVpx3h9BeaWHenIOGtYX4W55TzScDPcDLf1/a9bkkkjk8be7NRtTQNJkslGJht1a9StkcmGW8Ot4dbIZCOTjUx29tapW6dunUx2Mtmp22LJlmSy49Zxc9ycTDqZdDLp7M2pm1M3J5NOJp26LZZsSSYDt8AtcAsyGWQyyGSwt6Bug7oNMjnI5KBugw4YZBKWFFhSYEl+q3nKSSYnmZzsbVK3Sd0mmZxkclK3SQfMk8n8GvQVd80iSVakIRuyIx156pZflL7lyWSFJfl16bmGUpGGxK3gBksqLKmwpMKSCkvy29XTuFakIRvy1C2/Z33LQOJWcYMlFZZUWFJhSYUl+V3saWyOJJOwJL+TPdfQLiSZbLg13GBJhSUVllRYUmFJbdStUzdYUmHJmnnaa+gNSSY7bh03WFJhSYUlFZZUWJJf+J7GTt1gSYUl+cXvuQYfSDIZuAVusKTCkgpLKiypsKQGdQvqBksqLMnvi881DDoAltSB28ANllRYUmFJhSUVllTOSyrnJRWWVFiy5qj2GiYdAEvqxG0eN4MlBksMlhgsMVhi16mbXY4M5ECeuuXXwG9ZkLgV3GCJwRKDJQZLDJZYOXWzeiELsiJP3dYElmRH4lZxgyUGSwyWGCwxWJLfS5/G1pBkEpas2ay9BhtIMtlwa7jBEoMlBksMlhgsyW+xT+NG3WCJwZL8ovtcQ69IMtlx67jBEoMlBksMlhgsMaduTt1gicGSNdO11+COJJOOm+MGSwyWGCwxWGKwxIK6BXWDJQZL1rzXXsOgA2CJDdwGbrDEYInBEoMlBkuMaxzjGsdgicES4xpnTYNJkkmucWziBksMljRY0mBJgyXtOnVrV0N2pCNP3dakmOTJZCu4FdxgSYMlDZY0WNJgSSunbq0M5MlkgyVrhmyvoVakIXGruMGSBksaLGmwpMGSZqduzSqSTMKSNV+212COJJOGm+EGSxosabCkwZIGS1qjbo26wZIGS9bs2V5Dv5BksuPWcYMlDZY0WNJgSYMlrVM3p26wpMGSNZe21+ANSSYdN8cNljRY0mBJgyUNlrSgbkHdYEmDJWtmba8h6ABY0gZuAzdY0mBJgyUNljRYsubYFJe9cV7SOC9pXOM0rnEaLGncL2ncL2mwpMGSBksa1zhrwk3yuHVY0vN+SV1y1a0v2ZGODORAziPzvCRlQVakIXEruBXcCm4Ft4Jbxa3iVnGruFXcKm4Vt4pbxa3iZrgZboab4Wa4GW6Gm+FmuBlueY0TSxZkRS63VcLFki070pHLbS45iDCP7LglS9aP5XlJStw6bnmNs+Lm/ZKUuHXcOm6Om7M3Z2+Om+Pm7M3Zm+OW1zgp55GBW+AWuC2WbNmQHenIOMbJkpTzyDwvSVnOGvIaJ6UhcRu4DdySJSnJ5CCTk71N6jap2ySTk0xO6jap2ySTE7d53Py6kAVZkYZsyFM3vxwZyIE8dfNkScqCxK3gVnArHenIQA7kqZvXC1mQFXnq5smSlB2JW8Wt4lbJpJFJI5PG3uzUza0hyaSRSTt1cxtIMglLHJY4LPFGJhuZbGSysbdG3Rp1a2Syk8lO3XpFksmOW8et49bJJCxxWOKwxJ26OXWDJQ5L3KmbO5JMOm6OGyxxWOKwxGGJwxIP6hbUDZY4LPGgboMOgCU+cBu4wRKHJQ5LHJY4LPFB3SZ1gyUOS3xSt0kHwBKfuE3cYInDkoAlAUsClsR16hZXQ3akI0/d4hrIk8kouBXcYEnAkoAlAUsClkQ5dYsykCeTAUuinrpFrUhD4lZxgyUBSwKWBCwJWBJ26hZWkWQSloSduoU5kkwaboYbLAlYErAkYEnAkuC8JDgvCVgSsCQadesXkkx23DpusCRgScCSgCUBS6JTN6dusCRgSTh184Ykk46b4wZLApYELAlYErAkgroFdYMlAUsiqFvQAbAkBm4DN1gSsCRgScCSgCUxqNugbrAkYElM6jbpAFgSE7eJGywJWBKwJGDJgCXjOnUbV0UasiFP3cblyEAO4uIGSwYsGbBkwJIBS0Y5dRvFkYEcyFO3US9kQeJWcYMlA5YMWDJgyYAlo566DbuQZBKWDDt1G9aQZNJwM9xgyYAlA5YMWDJgyeAaZ3CNM2DJgCWDa5zRBpJMco0zOm6wZMCSAUsGLBmwZHTq1qkbLBmwZDh184okk46b4wZLBiwZsGTAkgFLRlC3oG6wZMCSEdQt6ABYMgK3wA2WDFgyYMmAJQOWjEHdBnWDJQOWjEHdJh0AS8bEbeIGSwYsGbBkwJIBS8Y8dZvXhSzIijx1m1dDduRxm1cgB/JkcsKSCUsmLJnl1G2WhuxIR566zTKQJ5Oz4lZxgyUTlkxYMmHJhCWznrrNOpBkEpZMO3WbVpFk0nAz3GDJhCUTlkxYMmHJbLjBksl5yeS8ZHKNM7nGmbBkcr9kcr9kwpIJSyYsmVzjzM5RAksmLFkzp+V+i1pZU6flftNZWXOnWy6WbFmQFWnIhuxIRwYSN8ctcAvcArfALXAL3AK3wC1wC9wGbgO3gdvAbeA2cBu4DdwGbgO3idvEbeI2cVssud8ZWNb8qqQjl9sq4WLJlnPLugZZJZfbWLLuCHXNsko2ZOfHHBnIgZwn7mLJlrgV3ApuBbfSkY7EreBW2FtlbxW3xZItDYlbxa3itliy5UDOIxdLtizHeLFkS0M2ZD9rWCzZMpC4GW4Nt8WSLclkI5ONvTXq1qhbI5ONTDbq1qlbJ5Mdt45bx62TyU4mO5ns7K1TN6duTiadTDp1S5akJJOOm+PmuDmZDDIZZDLYW1C3oG5BJoNMBnVLlqQkkwO3gdvAbZDJQSYHmRzsbVC3Qd0GmZxkclK3SQdMMjlxm7hN3CaZnGRynkzm3OuWp24597qlIRvy1C3nXrcM5CAubgW3UpAVaciGPHXLudctAzmQp24597plQeJWcYMlBZYUWFJgSYElOfeaxnYhySQsybnXXIM1JJk03Aw3WFJgSYElBZYUWJJzr2ncqBssKbAk515zDW0gyWTHreMGSwosKbCkwJICS3LuNY07dYMlBZbk3GuuwSuSTDpujhssKbCkwJICSwosybnXNA7qBksKLMm511xD0AGwJOded1zcYEmBJQWWFFhSYEnOvabxoG6wpMCSnHvNNUw6AJbk3GvGnbjBkgJLCiwpsKTAksJ5SeW8pMKSCkty7nWtIedet+zI45Zzr1sO5MlkhSUVllRYknOvaVwasiMdeeqWc69bnkzm3GvGrbjBkgpLKiypsKTCkpx7TeM6kGQSluTca67BKpJMGm6GGyypsKTCkgpLKizJudc0btQNllRYknOvuYbmSDLZcGu4wZIKSyosqbCkwpKce03jTt1gSYUlOfeaa/ALSSYdN8cNllRYUmFJhSUVluTcaxoHdYMlFZbk3GuuIegAWJJzrxk3cIMlFZZUWFJhSYUlOfeaxoO6wZIKS3LuNdcw6ABYknOvGXfiBksqLKmwpMKSCkvqpG6TusESgyXGNU7OvW5pyOOWc69bOjKQA3kyabAk517TuFSkIRvy1C3nXrcMJG4FN1hisMRgicESgyU595rG1ZGBHMhTt5x73ZJMGm6GGywxWGKwxGCJwZKce03jRt1gicGSnHvNNbSGJJMNt4YbLDFYYrDEYInBkpx7TeNO3WCJwZKce8019IEkk46b4wZLDJYYLDFYYrAk517T2KkbLDFYknOvuYagA2BJzr1m3MANlhgsMVhisMRgSc69pvGgbrDEYEnOveYaBh0AS3LudcfFDZYYLDFYYrDEYEnOvWZcWGKclxjnJcY1TuMap8GSxv2Sxv2SBksaLGmwpHGNk3OvW+IGS3LuNd9xu1hyf3dLzbnXLRuyIx0ZyIGcRy6WbFmQuFXcKm4Vt4pbxa3iVnEz3Aw3w81wM9wMN8PNcDPcDLeGW8Ot4dZwa7g13BpuDbfFkvsbbGrOvaZcLNlyua0SLpZsaciGXG6xpBMhkLgtluSPLZZsiZvjtliScRdLtsTNcXPcHDdnb8HeArfALdhbsLfAbbFky0DiFrgN3BZLtqxIQzZkP8aLJVsGciDnWcNiyZYFidvEbeK2WLIlmZxkcrK3eeqWc69bFmRFnrrl3OuWHXnccu51y4E8mcy51y0LsiJP3XLudcuOdOSpW869bnkymXOvGbfiVnGrhmzIjmRv9dQt5163JJNGJu3ULedetySThpvhZrgZmTQyaWSysbdG3Rp1a2SykclG3ZojySQs6bCkw5Kce92STHYy2dlbp26dunUy2clkp25+Icmk4+a4OW5OJmFJhyUdluTcaxoHdYMlHZbk3GuuIegAWJJzrxk3cIMlHZZ0WNJhSYclOfeaxoO6wZIOS3LuNdcw6ABYknOvGXfiBks6LOmwpMOSDkty7jWNJ3WDJQ5Lcu51rSHnXrc05HHLudctHRnIgTyZdFiSc69pXCrSkA156pZzr1sGEreCGyxxWOKwxGGJw5Kce03j6shADuSpW869bkkmDTfDDZY4LHFY4rDEYUnOvaZxo26wxGFJzr3mGlpDksmGW8MNljgscVjisMRhiXNe4pyXOCxxWJJzr7mGPpBk0nFz3GCJwxKHJQ5LHJbk3GsaO3WDJQ5Lcu411xB0ACzJudeMG7jBEoclDkscljgsybnXNB7UDZY4LMm511zDoANgSc697ri4wRKHJQ5LHJY4LMm51zSe1A2WOCzJude1hpx73bIgj1vOvW7ZkB3pyEAO5Klbzr1uWZAVeeqWc69bdiRuBTdYErAkYEnAkoAlOfeaxrUhO9KRp24597olmTTcDDdYErAkYEnAkoAlOfeaxjaQZBKW5NxrrqFVJJlsuDXcYEnAkoAlAUsClgTXOME1TsCSgCXBNU7OvW5JJrnGybnXlLAkYEnAkoAlAUty7jWNnbrBkoAlOfeaawg6AJbk3GvGDdxgScCSgCUBSwKW5NxrGg/qBksCluTca65h0AGwJOdeM+7ADZYELAlYErAkYEnOvabxpG6wJGBJzr3mGiYdAEty7nXFzbnXLSvSkA3ZkY48dcu51y1PJgcsybnXXEOpSEPiVnCDJQOWDFgyYMmAJTn3msa1Ig3ZkKduOfe6ZSBxq7jBkgFLBiwZsGTAkpx7TWNzJJmEJTn3mmtoF5JMNtwabrBkwJIBSwYsGbAk514zLiwZnJcMzksG1ziDa5wBSwb3Swb3SwYsGbBkwJLBNU7OvW6JGyzJudf7hZI15159fRHSYsmWAzmPXCzZsiAr0pAN2ZG4BW6BW+A2cBu4DdwGbgO3gdvAbeA2cBu4TdwmbhO3idvEbeI2cZu4Tdzmccu51y0Lcrm1JQ3ZkMutL+nIQA7kcrubIedeM8JiyZa4LZbkjy2WbIlbwW2xZMcdSNwqbhW3iltlb5W9VdwqbpW9VfZWcVss2bIgcTPcDLfFki0dGciBnMd4sWTLgqxIO2tYLNmyI3FruDXcFktSdjLZyWRnb526derWyWQnk526derWyaTj5rg5bk4mnUw6mXT25tTNqZuTySCTQd2SJSnJZOAWuAVuQSaDTAaZHOxtULdB3QaZHGRyULdkSUoyOXAbuE3cJpmcZHKSycneJnWb1G2SyUkmp+pmOfe6ZUHKza7DErsOSyznXrd0ZCAHUnWznHvdsiAr0s4aSkN2JG4Ft4JbmUcelth1WGJXZW/VjnFtyI50ZJw11IEkk4ab4Wa4GZk0Mmlk0tibxTG2gSSTjUw26tYqkkw23BpuDbdGJhuZbGSys7dO3Tp162Syk8lO3bojyWTHrePmuDmZdDLpZNLZm1M3p25OJp1MOnULOiDIZOAWuAVuQSaDTAaZDPYW1G1Qt0EmB5kc1G3QAYNMDtwGbgO3QSYnmZxkcrK3Sd0mdZtkcpLJSd0mHQBLcu51xc251y0r0pAN2ZGOPHUr57zECiwpsCTnXnMNpSINiVvBDZYUWFJgSYElBZbk3Gsa14o0ZEOeuuXc65aBxK3iBksKLCmwpMCSAkty7jWNzZFkEpbk3GuuoV1IMtlwa7jBkgJLCiwpsKTAkpx7TeNO3WBJgSU595pr6A1JJjtuHTdYUmBJgSUFlhRYknOvaezUDZYUWJJzr7kGH0gyGbgFbrCkwJICSwosKbAk517TOKgbLCmwJOdecw2DDoAlOfeacQdusKTAkgJLCiwpsCTnXtN4UjdYUmBJzr3mGiYdAEty7nXHPW4VllRYUmFJhSUVltRzjWP1XONYhSUVltRzjWM597plQeJWcIMlFZZUWFJhSYUlOfeaxvVCFmRFnrrl3OuWHYlbxQ2WVFhSYUmFJRWW5NxrGltDkklYknOvuQYbSDLZcGu4wZIKSyosqbCkwpKce03jRt1gSYUlOfeaa+gVSSY7bh03WFJhSYUlFZZUWJJzr2ns1A2WVFiSc6+5BnckmXTcHDdYUmFJhSUVllRYknOvaRzUDZZUWJJzr7mGQQfAkpx7zbgDN1hSYUmFJRWWVFiSc69pPKkbLKmwJOdecw2TDoAlOfeacSdusKTCEoMlBksMluTc64prsMQ4LzHOS4xrHOMax2CJFdwKbrDEYInBEuMaJ+det8QNluTcq49bLpZEWbIgK9KQDdmRjgzkQM4jDTfDzXAz3Aw3w81wM9wMN8Ot4dZwa7g13BpuDbeGW8Ot4dZw67h13DpuHbeOW8dtsSRsyUAO5HJbJVws2bIgK3K59SXbibBYsiVuiyX7xwYSt8BtsSTjLpZsiVvgFrgFbsHegr0FbgO3wd4Gexu4LZZs2ZG4DdwGboslKRdLtizIirRjvFiyZUc6Ms4aFku2nJI597ri5tzrlhVpyIbsSEeeuuXc65Ynkzn3uuWpW869bmlI3ApuBbcSyIE8mcy51y1P3XLudUtDNuSpW869bhlI3CpuhpuRSSOTRiaNvdmpW869bkkmjUwadUuWpCSTDbeGW8OtkclGJhuZbOytUbdO3TqZ7GSyU7fekGQSljRY0mBJzr2mdDLpZNLZm1M3p25OJp1MOnXzgSSTgVvgFrgFmYQlDZY0WJJzr2kc1A2WNFiSc6+5hkEHwJKce824AzdY0mBJgyUNljRYknOvaTypGyxpsCTnXnMNkw6AJTn3uuMetw5LOizpsKTDkg5Lcu51Gefc65aBHMhTt5x73bIgcSu4wZIOSzos6bCkw5Kce03jeiELsiJP3XLudcuOxK3iBks6LOmwpMOSDkty7jWNrSHJJCzJuddcgw0kmWy4NdxgSYclHZZ0WNJhSc69pnGjbrCkw5Kce8019Iokkx23jhss6bCkw5IOSzos6ZyXdM5LOizpsCTnXnMN7kgy6bg5brCkw5IOSzos6bAk517TOKgbLOmwJOdecw2DDoAlOfeacQdusKTDkg5LOizpsCTnXtN4UjdY0mFJzr3mGiYdAEty7jXjTtxgSYclDkscljgsybnXZZxzr1t2pCNP3XLudcuTyZx7zbgFN1jisMRhicMShyU595rGZSBPJh2W5NxrrqFWpCFxq7jBEoclDkscljgsybnXNLaKJJOwJOdecw3mSDJpuBlusMRhicMShyUOS3LuNY0bdYMlDkty7jXX0C8kmey4ddxgicMShyUOSxyWONc4zjWOwxKHJc41Ts69bkkmucbJudctcYMlDkscljgsybnXNA7qBkscluTca64h6ABYknOvGXfgBkscljgscVjisCTnXtN4UDdY4rAk515zDZMOgCU595pxJ26wxGGJwxKHJQFLcu51Gefc65aGbMhTt5x73TKQg7i4wZKAJQFLApYELMm51zQujgzkQJ665dzrlgWJW8UNlgQsCVgSsCRgSc69prFdSDIJS3LuNddgDUkmDTfDDZYELAlYErAkYEnOvaZxo26wJGBJzr3mGtpAksmOW8cNlgQsCVgSsCRgSc697rjsjfOS4LwkuMYJrnEClgT3S4L7JQFLApYELAmucXLudUvcYEnOvd7f6Gs59zpWzhZLtnRkIAdyHrlYsmVBVuTtNnzJhuxIRwZyIOeRiyVbFmRF4jZxm7hN3CZuE7fFknnfE8u51y3P3nLudUtDNmRHOjKQA3kymXOvW+JWcCu4FdwKbgW3gls5e8u515T1QhZkRRqyITvSkYHEreJmuBluhpvhtliSWTf2ZuzN2JuRSSOTjUw2MtnIZCOTjUw23BpuDbeGW8Ot49Zx6+yts7dOJjuZ7GSyk8lOJjuZdDLpZNJxc9wcN8fNcXPcFksy64sl93dlW869blmQFWnIhuxIRwZyuc0l55GLJVsWZEUasiE70pGBxG3gNnGbuE3cJm43S15PYpfsyJfb60HrkoEcyCm55l4lC7IiDdmQHenIQA4kbgW3glvBreBWcCu4FdwKbgW3glvFreJWcau4VdwqbhW3ilvFreJmuBluhpvhZrgZboab4Wa4GW4Nt4Zbw63hdrOk3l9sbWvutd5fh2Rr7lUykAM5j7xZIlmQFWnIhsSt49Zx67h13Bw3x81xc9wcN8fNcXPcHDfHLXAL3AK3wC1wC9wCt8AtcAvcBm4Dt4HbzZLXE/8lG7IjHRnIgZxH3iyRLMiKxG3iNnGbuE3cJm5Tbm3NvUoWZEUasiE70pGBHEjcCm4Ft4Jbwa3gVnAruBXcCm4Ft4pbxa3iVnGruFXcKm4Vt4pbxc1wM9wMN8PNcDPcDDfDzXAz3BpuDbeGW8Ot4dZwa7g13BpuDbeOW8et49Zx67h13DpuHbeOW8fNcXPcHDfHzXFz3Bw3x81xc9wCt8AtcAvcArfALXAL3AK3wG3gNnAbuA3cBm4Dt4HbwG3gNnCbuE3cJm4Tt4nbxG3iNnGbuMGSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAksKLCmwpMCSAktKsqQuebv1/K+BHMjbrbdbLpbc/y60rblXydvNUxqyITvydosVd7Fky9vtvpvU1txrjfvvrrlXydstxj9+/OH//fGXn/74rz//+b9++N1/v/7473//y5/+9tNf/7L/+Lf/7z/1//zrLz/9/PNP//GH//zlr3/687/9/Zc//+Hnv/7p/v9+KPf/vGL/i5X40az//nU+9PrTizw/vnjw+tPNkn+xq/9oV/z+FarqB17P8398PQ3fP1C9/lij6gealx+b2/0Ddv+ArSA/tuv+L13/pdrL8vf/+Mc/fv+P/x8=",
       "is_unconstrained": false,
       "name": "claim",
       "verification_key": "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"
@@ -7035,7 +7035,7 @@
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "claim_and_end_setup",
       "verification_key": "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"
@@ -7092,13 +7092,13 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "public_dispatch"
     }
   ],
   "name": "FeeJuice",
-  "noir_version": "1.0.0-beta.25+75061fab15986eedee4e7d9104ff87dd9fa4ca10",
+  "noir_version": "1.0.0-beta.26+40d6574f851d926f93e0c3a271bac3e6e82ac905",
   "outputs": {
     "globals": {
       "storage": [
@@ -7348,5 +7348,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "0.0.1-commit.321f6a9"
+  "aztec_version": "0.0.1-commit.330febf"
 }