@aztec/protocol-contracts 0.76.0 → 0.76.2

package/artifacts/ContractInstanceDeployer.json

@@ -3,6 +3,96 @@
   "noir_version": "1.0.0-beta.1+3f8376928465907d",
   "name": "ContractInstanceDeployer",
   "functions": [
+    {
+      "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": "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": "tdfNaoQwFIbhe8k6i5z8mIm3UsoQNQ6BECVqoYj33jhM26GzLN9GiBwfN77g2dkQuu12jXmcFta+7SxNvV/jlOtpPzjrSkwp3q7Pt5k4L87c55fZ5/O4rL6srFWSs5AH1mpRnx5jCqxt5MFfBu33oLU/g0Ye75y5BgVbFHxBwQ4EkxAwmWCyhMkKJmuYbGByA5MtTL7AZFiDBGuQYA0SrEGCNUiwBgnWIMEaJFiD9L8GnXoM1k/hhXYwWgocTTha4miFozWONji6wdEWR+NqlLgaFa5GBarxqKcPX6LvUnhsTeOW+6clav2cw599ai5TH4athHOz+l2qzvSU4drc/zzqgZTmpFx9SX3RFw==",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
+    },
     {
       "name": "deploy",
       "is_unconstrained": false,
@@ -1808,7 +1898,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "call_private_function_internal",
@@ -1821,96 +1911,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": "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": "tdfNaoQwFIbhe8k6i5z8mIm3UsoQNQ6BECVqoYj33jhM26GzLN9GiBwfN77g2dkQuu12jXmcFta+7SxNvV/jlOtpPzjrSkwp3q7Pt5k4L87c55fZ5/O4rL6srFWSs5AH1mpRnx5jCqxt5MFfBu33oLU/g0Ye75y5BgVbFHxBwQ4EkxAwmWCyhMkKJmuYbGByA5MtTL7AZFiDBGuQYA0SrEGCNUiwBgnWIMEaJFiD9L8GnXoM1k/hhXYwWgocTTha4miFozWONji6wdEWR+NqlLgaFa5GBarxqKcPX6LvUnhsTeOW+6clav2cw599ai5TH4athHOz+l2qzvSU4drc/zzqgZTmpFx9SX3RFw==",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
-    },
     {
       "name": "process_log",
       "is_unconstrained": true,
@@ -2038,7 +2038,7 @@
         "return_type": null
       },
       "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "bY/dCoMwDIXfJde9aOo2sK8iQ6pGKZRWah0M8d2Xjk26n5tDTvhyyNlgoG6dWuvHsIBuNnChN8kGz27bBXTROmentlyDzILVk19m47NdkokJdKUEkB9AnyRfj9YR6IvaxQ+IEuWb5VnVB45V/Z+v8eAVyg/+urO9mWhN5+j1+rj6vmiS7jN9lZpj6GlYI+V6RTPWBs9CSY7l6Ac=",
+      "debug_symbols": "bY/RCoMwDEX/Jc99aOo2Zn9FhlSNUiit1DoY4r8vjk26zZdLbji55C7QUTMPtfV9mEBXC7jQmmSDZ7esApponbNDna9BboLFi59G4zc7JRMT6EIJIN+BPkm+7q0j0Be1ij8QJcoPy7MqdxyL6zFf4s4rlF/8bWV7N9GaxtH79X72bdYkPUb6KTXG0FI3R9rqZc1YKzwLJTmWo58=",
       "brillig_names": [
         "sync_notes"
       ]
@@ -2485,15 +2485,15 @@
     }
   },
   "file_map": {
-    "125": {
+    "124": {
       "path": "/build-volume/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"
     },
-    "128": {
+    "127": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n    let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "139": {
+    "138": {
       "path": "/build-volume/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"
     },
@@ -2509,23 +2509,23 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    fn _to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    fn _to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = self._to_le_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = self._to_be_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // `_radix` must be less than 256\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        /// Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "242": {
+    "241": {
       "path": "/build-volume/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"
     },
-    "245": {
+    "244": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "247": {
+    "246": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "258": {
+    "257": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; 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 { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "259": {
+    "258": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{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"
     },
@@ -2533,21 +2533,21 @@
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { 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 = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    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    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 two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::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\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "276": {
+    "275": {
       "path": "/build-volume/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"
     },
-    "285": {
+    "284": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
-    "325": {
+    "324": {
       "path": "/build-volume/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"
     },
-    "342": {
+    "340": {
       "path": "/build-volume/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr",
-      "source": "mod events;\nmod capsule;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract ContractClassRegisterer {\n    use dep::aztec::protocol_types::{\n        abis::log_hash::LogHash,\n        constants::{\n            ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, FUNCTION_TREE_HEIGHT,\n            MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,\n            MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS,\n            MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n        },\n        contract_class_id::ContractClassId,\n    };\n\n    use dep::aztec::{\n        context::PrivateContext, macros::functions::private,\n        oracle::logs::emit_contract_class_unencrypted_log_private,\n    };\n\n    use crate::events::{\n        class_registered::ContractClassRegistered,\n        private_function_broadcasted::{\n            ClassPrivateFunctionBroadcasted, InnerPrivateFunction, PrivateFunction,\n        },\n        unconstrained_function_broadcasted::{\n            ClassUnconstrainedFunctionBroadcasted, InnerUnconstrainedFunction,\n            UnconstrainedFunction,\n        },\n    };\n\n    // docs:start:import_pop_capsule\n    use crate::capsule::pop_capsule;\n\n    // docs:end:import_pop_capsule\n\n    #[private]\n    fn register(\n        artifact_hash: Field,\n        private_functions_root: Field,\n        public_bytecode_commitment: Field,\n        emit: bool,\n    ) {\n        // TODO: Validate public_bytecode_commitment is the correct commitment of packed_public_bytecode\n        // TODO: We should be able to remove public_bytecode_commitment from the input if it's calculated in this function\n        // docs:start:pop_capsule\n        let packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] =\n            unsafe { pop_capsule() };\n        // docs:end:pop_capsule\n        // First field element contains the length of the bytecode\n        let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n        let bytecode_length_in_fields: u32 =\n            (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n        assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n        // The first value in the running hash is the bytecode length in bytes\n        let mut computed_public_bytecode_commitment = packed_public_bytecode[0];\n        // We can hash up to MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1, since the first element is the length\n        for i in 0..(MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1) {\n            // While we are forced to run the hash MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS times in the circuit,\n            // we want the bytecode commitment to be based on the actual length\n            if (i < bytecode_length_in_fields) {\n                // We skip the first element when hashing since it is the length\n                computed_public_bytecode_commitment = std::hash::poseidon2::Poseidon2::hash(\n                    [packed_public_bytecode[i + 1], computed_public_bytecode_commitment],\n                    2,\n                );\n            } else {\n                // Any bytes after the bytecode length must be 0\n                assert_eq(packed_public_bytecode[i + 1], 0);\n            }\n        }\n        assert_eq(computed_public_bytecode_commitment, public_bytecode_commitment);\n\n        // Compute contract class id from preimage\n        let contract_class_id = ContractClassId::compute(\n            artifact_hash,\n            private_functions_root,\n            public_bytecode_commitment,\n        );\n\n        // Emit the contract class id as a nullifier to be able to prove that this class has been (not) registered\n        context.push_nullifier(contract_class_id.to_field());\n\n        // Broadcast class info including public bytecode\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ContractClassRegistered: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_hash,\n                private_functions_root,\n                public_bytecode_commitment,\n            ],\n        );\n\n        // TODO(#10007): Drop this conditional and always emit the bytecode. We allow skipping the broadcast\n        // as a stopgap solution to allow txs to fit in Sepolia when we broadcast public bytecode.\n        if emit {\n            let event = ContractClassRegistered {\n                contract_class_id,\n                version: 1,\n                artifact_hash,\n                private_functions_root,\n                packed_public_bytecode,\n            };\n            emit_contract_class_log(&mut context, event.serialize_non_standard());\n        }\n    }\n\n    #[private]\n    fn broadcast_private_function(\n        contract_class_id: ContractClassId,\n        artifact_metadata_hash: Field,\n        unconstrained_functions_artifact_tree_root: Field,\n        private_function_tree_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n        private_function_tree_leaf_index: Field,\n        artifact_function_tree_sibling_path: [Field; ARTIFACT_FUNCTION_TREE_MAX_HEIGHT],\n        artifact_function_tree_leaf_index: Field,\n        function_data: InnerPrivateFunction,\n    ) {\n        let private_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS] =\n            unsafe { pop_capsule() };\n\n        let event = ClassPrivateFunctionBroadcasted {\n            contract_class_id,\n            artifact_metadata_hash,\n            unconstrained_functions_artifact_tree_root,\n            private_function_tree_sibling_path,\n            private_function_tree_leaf_index,\n            artifact_function_tree_sibling_path,\n            artifact_function_tree_leaf_index,\n            function: PrivateFunction {\n                selector: function_data.selector,\n                metadata_hash: function_data.metadata_hash,\n                vk_hash: function_data.vk_hash,\n                bytecode: private_bytecode,\n            },\n        };\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ClassPrivateFunctionBroadcasted: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_metadata_hash,\n                unconstrained_functions_artifact_tree_root,\n                function_data.selector.to_field(),\n                function_data.vk_hash,\n                function_data.metadata_hash,\n            ],\n        );\n        emit_contract_class_log(&mut context, event.serialize_non_standard());\n    }\n\n    #[private]\n    fn broadcast_unconstrained_function(\n        contract_class_id: ContractClassId,\n        artifact_metadata_hash: Field,\n        private_functions_artifact_tree_root: Field,\n        artifact_function_tree_sibling_path: [Field; ARTIFACT_FUNCTION_TREE_MAX_HEIGHT],\n        artifact_function_tree_leaf_index: Field,\n        function_data: InnerUnconstrainedFunction,\n    ) {\n        let unconstrained_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS] =\n            unsafe { pop_capsule() };\n        let event = ClassUnconstrainedFunctionBroadcasted {\n            contract_class_id,\n            artifact_metadata_hash,\n            private_functions_artifact_tree_root,\n            artifact_function_tree_sibling_path,\n            artifact_function_tree_leaf_index,\n            function: UnconstrainedFunction {\n                selector: function_data.selector,\n                metadata_hash: function_data.metadata_hash,\n                bytecode: unconstrained_bytecode,\n            },\n        };\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ClassUnconstrainedFunctionBroadcasted: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_metadata_hash,\n                private_functions_artifact_tree_root,\n                function_data.selector.to_field(),\n                function_data.metadata_hash,\n            ],\n        );\n        emit_contract_class_log(&mut context, event.serialize_non_standard());\n    }\n\n    #[contract_library_method]\n    fn emit_contract_class_log<let N: u32>(context: &mut PrivateContext, log: [Field; N]) {\n        let contract_address = context.this_address();\n        let counter = context.next_counter();\n\n        // The log preimage is too large for the hash to compile (16,200 fields, 518,400 bytes), so we do this via a\n        // specialized oracle.\n        // A malicious oracle cannot force us to use an incorrect bytecode:\n        // - Contract class -> we will commit to the packed bytecode (currently a TODO)\n        // - Private function -> we provide a membership proof\n        // - Unconstrained function -> we provide a membership proof\n        // However, the sequencer will be required to know a contract's preimage if it is called and the sequencer\n        // cannot prove non-registration. Therefore, it is possible that a malicious oracle might prevent sequencers\n        // from including transactions with calls to certain badly-broadcasted contracts.\n        // TODO(#8978): review correctness\n        let log_hash =\n            unsafe { emit_contract_class_unencrypted_log_private(contract_address, log, counter) };\n\n        // 40 = addr (32) + raw log len (4) + processed log len (4)\n        context.contract_class_logs_hashes.push(\n            LogHash { value: log_hash, counter, length: 40 + (N as Field) * 32 },\n        );\n    }\n\n    #[private]\n    fn assert_class_id_is_registered(contract_class_id: ContractClassId) {\n        context.push_nullifier_read_request(contract_class_id.to_field());\n    }\n}\n"
+      "source": "mod events;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract ContractClassRegisterer {\n    use dep::aztec::protocol_types::{\n        abis::log_hash::LogHash,\n        constants::{\n            ARTIFACT_FUNCTION_TREE_MAX_HEIGHT, FUNCTION_TREE_HEIGHT,\n            MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,\n            MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS,\n            MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT,\n        },\n        contract_class_id::ContractClassId,\n    };\n\n    use dep::aztec::{\n        context::PrivateContext, macros::functions::private,\n        oracle::logs::emit_contract_class_unencrypted_log_private,\n    };\n\n    use crate::events::{\n        class_registered::ContractClassRegistered,\n        private_function_broadcasted::{\n            ClassPrivateFunctionBroadcasted, InnerPrivateFunction, PrivateFunction,\n        },\n        unconstrained_function_broadcasted::{\n            ClassUnconstrainedFunctionBroadcasted, InnerUnconstrainedFunction,\n            UnconstrainedFunction,\n        },\n    };\n\n    // docs:start:import_pop_capsule\n    use dep::aztec::oracle::pxe_db;\n    // docs:end:import_pop_capsule\n\n    #[private]\n    fn register(\n        artifact_hash: Field,\n        private_functions_root: Field,\n        public_bytecode_commitment: Field,\n        emit: bool,\n    ) {\n        // TODO: Validate public_bytecode_commitment is the correct commitment of packed_public_bytecode\n        // TODO: We should be able to remove public_bytecode_commitment from the input if it's calculated in this function\n        // docs:start:pop_capsule\n        let packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] = unsafe {\n            pxe_db::load(\n                context.this_address(),\n                REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT,\n            )\n                .unwrap()\n        };\n        // docs:end:pop_capsule\n        // First field element contains the length of the bytecode\n        let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n        let bytecode_length_in_fields: u32 =\n            (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n        assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n        // The first value in the running hash is the bytecode length in bytes\n        let mut computed_public_bytecode_commitment = packed_public_bytecode[0];\n        // We can hash up to MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1, since the first element is the length\n        for i in 0..(MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS - 1) {\n            // While we are forced to run the hash MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS times in the circuit,\n            // we want the bytecode commitment to be based on the actual length\n            if (i < bytecode_length_in_fields) {\n                // We skip the first element when hashing since it is the length\n                computed_public_bytecode_commitment = std::hash::poseidon2::Poseidon2::hash(\n                    [packed_public_bytecode[i + 1], computed_public_bytecode_commitment],\n                    2,\n                );\n            } else {\n                // Any bytes after the bytecode length must be 0\n                assert_eq(packed_public_bytecode[i + 1], 0);\n            }\n        }\n        assert_eq(computed_public_bytecode_commitment, public_bytecode_commitment);\n\n        // Compute contract class id from preimage\n        let contract_class_id = ContractClassId::compute(\n            artifact_hash,\n            private_functions_root,\n            public_bytecode_commitment,\n        );\n\n        // Emit the contract class id as a nullifier to be able to prove that this class has been (not) registered\n        context.push_nullifier(contract_class_id.to_field());\n\n        // Broadcast class info including public bytecode\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ContractClassRegistered: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_hash,\n                private_functions_root,\n                public_bytecode_commitment,\n            ],\n        );\n\n        // TODO(#10007): Drop this conditional and always emit the bytecode. We allow skipping the broadcast\n        // as a stopgap solution to allow txs to fit in Sepolia when we broadcast public bytecode.\n        if emit {\n            let event = ContractClassRegistered {\n                contract_class_id,\n                version: 1,\n                artifact_hash,\n                private_functions_root,\n                packed_public_bytecode,\n            };\n            emit_contract_class_log(&mut context, event.serialize_non_standard());\n        }\n    }\n\n    #[private]\n    fn broadcast_private_function(\n        contract_class_id: ContractClassId,\n        artifact_metadata_hash: Field,\n        unconstrained_functions_artifact_tree_root: Field,\n        private_function_tree_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n        private_function_tree_leaf_index: Field,\n        artifact_function_tree_sibling_path: [Field; ARTIFACT_FUNCTION_TREE_MAX_HEIGHT],\n        artifact_function_tree_leaf_index: Field,\n        function_data: InnerPrivateFunction,\n    ) {\n        let private_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS] = unsafe {\n            pxe_db::load(\n                context.this_address(),\n                REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT,\n            )\n                .unwrap()\n        };\n\n        let event = ClassPrivateFunctionBroadcasted {\n            contract_class_id,\n            artifact_metadata_hash,\n            unconstrained_functions_artifact_tree_root,\n            private_function_tree_sibling_path,\n            private_function_tree_leaf_index,\n            artifact_function_tree_sibling_path,\n            artifact_function_tree_leaf_index,\n            function: PrivateFunction {\n                selector: function_data.selector,\n                metadata_hash: function_data.metadata_hash,\n                vk_hash: function_data.vk_hash,\n                bytecode: private_bytecode,\n            },\n        };\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ClassPrivateFunctionBroadcasted: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_metadata_hash,\n                unconstrained_functions_artifact_tree_root,\n                function_data.selector.to_field(),\n                function_data.vk_hash,\n                function_data.metadata_hash,\n            ],\n        );\n        emit_contract_class_log(&mut context, event.serialize_non_standard());\n    }\n\n    #[private]\n    fn broadcast_unconstrained_function(\n        contract_class_id: ContractClassId,\n        artifact_metadata_hash: Field,\n        private_functions_artifact_tree_root: Field,\n        artifact_function_tree_sibling_path: [Field; ARTIFACT_FUNCTION_TREE_MAX_HEIGHT],\n        artifact_function_tree_leaf_index: Field,\n        function_data: InnerUnconstrainedFunction,\n    ) {\n        let unconstrained_bytecode: [Field; MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS] = unsafe {\n            pxe_db::load(\n                context.this_address(),\n                REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT,\n            )\n                .unwrap()\n        };\n        let event = ClassUnconstrainedFunctionBroadcasted {\n            contract_class_id,\n            artifact_metadata_hash,\n            private_functions_artifact_tree_root,\n            artifact_function_tree_sibling_path,\n            artifact_function_tree_leaf_index,\n            function: UnconstrainedFunction {\n                selector: function_data.selector,\n                metadata_hash: function_data.metadata_hash,\n                bytecode: unconstrained_bytecode,\n            },\n        };\n        dep::aztec::oracle::debug_log::debug_log_format(\n            \"ClassUnconstrainedFunctionBroadcasted: {}\",\n            [\n                contract_class_id.to_field(),\n                artifact_metadata_hash,\n                private_functions_artifact_tree_root,\n                function_data.selector.to_field(),\n                function_data.metadata_hash,\n            ],\n        );\n        emit_contract_class_log(&mut context, event.serialize_non_standard());\n    }\n\n    #[contract_library_method]\n    fn emit_contract_class_log<let N: u32>(context: &mut PrivateContext, log: [Field; N]) {\n        let contract_address = context.this_address();\n        let counter = context.next_counter();\n\n        // The log preimage is too large for the hash to compile (16,200 fields, 518,400 bytes), so we do this via a\n        // specialized oracle.\n        // A malicious oracle cannot force us to use an incorrect bytecode:\n        // - Contract class -> we will commit to the packed bytecode (currently a TODO)\n        // - Private function -> we provide a membership proof\n        // - Unconstrained function -> we provide a membership proof\n        // However, the sequencer will be required to know a contract's preimage if it is called and the sequencer\n        // cannot prove non-registration. Therefore, it is possible that a malicious oracle might prevent sequencers\n        // from including transactions with calls to certain badly-broadcasted contracts.\n        // TODO(#8978): review correctness\n        let log_hash =\n            unsafe { emit_contract_class_unencrypted_log_private(contract_address, log, counter) };\n\n        // 40 = addr (32) + raw log len (4) + processed log len (4)\n        context.contract_class_logs_hashes.push(\n            LogHash { value: log_hash, counter, length: 40 + (N as Field) * 32 },\n        );\n    }\n\n    #[private]\n    fn assert_class_id_is_registered(contract_class_id: ContractClassId) {\n        context.push_nullifier_read_request(contract_class_id.to_field());\n    }\n}\n"
     },
     "52": {
       "path": "std/panic.nr",
@@ -2569,7 +2569,7 @@
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",
       "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    pub fn assert_empty(self) {\n        assert_eq(self.hash, 0);\n    }\n\n    pub fn raw(self) -> Field {\n        self.hash\n    }\n\n    /// This is only used during private execution, since in public it is the VM itself that keeps track of return\n    /// values.\n    pub fn get_preimage<T, let N: u32>(self) -> T\n    where\n        T: Deserialize<N>,\n    {\n        /// Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it.\n        let preimage: [Field; N] = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage));\n\n        Deserialize::deserialize(preimage)\n    }\n}\n"
     },
-    "86": {
+    "85": {
       "path": "/build-volume/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"
     }