@aztec/protocol-contracts 0.76.1 → 0.76.3

package/artifacts/MultiCallEntrypoint.json

@@ -4,23 +4,93 @@
   "name": "MultiCallEntrypoint",
   "functions": [
     {
-      "name": "sync_notes",
+      "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
       "custom_attributes": [],
       "abi": {
         "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         },
-        "parameters": [],
-        "return_type": null
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "packed_note_content",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
       },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "bY/dCoMwDIXfJde9aLop01eRIVWjFEortQ6G+O5Lxybdz004J3w55GwwULdOrXGjX6BuNrC+19F4x27bBXTBWGumNl+DTANPT36ZtUt2iTpEqFWhBJAbWJWS70djCepS7eIHRYnyDbNW1YHj+fKfr/DgFcoP/rqzvelgdGfp9fy4uj7rEu8zfdWag+9pWAOlglk3ng0WQkmO5egH",
+      "bytecode": "H4sIAAAAAAAA/9VZy67aQAwdSEJIuAEKn3Cl7tomXJ47Fn3c30AFPqHrrLppP7qMGCcH46siYVfFEpoknhyfOXZmJqHjztY//TrhOA5tz10b9dmGtrzPKkWs0pJn50F4dh+EZ/QgPGNFnh2Bp2/peUvc+ZlL3fl5bC7iTT7BEdzk/gYAwX6HNgttF/yKCakyYZBa+Otyvs/cpSnzf8kCZmqDvyD8vg1+Sbw/1y0+joXiRqF9rVstX+Eeb0U4xuIlXPJ1wfeF+SLwfWU+rOFvzId1T5xIN1qYlOtqY50XGlsKY+u80TrXaofXSOvcmdZoRTnPGB/On/gU1Kdu+fSYLwZfxnwJ+Eh/3z5DP577FPp9hONP0IfXZ+Su65n8lH/U3aK+YgP8k82lHPD8xPVlbPRhDmLQ85npY7FuoD4W+nt9pm/wp2Nvae0ai5ieqBFp1sf+zJeBL64v4+ThPIY4iEU8Etb/QzgfhbYH99D9YyF+j8W/4C1cQ404ViRco/7++Xwfjgfh52voJ93jructvc31ci7N4Xr4qwY/s+F/JPzcBn9J+AMb/GZv82SCPysJv7Dh38xBQ5v6afaWIxv+B8Ifm+DPD7QOv3OtNXNEOJ7Adb35u6pu2SNh/JxxtdojTRgfrg+uwd43FbiOBR/P4VSIMxXiSFiZItaTItboPx1jXxFroIg1VMTSzGOqiKWpV66IVShiada9pl6UR2mf5m0b2vJOk/ZpiviVtE/TfJcnram+YkFDHF/C+v9gOg9MeFYzWnPoWacYGLswin3rek3xC4EP8c4F3z0fZw+L9XGzXmxOW7JqOds0+SwYV34N34twPsb+0tov7fsUtS6ld/8h6OotBl/BfAn4iKP07j804n+L/hh/LPj4+n9rLifuej0csHHjN6+typjb74HSt3rj+Wtx67NJ8XN3PV//q++NqA/fS+cC17Hg4/uTXIiTC3EeEYt/s0cNfV2TTnHd+rVyuVq3f3TRXJS4y/8BHIufsP6/wjmOjdp75vzjalcdX3bH3WK338+/7yYM31sXdPoDg5oBSR0fAAA=",
+      "debug_symbols": "tdfRaoMwFMbxd8l1LnISkzS+yhglaiyBECXqYIjvvli6rayX47spjRx/3vgHz86G0G23a8zjtLD2bWdp6v0ap1xP+8FZV2JK8XZ9vszE+eP0fX6ZfT6Py+rLylqpJWchD/WfEfX+MabAWiMP/jJqvyet/RnU8njnzBkcbXH0BUc7GE1CAG0C2hJoK6DdAG0NtA3QtkD7ArSBXRKwSwJ2ScAuCdglAbskYJcE7JKAXdJ/u3TqMVlfixfcAXEpkDghcYnEFRJvkLhG4gaJWySOLFQiC1XIQhWs0KOePnyJvkvhsX+NW+6f1rH1cw5/NrO5TH0YthLOHe13PTtjVJo3+v6dUg+kGk7K1YfUB30B",
       "brillig_names": [
-        "sync_notes"
+        "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
@@ -1716,7 +1786,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "enqueue_public_function_call_internal",
         "call_private_function_internal",
@@ -1725,96 +1795,6 @@
       ],
       "verification_key": "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"
     },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "packed_note_content",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/9VZy67aQAwdSEJIuAEKn3Cl7tomXJ47Fn3c30AFPqHrrLppP7qMGCcH46siYVfFEpoknhyfOXZmJqHjztY//TrhOA5tz10b9dmGtrzPKkWs0pJn50F4dh+EZ/QgPGNFnh2Bp2/peUvc+ZlL3fl5bC7iTT7BEdzk/gYAwX6HNgttF/yKCakyYZBa+Otyvs/cpSnzf8kCZmqDvyD8vg1+Sbw/1y0+joXiRqF9rVstX+Eeb0U4xuIlXPJ1wfeF+SLwfWU+rOFvzId1T5xIN1qYlOtqY50XGlsKY+u80TrXaofXSOvcmdZoRTnPGB/On/gU1Kdu+fSYLwZfxnwJ+Eh/3z5DP577FPp9hONP0IfXZ+Su65n8lH/U3aK+YgP8k82lHPD8xPVlbPRhDmLQ85npY7FuoD4W+nt9pm/wp2Nvae0ai5ieqBFp1sf+zJeBL64v4+ThPIY4iEU8Etb/QzgfhbYH99D9YyF+j8W/4C1cQ404ViRco/7++Xwfjgfh52voJ93jructvc31ci7N4Xr4qwY/s+F/JPzcBn9J+AMb/GZv82SCPysJv7Dh38xBQ5v6afaWIxv+B8Ifm+DPD7QOv3OtNXNEOJ7Adb35u6pu2SNh/JxxtdojTRgfrg+uwd43FbiOBR/P4VSIMxXiSFiZItaTItboPx1jXxFroIg1VMTSzGOqiKWpV66IVShiada9pl6UR2mf5m0b2vJOk/ZpiviVtE/TfJcnram+YkFDHF/C+v9gOg9MeFYzWnPoWacYGLswin3rek3xC4EP8c4F3z0fZw+L9XGzXmxOW7JqOds0+SwYV34N34twPsb+0tov7fsUtS6ld/8h6OotBl/BfAn4iKP07j804n+L/hh/LPj4+n9rLifuej0csHHjN6+typjb74HSt3rj+Wtx67NJ8XN3PV//q++NqA/fS+cC17Hg4/uTXIiTC3EeEYt/s0cNfV2TTnHd+rVyuVq3f3TRXJS4y/8BHIufsP6/wjmOjdp75vzjalcdX3bH3WK338+/7yYM31sXdPoDg5oBSR0fAAA=",
-      "debug_symbols": "tdfRaoMwFMbxd8l1LnISkzS+yhglaiyBECXqYIjvvli6rayX47spjRx/3vgHz86G0G23a8zjtLD2bWdp6v0ap1xP+8FZV2JK8XZ9vszE+eP0fX6ZfT6Py+rLylqpJWchD/WfEfX+MabAWiMP/jJqvyet/RnU8njnzBkcbXH0BUc7GE1CAG0C2hJoK6DdAG0NtA3QtkD7ArSBXRKwSwJ2ScAuCdglAbskYJcE7JKAXdJ/u3TqMVlfixfcAXEpkDghcYnEFRJvkLhG4gaJWySOLFQiC1XIQhWs0KOePnyJvkvhsX+NW+6f1rH1cw5/NrO5TH0YthLOHe13PTtjVJo3+v6dUg+kGk7K1YfUB30B",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
-    },
     {
       "name": "process_log",
       "is_unconstrained": true,
@@ -1926,6 +1906,26 @@
       "brillig_names": [
         "process_log"
       ]
+    },
+    {
+      "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/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "bY/RCoMwDEX/Jc99aLop6K/IkKpRCqWVWgdD/PelY5Nu8yXcG04uuRsM1K1Ta9zoF6ibDazvdTTesdt2AV0w1pqpzdcg08DLi19m7ZJdog4RalUoAeQGVqXk+9FYgrpUu/hDUaL8wKxVdeB4rc75Cg9eofzibzvbuw5Gd5bez4+r67Mu8THTT605+J6GNVAqmHXj2WAhlORYjn4C",
+      "brillig_names": [
+        "sync_notes"
+      ]
     }
   ],
   "outputs": {
@@ -2030,31 +2030,31 @@
   },
   "file_map": {
     "134": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "135": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
+    "136": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "148": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+    "149": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note_content,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        packed_note_content,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note_content: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::unpack_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "251": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+    "250": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "268": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+    "267": {
+      "path": "/mnt/user-data/grego/repos/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        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\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        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    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, 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 = 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 { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_contract_class_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_contract_class_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) -> 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 = 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 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"
     },
-    "285": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
+    "284": {
+      "path": "/mnt/user-data/grego/repos/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"
     },
-    "334": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
+    "333": {
+      "path": "/mnt/user-data/grego/repos/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"
     },
     "52": {
@@ -2062,23 +2062,23 @@
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
     "62": {
-      "path": "/build-volume/noir-projects/noir-contracts/contracts/multi_call_entrypoint_contract/src/main.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-contracts/contracts/multi_call_entrypoint_contract/src/main.nr",
       "source": "// An entrypoint contract that allows everything to go through. Only used for testing\n// Pair this with SignerlessWallet to perform multiple actions before any account contracts are deployed (and without authentication)\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract MultiCallEntrypoint {\n    use dep::authwit::entrypoint::app::AppPayload;\n    use dep::aztec::macros::functions::private;\n\n    #[private]\n    fn entrypoint(app_payload: AppPayload) {\n        app_payload.execute_calls(&mut context);\n    }\n}\n"
     },
     "67": {
-      "path": "/build-volume/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
       "source": "use dep::aztec::{\n    prelude::PrivateContext,\n    protocol_types::{\n        constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n        hash::poseidon2_hash_with_separator,\n        traits::{Hash, Serialize},\n    },\n};\nuse std::meta::derive;\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\n#[derive(Serialize)]\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_args_hash(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_args_hash(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
     },
     "7": {
       "path": "std/collections/bounded_vec.nr",
       "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\n            let mut exceeded_len = false;\n            for i in 0..Len {\n                exceeded_len |= i == append_len;\n                if !exceeded_len {\n                    self.storage[self.len + i] = vec.get_unchecked(i);\n                }\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        static_assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\n            let mut ret = false;\n            let mut exceeded_len = false;\n            for i in 0..MaxLen {\n                exceeded_len |= i == self.len;\n                if !exceeded_len {\n                    ret |= predicate(self.storage[i]);\n                }\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(self.get_unchecked(i));\n                }\n            }\n        }\n\n        ret\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n\n        if is_unconstrained() {\n            for i in len..MaxLen {\n                array[i] = zeroed;\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i >= len {\n                    array[i] = zeroed;\n                }\n            }\n        }\n\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n        use crate::convert::From;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are zeroed out, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n\n        #[test]\n        fn from_parts_unchecked() {\n            // docs:start:from-parts-unchecked\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // invalid use!\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n            // both vecs have length 3 so we'd expect them to be equal, but this\n            // fails because elements past the length are still checked in eq\n            assert(vec1 != vec2);\n            // docs:end:from-parts-unchecked\n        }\n    }\n}\n"
     },
-    "79": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
+    "80": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            /// Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            /// for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        /// Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        /// execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        /// the number of side effects that took place), along with the hash of the return values. We validate these\n        /// by requesting a private kernel iteration in which the return values are constrained to hash\n        /// to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "95": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/hash.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }
   }