@aztec/protocol-contracts 0.86.0 → 0.87.0

package/artifacts/MultiCallEntrypoint.json

@@ -1,30 +1,8 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.4+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.5+0000000000000000000000000000000000000000",
   "name": "MultiCallEntrypoint",
   "functions": [
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "aztec::macros::functions::utility"
-      ],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZLdCoMgGIbvxWMP/P/ZrYwxrGwIYmE1GNG9z8JYrNFOOhE/fXh50HcElS2Gx92FuunA5ToC35Smd01I0zhBUETnvXvct8cAzQumC9+1Jsxj15vYgwtGDFMIbKiWvSQpo3beLtMEd7xUItNqvs+sxD9QTnhGOUefWCamGwSYnWGjqFxtuD62YVRnlAm1s+Gn2Ci22mh1bCPQ+jaCiJ2NOMNGE5JpTfkfG4UyKtHXT01pfJroTOFtrlg9hHLTuP7V2q/ytbEpbTVEO9dw08C0XrGChKbYFP0G",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -1186,6 +1164,14 @@
                                   "kind": "field"
                                 }
                               }
+                            },
+                            {
+                              "name": "length",
+                              "type": {
+                                "kind": "integer",
+                                "sign": "unsigned",
+                                "width": 32
+                              }
                             }
                           ]
                         }
@@ -1217,12 +1203,29 @@
                   "length": 1,
                   "type": {
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash",
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted",
                     "fields": [
                       {
-                        "name": "value",
+                        "name": "inner",
                         "type": {
-                          "kind": "field"
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash",
+                          "fields": [
+                            {
+                              "name": "value",
+                              "type": {
+                                "kind": "field"
+                              }
+                            },
+                            {
+                              "name": "length",
+                              "type": {
+                                "kind": "integer",
+                                "sign": "unsigned",
+                                "width": 32
+                              }
+                            }
+                          ]
                         }
                       },
                       {
@@ -1232,14 +1235,6 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
                       }
                     ]
                   }
@@ -1685,15 +1680,37 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "notify_enqueued_public_function_call_wrapper",
         "call_private_function_internal",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "nZPRioQgFIbf5Vx3oaWmvsowDFY2CGLh1MISvfvqoDu14DLMjSfzfF9/pRsMulvvN+PG6QHyskHnjbXmfrNTrxYzuXB3AxQH3IBsKsAEJA2FgmxDYSDFvleQ+2+L1zq2HwRBOyuv3QLSrdZW8KXs+mx6zMo966J8WEUVaDeEGoSjsTpe7dWLRmUUI0pYwjFiiP4qMCInCS5LWp4VPEBZ0OITX5d5WtPEU/p6B0zYuwF40+YAVJQCkDJPGpF4wvhHATjJAQQvBWBlPnz4xLOafRJA1HUSiIaWAvB/AvC8iVr05xdcw1T1xp/29h5V3qjO6jQdV9cfVpfvOa/kszH7qdfD6nU0HQ5IGC+YV3Vz3ePTfgA=",
+      "brillig_names": [
+        "sync_notes"
+      ]
     },
     {
       "name": "public_dispatch",
@@ -1719,8 +1736,8 @@
           }
         }
       },
-      "bytecode": "JwAABAEqAAABBRhSVSgKJhpbPAABAA==",
-      "debug_symbols": "XYxLCoAwDAXvkrUn8Coi0k9aAqEpsRWk9O5+cCFdzhveNPBoa9woBdlhXhqwOFNI0k2tT2CVmCluw3wYJWMZPww1uZ8tZ8bhn1Uc+qr4lF7X134B",
+      "bytecode": "JwAABAEqAAABBRhSVSgKJhpbPAAAAQ==",
+      "debug_symbols": "XY1bCoAgEEX3Mt+toK1EiI9RBkRl0iDEvWeRIH3ee+6jgkFVnKBg4wHrVkExeU9O+Khlphi6W9sCQ4rMiN2CiW97D0hN/C+dkkkqj5+0JeiJ5isNMk4TR42mMD5LL2t7uwE=",
       "brillig_names": [
         "public_dispatch"
       ]
@@ -1822,6 +1839,20 @@
           ],
           "kind": "struct",
           "path": "MultiCallEntrypoint::entrypoint_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [],
+                "kind": "struct",
+                "path": "MultiCallEntrypoint::sync_notes_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "MultiCallEntrypoint::sync_notes_abi"
         }
       ]
     }
@@ -1829,7 +1860,7 @@
   "file_map": {
     "104": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n\n    fn_abi\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
     "143": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
@@ -1843,19 +1874,19 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "270": {
+    "271": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n        MAX_PROTOCOL_CONTRACTS,\n    },\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::{pow, sqrt},\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 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 secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_protocol_contract(self) -> bool {\n        self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\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"
     },
-    "288": {
+    "289": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\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\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE,\n        GENERATOR_INDEX__OUTER_NULLIFIER, GENERATOR_INDEX__SILOED_NOTE_HASH,\n        GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{arrays::array_concat, field::{field_from_bytes, field_from_bytes_32_trunc}},\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, private_log.inner.log.length)\n    }\n}\n\npub fn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "305": {
+    "306": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "363": {
+    "365": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
@@ -1873,7 +1904,7 @@
     },
     "68": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        length: u32,\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log =\n            PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "71": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",