@aztec-labs/protocol-contracts 6.0.0-rc.1 → 6.0.0-rc.3

package/artifacts/ContractClassRegistry.json

@@ -706,51 +706,63 @@
         },
         {
           "name": "poseidon2_hash_bytes",
-          "start": 11953
+          "start": 12580
+        },
+        {
+          "name": "poseidon2_hash_bytes_matches_hash_of_packed_chunks",
+          "start": 13179
+        },
+        {
+          "name": "poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk",
+          "start": 13418
+        },
+        {
+          "name": "poseidon2_hash_bytes_commits_to_chunk_count",
+          "start": 13638
         },
         {
           "name": "subarray_hash_matches_fixed",
-          "start": 12529
+          "start": 13869
         },
         {
           "name": "subarray_hash_matches_variable",
-          "start": 12928
+          "start": 14268
         },
         {
           "name": "subarray_hash_with_separator_matches_fixed_len_with_separator",
-          "start": 13384
+          "start": 14724
         },
         {
           "name": "smoke_sha256_to_field",
-          "start": 14009
+          "start": 15349
         },
         {
           "name": "unique_siloed_note_hash_matches_typescript",
-          "start": 15411
+          "start": 16751
         },
         {
           "name": "siloed_nullifier_matches_typescript",
-          "start": 16633
+          "start": 17973
         },
         {
           "name": "siloed_private_log_first_field_matches_typescript",
-          "start": 17013
+          "start": 18353
         },
         {
           "name": "empty_l2_to_l1_message_hash_matches_typescript",
-          "start": 17423
+          "start": 18763
         },
         {
           "name": "l2_to_l1_message_hash_matches_typescript",
-          "start": 17874
+          "start": 19214
         },
         {
           "name": "poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version",
-          "start": 18490
+          "start": 19830
         }
       ],
       "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). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[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 subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
