@aztec/protocol-contracts 0.87.1 → 0.87.2-nightly.20250524

package/artifacts/MultiCallEntrypoint.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.5+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.6+0000000000000000000000000000000000000000",
   "name": "MultiCallEntrypoint",
   "functions": [
     {
@@ -1680,18 +1680,18 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "notify_enqueued_public_function_call_wrapper",
         "call_private_function_internal",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
-      "name": "sync_notes",
+      "name": "sync_private_state",
       "is_unconstrained": true,
       "custom_attributes": [
         "utility"
@@ -1709,7 +1709,7 @@
       "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
       "debug_symbols": "nZPRioQgFIbf5Vx3oaWmvsowDFY2CGLh1MISvfvqoDu14DLMjSfzfF9/pRsMulvvN+PG6QHyskHnjbXmfrNTrxYzuXB3AxQH3IBsKsAEJA2FgmxDYSDFvleQ+2+L1zq2HwRBOyuv3QLSrdZW8KXs+mx6zMo966J8WEUVaDeEGoSjsTpe7dWLRmUUI0pYwjFiiP4qMCInCS5LWp4VPEBZ0OITX5d5WtPEU/p6B0zYuwF40+YAVJQCkDJPGpF4wvhHATjJAQQvBWBlPnz4xLOafRJA1HUSiIaWAvB/AvC8iVr05xdcw1T1xp/29h5V3qjO6jQdV9cfVpfvOa/kszH7qdfD6nU0HQ5IGC+YV3Vz3ePTfgA=",
       "brillig_names": [
-        "sync_notes"
+        "sync_private_state"
       ]
     },
     {
@@ -1847,12 +1847,12 @@
               "type": {
                 "fields": [],
                 "kind": "struct",
-                "path": "MultiCallEntrypoint::sync_notes_parameters"
+                "path": "MultiCallEntrypoint::sync_private_state_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "MultiCallEntrypoint::sync_notes_abi"
+          "path": "MultiCallEntrypoint::sync_private_state_abi"
         }
       ]
     }
@@ -1880,13 +1880,13 @@
     },
     "289": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{arrays::array_concat, field::{field_from_bytes, field_from_bytes_32_trunc}},\n};\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\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        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\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 silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, private_log.inner.log.length)\n    }\n}\n\npub fn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\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 merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\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 = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> 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[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 poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\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 compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{arrays::array_concat, field::{field_from_bytes, field_from_bytes_32_trunc}},\n};\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\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        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        compute_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\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 silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, private_log.inner.log.length)\n    }\n}\n\npub fn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\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 merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\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 = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> 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[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 poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\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 compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
     "306": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "365": {
+    "367": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },