@aztec/protocol-contracts 0.69.0-devnet → 0.69.1

package/artifacts/Router.json

@@ -1685,7 +1685,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZXdasMwDIXfxde5kGTLP32VMUrapiUQkpKmg1H67rNDnKSdKSxlg0FvQmR/sg5HinMRu2JzPqzLet+cxOrtIqpmm3dlU/voIpD7tdMxr0N46vK2EyvUDjJR1Dv/agCumdiXVSFWmq7ZN5istANMVk+w5QQsGd0AS3b0GEateNShlVYjTgwp3lgZcQvT4aRTMJCOMBiew++ZQP3yJemLefmS9MU+7YsC5gFW4HCEjewLuF8uQJAqYIiGFAvq8fEIIHl0CGad1almsY3KNU5uIlEvBp8XY0ZnAGcVkmLQoTIRdzibHG9OYoRJWhVnmBTKey/pf8uXfy3f6BF3Tt2Opg82bVlV5WF98+uC8FBJp9EXjech2fvpUnJJklqSxEuS9I+TfISBTX/E/uIcMg27WSL7RB9+5G2Zb6oiuBp2z/U2muzD7vMYd2Ibjm2zLXbntggNmXoRXJWQKQjXVRCibMZy1NYvkczI+qq+8hc=",
+      "debug_symbols": "7ZXbioMwEIbfJddeZA459VWWpdjWFkG0WLuwlL77JmLUdkNhLbuw0Btxkm8yP/+M8SJ2xeZ8WJf1vjmJ1dtFVM0278qm9tFFgOrXTse8DuGpy9tOrEA7mYmi3vlXI+U1E/uyKsRK4zX7BqMlO8Bo9QRblYBJgRtgUg4fw6AZ49H+nScclUzxxlLErZzROgVL1BGWRs3h90yAfvmS9MW8fEn6Yp/2haVSA8zSwQgb6gu4Xy6AMlXAIA4pVvLj4wGJRzuRtJ3wVLOUjco1TG4CYi8GnhdjxlFARnosBhywibjzszM3JzHCSJbjDCMD3XuJ/1s+/bV8o8cxdo5vR9MHm7asqvKwvvl1yfDgpNMAEuJ5gPZ+upiWJPGSJLUkSf84yUcQ2PRH7C/OIdMoN0tUPtGHH3lb5puqCK6G3XO9jSb7sPs8xp3YhmPbbIvduS1CQ6ZeBFdJZizDdRWEsM0Ujdr6JaQMra/qK38B",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal"
@@ -3314,105 +3314,13 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZXbasMwDIbfxde5kGT51FcZo6RtWgIhKWk6GKXvPrvETtqZjXUHGPQmRPYn6/dvxTmJTbU67pZ1u+0OYvF0Ek23Loe6a310EsiXscO+bEN4GMp+EAvUDgpRtRv/agDOhdjWTSUWms7FO5istCNMVk+wVRlYKnQjLJWjj2HUrJIOzZoTTgpyvLEy4hamxUnnYCAdYTBqDj8XAtXDl6wv+uFL1hfzbV8YlBphBocJNvJSwP52AZctIE3MQdafFEAAmWiAOZ47LmWjdo2Tn0gU5BD8hByT3AGc1cjKQYdsIu5w1j3eoEwbk7Qc+5gY5Y2fhP99A/T3GzA64c7xdYv6YNXXTVPvlle/MAgPzov1ReN6SPa2x1jek8T3JKl7kvSXk3yEgc1/Pf4CHTONcrNE5RN9+FL2dblqquBqmD2262iyD4fXfZyJx7Dvu3W1OfZVOJDpLIKrEgqGcKsEIWwLJZO2yxDJgqyv6iu/AQ==",
+      "debug_symbols": "7ZVbasMwEEX3om99aB56ZSulFCdxgsHYwXEKJWTvlYJlO6lIafqAQn6MRzpXM7oay0exLpeH7UvVbNq9WDwdRd2uir5qmxAdBfB5bL8rmhju+6LrxQKMV1KUzTq8WqVOUmyquhQLgyf5AUZHboDRmQl2OgOTBj/ApD3ehsEwpqXDO084apXjraOEOzWjTQ5WaBKsrJ7Dz1KAfviS9cU8fMn6Yr/tCyutB5iVhxG2dE7gfjuBzyYgmzTA5pMEgMSjoUjGTXjuuLRLtRuY/ATEWA6qnyjHju2AjHS7HPDANuE+9M/coEwbIzlOfYwMdOUnwn/fAP79BqwZ29l7vmzRECy7qq6r7cvFL0zFB+eLBQVpPUB33WNM94j4HpG+R2S+LAoRRDb/9YQLdFBa7WdCHYQhfC26qljWZXQ1zh6aVTI5hP3bLs2kY9h17apcH7oyHsh0FtFVUpJVvFViIeykprG28xCSRBeyhszv",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal"
       ],
       "verification_key": "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"
     },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLBCoQgFAXQf3nrFqlZ2a/EEFYWgmiYDQzRv49FMzRDG908vOJ5bu4KvWiXsZF6MDNU9QrKdNxJo31atwRaK5WSY3O9hnQfCB3v54nrPc6OWwcVoSQBoXt/ypH3g1QCqhxvjwQQDhYkWGTBgoYKfPsHyxA7Ccuy/GsQKQ5EY1Aeg4oYVEYgclsBRtPygyguftHm45NbyVslzooNi+4ujXOvSfyVb7KmE/1ixV7DSwP9rFGRYOzX+tVv",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "10421965853029650238": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called statically"
-          },
-          "11405868724477732285": {
-            "error_kind": "string",
-            "string": "Function _check_timestamp can only be called internally"
-          },
-          "13418685691864489983": {
-            "error_kind": "string",
-            "string": "Function _check_timestamp can only be called statically"
-          },
-          "1433889167918961673": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 17
-          },
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2242946026394210301": {
-            "error_kind": "string",
-            "string": "Block number mismatch."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "8209322232883590150": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called internally"
-          },
-          "8443716675528357851": {
-            "error_kind": "string",
-            "string": "Timestamp mismatch."
-          }
-        },
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
     {
       "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
@@ -3503,6 +3411,78 @@
         "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
+    {
+      "name": "public_dispatch",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "error_types": {
+          "10421965853029650238": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called statically"
+          },
+          "11405868724477732285": {
+            "error_kind": "string",
+            "string": "Function _check_timestamp can only be called internally"
+          },
+          "13418685691864489983": {
+            "error_kind": "string",
+            "string": "Function _check_timestamp can only be called statically"
+          },
+          "1433889167918961673": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 17
+          },
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "2242946026394210301": {
+            "error_kind": "string",
+            "string": "Block number mismatch."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "8209322232883590150": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called internally"
+          },
+          "8443716675528357851": {
+            "error_kind": "string",
+            "string": "Timestamp mismatch."
+          }
+        },
+        "parameters": [
+          {
+            "name": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "public_dispatch"
+      ]
+    },
     {
       "name": "_check_timestamp",
       "is_unconstrained": true,
@@ -3562,6 +3542,26 @@
       "brillig_names": [
         "_check_timestamp"
       ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgFAXQf3nrFqlZ2a/EEFYWgmiYDQzRv49FMzRDG908vOJ5bu4KvWiXsZF6MDNU9QrKdNxJo31atwRaK5WSY3O9hnQfCB3v54nrPc6OWwcVoSQBoXt/ypH3g1QCqhxvjwQQDhYkWGTBgoYKfPsHyxA7Ccuy/GsQKQ5EY1Aeg4oYVEYgclsBRtPygyguftHm45NbyVslzooNi+4ujXOvSfyVb7KmE/1ixV7DSwP9rFGRYOzX+tVv",
+      "brillig_names": [
+        "sync_notes"
+      ]
     }
   ],
   "outputs": {
@@ -3718,7 +3718,7 @@
     },
     "250": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, 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    tx_hash: 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(tx_hash, 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 { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\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: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\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.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\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    std::hash::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 std::hash::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) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::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 = std::hash::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 two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::poseidon2::Poseidon2::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 contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_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 = std::hash::sha256(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        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, 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    tx_hash: 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(tx_hash, 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 { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\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    std::hash::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 std::hash::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) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::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 = std::hash::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 two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::poseidon2::Poseidon2::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 contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_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 = std::hash::sha256(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"
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
@@ -3742,7 +3742,7 @@
     },
     "65": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
     "73": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",

package/dest/protocol_contract_data.js

@@ -26,13 +26,13 @@ export const ProtocolContractAddress = {
 };
 export const ProtocolContractLeaf = {
     AuthRegistry: Fr.fromHexString('0x23413f98beb033d7bfa8a9b5addc441f26759faf00dff5c848da5f3518bf7eb0'),
-    ContractInstanceDeployer: Fr.fromHexString('0x032447de7cc74649ca4fc97e444029c6410065fa7878f0198389dbc0cc51eb47'),
+    ContractInstanceDeployer: Fr.fromHexString('0x244a782d3b9bcee8160689f03dce5be8eaf91a12c30575d4e4ed63e81d225ea5'),
     ContractClassRegisterer: Fr.fromHexString('0x0a39c154e69a1d9ad1ae1f179b77988a64c46825eb88a8fd48818c6d149a5f0d'),
     MultiCallEntrypoint: Fr.fromHexString('0x1c1001e61223368d2d563234664e585ef5f77dab4a35fa00b3ea804cb7651e2b'),
     FeeJuice: Fr.fromHexString('0x2fba6f22985e0de4e48958c798da7ff66180b7cbfcca5954bfea5a23868c74bc'),
     Router: Fr.fromHexString('0x0a22e9a628194414e41773fca0bc6c0d814da59da3efa83a82473ca6f27cd744'),
 };
-export const protocolContractTreeRoot = Fr.fromHexString('0x0636068d571321cc16741580211e001e997616fbef68520d4a8595c578cfceab');
+export const protocolContractTreeRoot = Fr.fromHexString('0x15c4ba754a1c246494577702f41a1f2f87b62dd22356c3e52e041870e8b1ebfc');
 export const REGISTERER_CONTRACT_CLASS_REGISTERED_TAG = new Fr(11121068431693264234253912047066709627593769337094408533543930778360n);
 export const REGISTERER_PRIVATE_FUNCTION_BROADCASTED_TAG = new Fr(2889881020989534926461066592611988634597302675057895885580456197069n);
 export const REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_TAG = new Fr(24399338136397901754495080759185489776044879232766421623673792970137n);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aztec/protocol-contracts",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
   "description": "Canonical Noir contracts for the Aztec Network",
-  "version": "0.69.0-devnet",
+  "version": "0.69.1",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -69,9 +69,9 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuits.js": "0.69.0-devnet",
-    "@aztec/foundation": "0.69.0-devnet",
-    "@aztec/types": "0.69.0-devnet",
+    "@aztec/circuits.js": "0.69.1",
+    "@aztec/foundation": "0.69.1",
+    "@aztec/types": "0.69.1",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"

package/src/protocol_contract_data.ts

@@ -32,7 +32,7 @@ export const ProtocolContractAddress: Record<ProtocolContractName, AztecAddress>
 
 export const ProtocolContractLeaf = {
   AuthRegistry: Fr.fromHexString('0x23413f98beb033d7bfa8a9b5addc441f26759faf00dff5c848da5f3518bf7eb0'),
-  ContractInstanceDeployer: Fr.fromHexString('0x032447de7cc74649ca4fc97e444029c6410065fa7878f0198389dbc0cc51eb47'),
+  ContractInstanceDeployer: Fr.fromHexString('0x244a782d3b9bcee8160689f03dce5be8eaf91a12c30575d4e4ed63e81d225ea5'),
   ContractClassRegisterer: Fr.fromHexString('0x0a39c154e69a1d9ad1ae1f179b77988a64c46825eb88a8fd48818c6d149a5f0d'),
   MultiCallEntrypoint: Fr.fromHexString('0x1c1001e61223368d2d563234664e585ef5f77dab4a35fa00b3ea804cb7651e2b'),
   FeeJuice: Fr.fromHexString('0x2fba6f22985e0de4e48958c798da7ff66180b7cbfcca5954bfea5a23868c74bc'),
@@ -40,7 +40,7 @@ export const ProtocolContractLeaf = {
 };
 
 export const protocolContractTreeRoot = Fr.fromHexString(
-  '0x0636068d571321cc16741580211e001e997616fbef68520d4a8595c578cfceab',
+  '0x15c4ba754a1c246494577702f41a1f2f87b62dd22356c3e52e041870e8b1ebfc',
 );
 
 export const REGISTERER_CONTRACT_CLASS_REGISTERED_TAG = new Fr(