+      "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash of a fixed string, such as a function signature or a domain separator name.\n///\n/// The bytes are packed into 31-byte little-endian chunks, one `Field` per chunk, and the result is\n/// [`poseidon2_hash`] of those fields.\n///\n/// The hash commits to the number of chunks but not to the byte length `N`: zero bytes at the end of the last chunk\n/// do not change the result, so `[1]`, `[1, 0]` and `[1, 0, ..., 0]` (31 bytes) all hash to the same value. Do not\n/// use this to commit to variable-length data, e.g. a payload zero-padded to a maximum length, unless the length is\n/// bound separately.\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon2_hash_bytes_matches_hash_of_packed_chunks() {\n    let mut bytes = [0; 32];\n    bytes[0] = 1;\n    bytes[1] = 2;\n    bytes[31] = 3;\n\n    assert_eq(poseidon2_hash_bytes(bytes), poseidon2_hash([1 + 2 * 256, 3]));\n}\n\n#[test]\nfn poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk() {\n    let hash = poseidon2_hash_bytes([1]);\n\n    assert_eq(poseidon2_hash_bytes([1, 0]), hash);\n    assert_eq(poseidon2_hash_bytes([1].concat([0; 30])), hash);\n}\n\n#[test]\nfn poseidon2_hash_bytes_commits_to_chunk_count() {\n    let one_chunk: [u8; 31] = [1].concat([0; 30]);\n    let two_chunks: [u8; 32] = [1].concat([0; 31]);\n\n    assert(poseidon2_hash_bytes(one_chunk) != poseidon2_hash_bytes(two_chunks));\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
     "196": {
       "function_locations": [
@@ -4088,5 +4100,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "6.0.0-rc.1"
+  "aztec_version": "6.0.0-rc.3"
 }

package/artifacts/ContractInstanceRegistry.json

@@ -352,7 +352,7 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V2, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            DOM_SEP__CONTRACT_ADDRESS_V2,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x303ffc8bd456d132463b1fc3a633aeb718a7883c268f3956c05e6fe09b5a5424;\n    assert_eq(address, expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V2);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x0fa1c698858df1a99170cd39d5f4bfad6d0d60f1f8afa3dc92281ee60b36f3bb;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nfn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
+      "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V3, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            DOM_SEP__CONTRACT_ADDRESS_V3,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x23877639c7424d1d2a9f514e59ee662b3154a730b783caf822d196b625ba4355;\n    assert_eq(address, expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V3);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x2e0787752b82b3ab9c28d67b48f24f8a3dac253023bf5136bbcb8ddbf4b1381c;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nfn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
     },
     "145": {
       "function_locations": [
@@ -846,23 +846,23 @@
         },
         {
           "name": "ScheduledValueChange<T>::get_time_horizon",
-          "start": 4008
+          "start": 4037
         },
         {
           "name": "ScheduledValueChange<T>::schedule_change",
-          "start": 8420
+          "start": 8926
         },
         {
           "name": "<impl Eq for ScheduledValueChange<T>>::eq",
-          "start": 8747
+          "start": 9253
         },
         {
           "name": "<impl Empty for ScheduledValueChange<T>>::empty",
-          "start": 8987
+          "start": 9493
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
-      "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n    pub(crate) pre: T,\n    pub(crate) post: T,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n    pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n    /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n    /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon (see\n    /// `get_time_horizon()`).\n    pub fn get_current_at(self, timestamp: u64) -> T {\n        // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n        // - in public, any transaction that is included at the timestamp of change will use the post value\n        // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n        //   the post value (barring any follow-up changes)\n        if timestamp < self.timestamp_of_change {\n            self.pre\n        } else {\n            self.post\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n    /// value. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (T, u64) {\n        (self.post, self.timestamp_of_change)\n    }\n\n    // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n    // value might not be the current anymore since timestamp of change might have already passed.\n    pub fn get_previous(self) -> (T, u64) {\n        (self.pre, self.timestamp_of_change)\n    }\n\n    /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n    /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n    /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n    /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n    /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n    /// however, then this value is the 'effective minimum delay' (obtained by calling\n    /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n    /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n    /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon\n    /// computed using the same anchor timestamp.\n    pub fn get_time_horizon(self, anchor_block_timestamp: u64, minimum_delay: u64) -> u64 {\n        // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n        // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n        // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n        // to the time horizon.\n        if anchor_block_timestamp >= self.timestamp_of_change {\n            // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n            // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n            // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n            // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n            // timestamp, and so the smallest possible next timestamp of change equals `anchor_block_timestamp + 1 +\n            // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n            //\n            //   timestamp of    anchor\n            //      change       timestamp          time horizon\n            //   =======|=============N===================H===========>\n            //                         ^                   ^\n            //                         ---------------------\n            //                             minimum delay\n            anchor_block_timestamp + minimum_delay\n        } else {\n            // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n            //   a) It could be so far into the future that the time horizon is actually determined by the minimum\n            //      delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n            //      This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n            //      the timestamp prior to the earliest one in which a new timestamp of change might land.\n            //\n            //         anchor\n            //         timestamp                      time horizon    timestamp of change\n            //        =====N=================================H=================|=========>\n            //              ^                                 ^\n            //              |                                 |\n            //              -----------------------------------\n            //                        minimum delay\n            //\n            //   b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n            //      the timestamp of change would become the limiting factor for the time horizon, which would equal\n            //      the timestamp right before the timestamp of change (since by definition the value changes at the\n            //      timestamp of change).\n            //\n            //           anchor                         time horizon\n            //           timestamp   timestamp of change    if not scheduled\n            //        =======N=============|===================H=================>\n            //                ^           ^                     ^\n            //                |     actual horizon              |\n            //                -----------------------------------\n            //                          minimum delay\n            //\n            // Note that the current implementation does not allow the caller to set the timestamp of change to an\n            // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n            // allow for this to happen.\n            // Because anchor_block_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n            // subtract 1.\n            min(\n                anchor_block_timestamp + minimum_delay,\n                self.timestamp_of_change - 1,\n            )\n        }\n    }\n\n    /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n    /// called in public with the current timestamp.\n    pub fn schedule_change(\n        &mut self,\n        new_value: T,\n        current_timestamp: u64,\n        minimum_delay: u64,\n        timestamp_of_change: u64,\n    ) {\n        assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n        self.pre = self.get_current_at(current_timestamp);\n        self.post = new_value;\n        self.timestamp_of_change = timestamp_of_change;\n    }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n    T: Empty,\n{\n    fn empty() -> Self {\n        Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n    }\n}\n"
+      "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n    pub(crate) pre: T,\n    pub(crate) post: T,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n    pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n    /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n    /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon (see\n    /// `get_time_horizon()`).\n    pub fn get_current_at(self, timestamp: u64) -> T {\n        // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n        // - in public, any transaction that is included at the timestamp of change will use the post value\n        // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n        //   the post value (barring any follow-up changes)\n        if timestamp < self.timestamp_of_change {\n            self.pre\n        } else {\n            self.post\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n    /// value. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (T, u64) {\n        (self.post, self.timestamp_of_change)\n    }\n\n    // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n    // value might not be the current anymore since timestamp of change might have already passed.\n    pub fn get_previous(self) -> (T, u64) {\n        (self.pre, self.timestamp_of_change)\n    }\n\n    /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n    /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n    /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n    /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n    /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n    /// however, then this value is the 'effective minimum delay' (obtained by calling\n    /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n    /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n    /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon\n    /// computed using the same anchor timestamp.\n    pub fn get_time_horizon(self, anchor_block_timestamp: u64, minimum_delay: u64) -> u64\n    where\n        T: Eq,\n    {\n        // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n        // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n        // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n        // to the time horizon.\n        //\n        // A scheduled change with `post == pre` does not change the current value at its timestamp of change. An\n        // example is a cancellation, which schedules the current value. Such a change does not limit the time\n        // horizon. Only a change that is scheduled after the anchor block can give a different value, and\n        // `minimum_delay` limits that change in the same way as when the timestamp of change has passed.\n        if (anchor_block_timestamp >= self.timestamp_of_change) | (self.pre == self.post) {\n            // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n            // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n            // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n            // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n            // timestamp, and so the smallest possible next timestamp of change equals `anchor_block_timestamp + 1 +\n            // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n            //\n            //   timestamp of    anchor\n            //      change       timestamp          time horizon\n            //   =======|=============N===================H===========>\n            //                         ^                   ^\n            //                         ---------------------\n            //                             minimum delay\n            anchor_block_timestamp + minimum_delay\n        } else {\n            // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n            //   a) It could be so far into the future that the time horizon is actually determined by the minimum\n            //      delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n            //      This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n            //      the timestamp prior to the earliest one in which a new timestamp of change might land.\n            //\n            //         anchor\n            //         timestamp                      time horizon    timestamp of change\n            //        =====N=================================H=================|=========>\n            //              ^                                 ^\n            //              |                                 |\n            //              -----------------------------------\n            //                        minimum delay\n            //\n            //   b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n            //      the timestamp of change would become the limiting factor for the time horizon, which would equal\n            //      the timestamp right before the timestamp of change (since by definition the value changes at the\n            //      timestamp of change).\n            //\n            //           anchor                         time horizon\n            //           timestamp   timestamp of change    if not scheduled\n            //        =======N=============|===================H=================>\n            //                ^           ^                     ^\n            //                |     actual horizon              |\n            //                -----------------------------------\n            //                          minimum delay\n            //\n            // Note that the current implementation does not allow the caller to set the timestamp of change to an\n            // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n            // allow for this to happen.\n            // Because anchor_block_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n            // subtract 1.\n            min(\n                anchor_block_timestamp + minimum_delay,\n                self.timestamp_of_change - 1,\n            )\n        }\n    }\n\n    /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n    /// called in public with the current timestamp.\n    pub fn schedule_change(\n        &mut self,\n        new_value: T,\n        current_timestamp: u64,\n        minimum_delay: u64,\n        timestamp_of_change: u64,\n    ) {\n        assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n        self.pre = self.get_current_at(current_timestamp);\n        self.post = new_value;\n        self.timestamp_of_change = timestamp_of_change;\n    }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n    T: Empty,\n{\n    fn empty() -> Self {\n        Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n    }\n}\n"
     },
     "17": {
       "function_locations": [
@@ -1138,51 +1138,63 @@
         },
         {
           "name": "poseidon2_hash_bytes",
-          "start": 11953
+          "start": 12580
+        },
+        {
+          "name": "poseidon2_hash_bytes_matches_hash_of_packed_chunks",
+          "start": 13179
+        },
+        {
+          "name": "poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk",
+          "start": 13418
+        },
+        {
+          "name": "poseidon2_hash_bytes_commits_to_chunk_count",
+          "start": 13638
         },
         {
           "name": "subarray_hash_matches_fixed",
-          "start": 12529
+          "start": 13869
         },
         {
           "name": "subarray_hash_matches_variable",
-          "start": 12928
+          "start": 14268
         },
         {
           "name": "subarray_hash_with_separator_matches_fixed_len_with_separator",
-          "start": 13384
+          "start": 14724
         },
         {
           "name": "smoke_sha256_to_field",
-          "start": 14009
+          "start": 15349
         },
         {
           "name": "unique_siloed_note_hash_matches_typescript",
-          "start": 15411
+          "start": 16751
         },
         {
           "name": "siloed_nullifier_matches_typescript",
-          "start": 16633
+          "start": 17973
         },
         {
           "name": "siloed_private_log_first_field_matches_typescript",
-          "start": 17013
+          "start": 18353
         },
         {
           "name": "empty_l2_to_l1_message_hash_matches_typescript",
-          "start": 17423
+          "start": 18763
         },
         {
           "name": "l2_to_l1_message_hash_matches_typescript",
-          "start": 17874
+          "start": 19214
         },
         {
           "name": "poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version",
-          "start": 18490
+          "start": 19830
         }
       ],
       "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). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[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 subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
+      "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash of a fixed string, such as a function signature or a domain separator name.\n///\n/// The bytes are packed into 31-byte little-endian chunks, one `Field` per chunk, and the result is\n/// [`poseidon2_hash`] of those fields.\n///\n/// The hash commits to the number of chunks but not to the byte length `N`: zero bytes at the end of the last chunk\n/// do not change the result, so `[1]`, `[1, 0]` and `[1, 0, ..., 0]` (31 bytes) all hash to the same value. Do not\n/// use this to commit to variable-length data, e.g. a payload zero-padded to a maximum length, unless the length is\n/// bound separately.\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon2_hash_bytes_matches_hash_of_packed_chunks() {\n    let mut bytes = [0; 32];\n    bytes[0] = 1;\n    bytes[1] = 2;\n    bytes[31] = 3;\n\n    assert_eq(poseidon2_hash_bytes(bytes), poseidon2_hash([1 + 2 * 256, 3]));\n}\n\n#[test]\nfn poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk() {\n    let hash = poseidon2_hash_bytes([1]);\n\n    assert_eq(poseidon2_hash_bytes([1, 0]), hash);\n    assert_eq(poseidon2_hash_bytes([1].concat([0; 30])), hash);\n}\n\n#[test]\nfn poseidon2_hash_bytes_commits_to_chunk_count() {\n    let one_chunk: [u8; 31] = [1].concat([0; 30]);\n    let two_chunks: [u8; 32] = [1].concat([0; 31]);\n\n    assert(poseidon2_hash_bytes(one_chunk) != poseidon2_hash_bytes(two_chunks));\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
     "192": {
       "function_locations": [
@@ -2727,7 +2739,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "public_dispatch"
     },
@@ -4633,14 +4645,14 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
       "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "publish_for_public_execution",
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "abi": {
@@ -4753,7 +4765,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "update"
     }
@@ -5185,5 +5197,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "6.0.0-rc.1"
+  "aztec_version": "6.0.0-rc.3"
 }

package/artifacts/FeeJuice.json

@@ -566,51 +566,63 @@
         },
         {
           "name": "poseidon2_hash_bytes",
-          "start": 11953
+          "start": 12580
+        },
+        {
+          "name": "poseidon2_hash_bytes_matches_hash_of_packed_chunks",
+          "start": 13179
+        },
+        {
+          "name": "poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk",
+          "start": 13418
+        },
+        {
+          "name": "poseidon2_hash_bytes_commits_to_chunk_count",
+          "start": 13638
         },
         {
           "name": "subarray_hash_matches_fixed",
-          "start": 12529
+          "start": 13869
         },
         {
           "name": "subarray_hash_matches_variable",
-          "start": 12928
+          "start": 14268
         },
         {
           "name": "subarray_hash_with_separator_matches_fixed_len_with_separator",
-          "start": 13384
+          "start": 14724
         },
         {
           "name": "smoke_sha256_to_field",
-          "start": 14009
+          "start": 15349
         },
         {
           "name": "unique_siloed_note_hash_matches_typescript",
-          "start": 15411
+          "start": 16751
         },
         {
           "name": "siloed_nullifier_matches_typescript",
-          "start": 16633
+          "start": 17973
         },
         {
           "name": "siloed_private_log_first_field_matches_typescript",
-          "start": 17013
+          "start": 18353
         },
         {
           "name": "empty_l2_to_l1_message_hash_matches_typescript",
-          "start": 17423
+          "start": 18763
         },
         {
           "name": "l2_to_l1_message_hash_matches_typescript",
-          "start": 17874
+          "start": 19214
         },
         {
           "name": "poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version",
-          "start": 18490
+          "start": 19830
         }
       ],
       "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). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[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 subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
+      "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion). Its value is the\n    // transaction's nonce commitment (origin, chain id, version, salt): see\n    // `TxRequest::compute_protocol_nullifier_value`. The reset kernel siloes it under\n    // `NULL_MSG_SENDER_CONTRACT_ADDRESS` like every other nullifier.\n    Nullifier { value: tx_request.compute_protocol_nullifier_value(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\n/// Computes sha256 hash of 2 input fields, prefixed by a domain separator, so that the result cannot collide with an\n/// [`accumulate_sha256`] over the same two fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256_with_separator(separator: u32, v0: Field, v1: Field) -> Field {\n    // Concatenate the separator and two fields into 4 + 32 x 2 = 68 bytes\n    let separator_as_bytes: [u8; 4] = (separator as Field).to_be_bytes();\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = separator_as_bytes.concat(v0_as_bytes).concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash with a domain separator over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// For `in_len == N` this is equivalent to [`poseidon2_hash_with_separator`].\n#[no_predicates]\npub fn poseidon2_hash_subarray_with_separator<let N: u32, T>(\n    input: [Field; N],\n    in_len: u32,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(input);\n    poseidon::poseidon2::Poseidon2::hash(inputs_with_separator, in_len + 1)\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n/// Computes a Poseidon2 hash of a fixed string, such as a function signature or a domain separator name.\n///\n/// The bytes are packed into 31-byte little-endian chunks, one `Field` per chunk, and the result is\n/// [`poseidon2_hash`] of those fields.\n///\n/// The hash commits to the number of chunks but not to the byte length `N`: zero bytes at the end of the last chunk\n/// do not change the result, so `[1]`, `[1, 0]` and `[1, 0, ..., 0]` (31 bytes) all hash to the same value. Do not\n/// use this to commit to variable-length data, e.g. a payload zero-padded to a maximum length, unless the length is\n/// bound separately.\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon2_hash_bytes_matches_hash_of_packed_chunks() {\n    let mut bytes = [0; 32];\n    bytes[0] = 1;\n    bytes[1] = 2;\n    bytes[31] = 3;\n\n    assert_eq(poseidon2_hash_bytes(bytes), poseidon2_hash([1 + 2 * 256, 3]));\n}\n\n#[test]\nfn poseidon2_hash_bytes_ignores_trailing_zeros_in_last_chunk() {\n    let hash = poseidon2_hash_bytes([1]);\n\n    assert_eq(poseidon2_hash_bytes([1, 0]), hash);\n    assert_eq(poseidon2_hash_bytes([1].concat([0; 30])), hash);\n}\n\n#[test]\nfn poseidon2_hash_bytes_commits_to_chunk_count() {\n    let one_chunk: [u8; 31] = [1].concat([0; 30]);\n    let two_chunks: [u8; 32] = [1].concat([0; 31]);\n\n    assert(poseidon2_hash_bytes(one_chunk) != poseidon2_hash_bytes(two_chunks));\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn subarray_hash_with_separator_matches_fixed_len_with_separator() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let separator = 42;\n\n    assert_eq(\n        poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n        poseidon2_hash_with_separator(values_to_hash, separator),\n    );\n    // Hashing the whole array must differ from hashing a prefix of it, even though the padding is zero.\n    assert(\n        poseidon2_hash_subarray_with_separator(padded, padded.len(), separator)\n            != poseidon2_hash_subarray_with_separator(padded, values_to_hash.len(), separator),\n    );\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
     "181": {
       "function_locations": [
@@ -7094,5 +7106,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "6.0.0-rc.1"
+  "aztec_version": "6.0.0-rc.3"
 }

package/dest/protocol_contract_data.js

@@ -19,19 +19,19 @@ export const ProtocolContractAddress = {
     FeeJuice: AztecAddress.fromBigIntUnsafe(3n)
 };
 export const ProtocolContractDerivedAddress = {
-    ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x0a80f1a867261f73366b038402bef355a9f7d0d48b65dc5859f936bdc85b01dd'),
-    ContractClassRegistry: AztecAddress.fromStringUnsafe('0x1d9b7b92e6f207ba7acf9ea59f402f563794b4668d112df80e7a289f872ee33f'),
-    FeeJuice: AztecAddress.fromStringUnsafe('0x2edff490433ce3c44345ba9116fc973f95bae381b3387e2ddb78245e518702ab')
+    ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x2b937086a6b367070f03fd007b932f64fcce36501ffcad6ff7c73f1d116e1c77'),
+    ContractClassRegistry: AztecAddress.fromStringUnsafe('0x2b95cb98fbd2723c66350f27310e670ff9faeaa8ca100ce83a3195e4d8235e17'),
+    FeeJuice: AztecAddress.fromStringUnsafe('0x064e81954bc70f4c8e060d4fa2ba0427eff0fe10f1f5aa57bf8f93c8745fac79')
 };
 export const ProtocolContractClassId = {
-    ContractInstanceRegistry: Fr.fromString('0x2ddcfb2affa46c76b4b24e24a5d7ca5fa4fe0db09a93eefb8719377d4ab4ac75'),
+    ContractInstanceRegistry: Fr.fromString('0x250bc22bd53e83820ec12b83b41addb81073884ef63e7dc5261787bf92850f7f'),
     ContractClassRegistry: Fr.fromString('0x010f027b753bf0e29dedc8e47a8bdda62211a7253b002b625cffb475495dc002'),
     FeeJuice: Fr.fromString('0x1fa4d16bbcc242b144b07ee9a424083ee404ed9ce11037b24c465057b6a92c59')
 };
 export const ProtocolContractClassIdPreimage = {
     ContractInstanceRegistry: {
-        artifactHash: Fr.fromString('0x272d6a46be29b8aae0d46c96f52cf09a4f5ecccdee332727d23b60cc12d7bea6'),
-        privateFunctionsRoot: Fr.fromString('0x225cf0ac7fe1c7649d253b0fc79b966ad847f7c762e361acad161fd40d9e70e2'),
+        artifactHash: Fr.fromString('0x28f9ec60f51cd93bc2cd3d021d3a0d1847cd3b4b57ed6fb22435d422b3a0fb31'),
+        privateFunctionsRoot: Fr.fromString('0x2cab3dca97df25e1b2f62b64540799a1130f8d2cf41aff507909ec075cb3905b'),
         publicBytecodeCommitment: Fr.fromString('0x1fd8380bb220e7d13db681da7e62c93b03add6754895a84c51d13fcde03e8d25')
     },
     ContractClassRegistry: {
@@ -54,7 +54,7 @@ export const ProtocolContractPrivateFunctions = {
     ContractInstanceRegistry: [
         {
             selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000077cff62f')),
-            vkHash: Fr.fromString('0x1cdc691d3fb13bcc6915dd93aa4d425cf2567a2000c9e5f8110edd1a44ca5578')
+            vkHash: Fr.fromString('0x0ba93c1df26342e4871884648597eba8204fe51b1295e00ecb69a011db1359b6')
         }
     ],
     ContractClassRegistry: [
@@ -75,9 +75,9 @@ export const ProtocolContractPrivateFunctions = {
     ]
 };
 export const ProtocolContractsList = new ProtocolContracts([
-    AztecAddress.fromStringUnsafe('0x1d9b7b92e6f207ba7acf9ea59f402f563794b4668d112df80e7a289f872ee33f'),
-    AztecAddress.fromStringUnsafe('0x0a80f1a867261f73366b038402bef355a9f7d0d48b65dc5859f936bdc85b01dd'),
-    AztecAddress.fromStringUnsafe('0x2edff490433ce3c44345ba9116fc973f95bae381b3387e2ddb78245e518702ab'),
+    AztecAddress.fromStringUnsafe('0x2b95cb98fbd2723c66350f27310e670ff9faeaa8ca100ce83a3195e4d8235e17'),
+    AztecAddress.fromStringUnsafe('0x2b937086a6b367070f03fd007b932f64fcce36501ffcad6ff7c73f1d116e1c77'),
+    AztecAddress.fromStringUnsafe('0x064e81954bc70f4c8e060d4fa2ba0427eff0fe10f1f5aa57bf8f93c8745fac79'),
     AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
     AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
     AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
@@ -87,13 +87,13 @@ export const ProtocolContractsList = new ProtocolContracts([
     AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
     AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000')
 ]);
-export const protocolContractsHash = Fr.fromString('0x0030cdae9792549b9edb5b865f4e10e91bb87565f22ab80d405213f7e991b378');
+export const protocolContractsHash = Fr.fromString('0x0f54271c52865841a77aaa66036eed901aff22fdce9f08e123ec8b205c9854d7');
 export const ProtocolContractGenesisNullifiers = [
     Fr.fromString('0x04287df03953b0d68b0e83e08a89067afc602626defd6002277cd6df34696818'),
     Fr.fromString('0x0d99507b7ecac720c73bf197a0e7366a5ed80c1c1b0afe8ff8c6ecc7b5a7aefe'),
     Fr.fromString('0x0eb50b367fb754d3a7d1238bfc105cc9b391a02e187be69038876ae9a502e877'),
+    Fr.fromString('0x16f917edd8e333013e5bb0633f7f484725bd19403854d6112992dccef4961e32'),
     Fr.fromString('0x1cea539e01abaa5db980e7ff52ef0d2a7772310306ac625783ae435756ee326d'),
-    Fr.fromString('0x2c1eb017f1534e95d91808e7ccc5f24a1cc6bf5686c6b6598e79b6f571d386fe'),
     Fr.fromString('0x2c3a57c8d7c387652babd36c4d79ab03c0fe593e160315a4dc098f92caf592c3')
 ];
 export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x1a7e1badb79abdd38c684b3c8306ffe7ecb33c69e3380d9855730aaaa83a21a8');

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aztec-labs/protocol-contracts",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
   "description": "Canonical Noir contracts for the Aztec Network",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0-rc.3",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -73,15 +73,15 @@
     ]
   },
   "dependencies": {
-    "@aztec-labs/constants": "6.0.0-rc.1",
-    "@aztec-labs/foundation": "6.0.0-rc.1",
-    "@aztec-labs/stdlib": "6.0.0-rc.1",
+    "@aztec-labs/constants": "6.0.0-rc.3",
+    "@aztec-labs/foundation": "6.0.0-rc.3",
+    "@aztec-labs/stdlib": "6.0.0-rc.3",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec-foundation/protocol-contracts-artifacts": "6.0.0-rc.1",
+    "@aztec-foundation/protocol-contracts-artifacts": "6.0.0-rc.6",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.chunk": "^4.2.9",

package/src/protocol_contract_data.ts

@@ -33,23 +33,23 @@ FeeJuice: AztecAddress.fromBigIntUnsafe(3n)
 
     
     export const ProtocolContractDerivedAddress = {
-      ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x0a80f1a867261f73366b038402bef355a9f7d0d48b65dc5859f936bdc85b01dd'),
-ContractClassRegistry: AztecAddress.fromStringUnsafe('0x1d9b7b92e6f207ba7acf9ea59f402f563794b4668d112df80e7a289f872ee33f'),
-FeeJuice: AztecAddress.fromStringUnsafe('0x2edff490433ce3c44345ba9116fc973f95bae381b3387e2ddb78245e518702ab')
+      ContractInstanceRegistry: AztecAddress.fromStringUnsafe('0x2b937086a6b367070f03fd007b932f64fcce36501ffcad6ff7c73f1d116e1c77'),
+ContractClassRegistry: AztecAddress.fromStringUnsafe('0x2b95cb98fbd2723c66350f27310e670ff9faeaa8ca100ce83a3195e4d8235e17'),
+FeeJuice: AztecAddress.fromStringUnsafe('0x064e81954bc70f4c8e060d4fa2ba0427eff0fe10f1f5aa57bf8f93c8745fac79')
     };
   
 
     
     export const ProtocolContractClassId: Record<ProtocolContractName, Fr> = {
-      ContractInstanceRegistry: Fr.fromString('0x2ddcfb2affa46c76b4b24e24a5d7ca5fa4fe0db09a93eefb8719377d4ab4ac75'),
+      ContractInstanceRegistry: Fr.fromString('0x250bc22bd53e83820ec12b83b41addb81073884ef63e7dc5261787bf92850f7f'),
 ContractClassRegistry: Fr.fromString('0x010f027b753bf0e29dedc8e47a8bdda62211a7253b002b625cffb475495dc002'),
 FeeJuice: Fr.fromString('0x1fa4d16bbcc242b144b07ee9a424083ee404ed9ce11037b24c465057b6a92c59')
     };
 
     export const ProtocolContractClassIdPreimage: Record<ProtocolContractName, { artifactHash: Fr; privateFunctionsRoot: Fr; publicBytecodeCommitment: Fr }> = {
       ContractInstanceRegistry: {
-        artifactHash: Fr.fromString('0x272d6a46be29b8aae0d46c96f52cf09a4f5ecccdee332727d23b60cc12d7bea6'),
-        privateFunctionsRoot: Fr.fromString('0x225cf0ac7fe1c7649d253b0fc79b966ad847f7c762e361acad161fd40d9e70e2'),
+        artifactHash: Fr.fromString('0x28f9ec60f51cd93bc2cd3d021d3a0d1847cd3b4b57ed6fb22435d422b3a0fb31'),
+        privateFunctionsRoot: Fr.fromString('0x2cab3dca97df25e1b2f62b64540799a1130f8d2cf41aff507909ec075cb3905b'),
         publicBytecodeCommitment: Fr.fromString('0x1fd8380bb220e7d13db681da7e62c93b03add6754895a84c51d13fcde03e8d25'),
       },
 ContractClassRegistry: {
@@ -71,7 +71,7 @@ FeeJuice: Fr.fromString('0x00000000000000000000000000000000000000000000000000000
     };
 
     export const ProtocolContractPrivateFunctions: Record<ProtocolContractName, { selector: FunctionSelector; vkHash: Fr }[]> = {
-      ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000077cff62f')), vkHash: Fr.fromString('0x1cdc691d3fb13bcc6915dd93aa4d425cf2567a2000c9e5f8110edd1a44ca5578') }],
+      ContractInstanceRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000000000000000000000000000000000000000000000077cff62f')), vkHash: Fr.fromString('0x0ba93c1df26342e4871884648597eba8204fe51b1295e00ecb69a011db1359b6') }],
 ContractClassRegistry: [{ selector: FunctionSelector.fromField(Fr.fromString('0x000000000000000000000000000000000000000000000000000000006934ed0d')), vkHash: Fr.fromString('0x1af8e7c965fa21b828e2307fb320fbf38038a42121495906aba2b80c3f072bd8') }],
 FeeJuice: [{ selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000cbe67243')), vkHash: Fr.fromString('0x2e78182eafa9eedb8a75d0eabee8cc7031a41b2d630949979a9495f6be9d9e2e') }, { selector: FunctionSelector.fromField(Fr.fromString('0x00000000000000000000000000000000000000000000000000000000e8d374b6')), vkHash: Fr.fromString('0x253da18011550ba749e4311e9dc5f59309a35c27b1d16e1f9ccb90bae9db1235') }]
     };
@@ -79,9 +79,9 @@ FeeJuice: [{ selector: FunctionSelector.fromField(Fr.fromString('0x0000000000000
 
     
     export const ProtocolContractsList = new ProtocolContracts([
-      AztecAddress.fromStringUnsafe('0x1d9b7b92e6f207ba7acf9ea59f402f563794b4668d112df80e7a289f872ee33f'),
-AztecAddress.fromStringUnsafe('0x0a80f1a867261f73366b038402bef355a9f7d0d48b65dc5859f936bdc85b01dd'),
-AztecAddress.fromStringUnsafe('0x2edff490433ce3c44345ba9116fc973f95bae381b3387e2ddb78245e518702ab'),
+      AztecAddress.fromStringUnsafe('0x2b95cb98fbd2723c66350f27310e670ff9faeaa8ca100ce83a3195e4d8235e17'),
+AztecAddress.fromStringUnsafe('0x2b937086a6b367070f03fd007b932f64fcce36501ffcad6ff7c73f1d116e1c77'),
+AztecAddress.fromStringUnsafe('0x064e81954bc70f4c8e060d4fa2ba0427eff0fe10f1f5aa57bf8f93c8745fac79'),
 AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
 AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
 AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000'),
@@ -92,7 +92,7 @@ AztecAddress.fromStringUnsafe('0x00000000000000000000000000000000000000000000000
 AztecAddress.fromStringUnsafe('0x0000000000000000000000000000000000000000000000000000000000000000')
     ]);
 
-    export const protocolContractsHash = Fr.fromString('0x0030cdae9792549b9edb5b865f4e10e91bb87565f22ab80d405213f7e991b378');
+    export const protocolContractsHash = Fr.fromString('0x0f54271c52865841a77aaa66036eed901aff22fdce9f08e123ec8b205c9854d7');
   
 
     
@@ -100,8 +100,8 @@ AztecAddress.fromStringUnsafe('0x00000000000000000000000000000000000000000000000
       Fr.fromString('0x04287df03953b0d68b0e83e08a89067afc602626defd6002277cd6df34696818'),
 Fr.fromString('0x0d99507b7ecac720c73bf197a0e7366a5ed80c1c1b0afe8ff8c6ecc7b5a7aefe'),
 Fr.fromString('0x0eb50b367fb754d3a7d1238bfc105cc9b391a02e187be69038876ae9a502e877'),
+Fr.fromString('0x16f917edd8e333013e5bb0633f7f484725bd19403854d6112992dccef4961e32'),
 Fr.fromString('0x1cea539e01abaa5db980e7ff52ef0d2a7772310306ac625783ae435756ee326d'),
-Fr.fromString('0x2c1eb017f1534e95d91808e7ccc5f24a1cc6bf5686c6b6598e79b6f571d386fe'),
 Fr.fromString('0x2c3a57c8d7c387652babd36c4d79ab03c0fe593e160315a4dc098f92caf592c3')
     ];