@aztec/protocol-contracts 0.70.0 → 0.71.0

package/artifacts/MultiCallEntrypoint.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.1+561b7ed4beb7b55c",
+  "noir_version": "1.0.0-beta.1+2d73c1d7bc5b1db7",
   "name": "MultiCallEntrypoint",
   "functions": [
     {
@@ -93,6 +93,138 @@
         "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VTvQ6CMBBu+YmCMqiJbia+QREMjCbuvkMDMuqAixuPLjXX9FKbMLQ18Uuaa+Hy/ZSDEgUKNSIWkCQHqAnUAL0Px3WGM7NDnmi6LvlrVhaJIZ9D/x9+6sm/gOT3dP9sBjyXQfHjLFJ3Pq4UzYSvzPKb+cy8mci5+kHOEcdM08aghmehoYci3zvYZ4Y+iQVR/3Q0uM9V1YxJvRD4Y/LtHevHWv8WzqnmX9TIwmdX8bwreMdPvG3Lhq81foEA3dM/z8Ie9lOzgDMuiZqN/nVvro/nrScTECRvfuFT84YGAAA=",
+      "debug_symbols": "ndLRCoMgFAbgdznXXXhcZetVYoSVhSAaZoMRvfssYmujG705+Ivf8eZfoBPNPNRS92aCslpAmZY7abRPy5pAY6VScqjP10C2gbi/n0autzg5bh2UNKMJCN35U06876USUOZ0fSSANFjcgkUaLLJQQS//QEIKdhgkiOlHYZruLItjeRxjcayIYje8ZsjyL7tnv2z18cmt5I0SR936Wben9rnXKP6KOFrTim62YqvkqY1+VsgSSv1av/oN",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "process_log",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "log_plaintext",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "unique_note_hashes_in_tx",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "recipient",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/92caVPbMBCGHbABB0LC0fukNy1tHZKQpCctve8L+jlTyJ9oP7j9E7T/tnlBSzZCnaGDNOWtZzxOvMruo7Usr6VVCtH2ttbbC+ZzbI6j5ojz09HgJmWXzTHb31b1qCsLxVggYBwiYBwmYIwJGBMCxhECxlECxjECxpSAsUjAOE7AOEHAWCJgnCRgLBMwVggYpwIwhuCcJuGc8cipY/tQvLPRwW+jhwgYDxMwHiFgPErAeIyA8TgB4wkCxpMEjKcIGE8TMJ4hYDxLwDhHwHiOgPE8AeMFAsaLBIyXCBgvEzBeIWCcJ2C8SsB4jYBxgYDxOgHjDQLGmwSMGQFjlYBxkYCxRsBYJ2BsEDAuETA2CRhbBIxtAsZbBIy3CRjvEDDeJWC8R8B4n4BxmYDxAQHjQwLGFQLGRwSMjwkYnxAwPiVgfEbA+JyA8QUB40sCxlcEjK8JGN8QML4lYHxHwPiegPEDAePHAIwhOD+RcK6ScK4F4ow+W9BDvR0Lt7AwCguPsLAHC2ewMAULP7CwAgsXsDAAifdIbEfieKW3I/EZScVI2EUSLJJMkcSJJEkkISLJD0l0SFJDEhiSrJDEhCShs719rrcjiQRJGkiCQJIBJvExSY5JaEzyYhIVk5SYBMQkGyaxMEmEWmGSA5MIGKTHIDgGmTGIi0FSDEJikA+DaBikwiAQBlkwiCGDBHjJxUskXtLwEoSXDATxCJIRhCLIQxCFIAVBAB6yeIjhIYFOGJ0cOhHcpLgB0LjWoj9v0kh+mGNqjkNK7nERXTW17PrU38randRRP4/8tdToHAuiv9EU/WkY/kwW2q7kff26LmJ32BxX874vV/NBJimzqcpsWmWkPmGud70W1l/VxZLlo0jVRWwXw9iuFSx7+rpomdgvRiHb5vaiZG1PeGz/SN9RkjJ5n6dgyeJ8dz1EliiZXF/YmVfl7LY1ZsmEBZu035LyjWxrRibXNFY6/bXX0Pd3Pft37bVe/R/ba2zJ4nx3Pf62veq2ZbfXJOpv0peKbETJflqyUSX7lfdt1825sP3w9nNX32++n1szDn5tC9to3veBtLthdS5RPtvyjy5vyVIli/NBO0XzPVZ2tC7hSKzyNfO9bI4j6jfy+4rD/ohlf4Dbcc72S+oonzrKo30tmM+Ir9F+vkn5aPe9in3ZfM/2tS21Xf2iP/3Nmqvv88i/IfrHg+iv7+ifCMNfF/2lMP7f0T8Zhr8r+sth9C+J/koY/Q3RPxVE/+JOXKD/XMeOC2bUeY9x7J7jArFftFhDxQUzFo/tHx0XQDbrYK04ZHYfMOuwM+uw49I16VHXlEddxQNax5JHXRWPulKPunxexwmPunz6q+xR15hHXT7bvU9/yXUMOz6VZa44LQqgvxhG/07fL320fhfTdRL7iVX+q+XniSB+7o87SX+mfeGKpXza3uvzWuyXHDzCXXTI9vOHZxuNVrfdarR7IX11abGdFSz9wmqf0+9Eun/R5V3Pflfc59HXmWvMoaz8ii1WsklLliiZMOoxB1dc7JN/L/7X9isOmd0/7/VaTkeDbU3fj+NR/36Oc/91b7a2/8hli9HoT6LBMcXIsp9Y5b+b73Zft997pNvsVLu1TrfT6Kyv1790pi392ofw02+mXHNgmVMAAA==",
+      "debug_symbols": "tZZLCoMwFEX3knEGvlc/rVspRaJGCYQoUQtF3HsT6Ufa8Z2E3PByMjrhrqLV9dJXxnXDJMrrKuzQqNkMLqR1k6L2xlrTV8djkcSFkmS/MI3KxTzNys+i5Iyl0K4NuzwJgM5YLcqcN/k3Wrwni+IzmPF2k4FNQDYD2ScgOwWyMyA7B7ILIPsMZF9wbAJ6SUAvCeglAb0koJcE9JKAXhLQSwJ6SUAvGeglA71klJdbSHfljaqtftWNbnHNoX3Mj1H/FJHRD41uF69jJfm2keh3SjKj/XcNgTiVxJfwSHjoCQ==",
+      "brillig_names": [
+        "process_log"
+      ]
+    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -1786,7 +1918,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "enqueue_public_function_call_internal",
         "call_private_function_internal",
@@ -1794,26 +1926,6 @@
         "directive_integer_quotient"
       ],
       "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAADBZ4LHiGvGl2kzG8PsO9iHOw32U/AvmqV2oAO0SNiQJAwe6fT4xABSFFb1z3xXKU0VVYBcmx8aCj7S0+daEoiUDR2LVXRFiBHGM+Acl1mUCdp1cdiQgnnmXB9s1yKiMSQRJPC93s/dgvsbRAdXUYOq5JWjZebwWPCiZgcNuCIpdEbZHkdRNXlwpURPTEeuMRf77K0DPZicUUVgixfkpENcl8c6WX2pyBI+r/UHHl7HAM15mjwRd4GVlC6UHrzFfrhjwS7NSyd0pPrYaD8y0SQNctZhRbG31VFX5auPnA2ztKjd4AtSfNnZtKzU6+cCq505UlhxYwQ6a4ikBdNV9e24bTb4M7Npt6Q+G/Gsq+aINum69adB+m9K/cARo8kaD/xgKaDxybCqfdyEwvCLzjlaPMokre05vkKKiz7Qdg4FHKBwnyRJMv39GTJbjSR2B1n8T2qFGBkPeT3PwWkqtsI0g+YbM9YGG0s+QlblB0y+xiP8SyMX4gMPf+VNeAZq7BwRWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQpjDMR/JFw+S3pQLBCqrmQ1TxqOyYznNprc9+SCDFBWQewX0CKYShHJZAWuSBK5L83U36xlrBcHZj6UQFqm6y7KwlJCrbtfKXQPm0onuTYS3RZLyTnnULWSeCUGYPKT6kTU+9Upm2YoNGzEkvXTtcn5b36nW97pnk+DtWIdWEo/ybXlxfxZ0qmQa/Rcd9v8/SPPfhx2HItORFpU05xDk6hD6gjYxZFzoxFXzkV13eN0qkfG2fysr9K0La+PlU85qQAph3qx2s3DKT0L3OmZct1qevcWM1L34r35/z/o21bcS5ZeJ8Nnbs/Fa3lOEt4SQ2x2DN5xzvkESPev8iMn8jWBElwIBsmIJniY2N8nT4h2DLuV4oVXDk1kPzTh2l+f2oFjgg6tU4a019gZeWqXOvTsqHawWqeOwA2y6emXpx0ByDPGNk25zhQFRCMJKNPfK8ECK37YSdz//UAzAju8siFDcImXDfGfUO+v9zVkDxu6FuDe5Qdv4H2tglKqZ3lx8sh3yzSwkNaOHn3Bpir+b0WX/3EGYulSQXv08p/RxbX3gSdCuVQBg4emAi83Su62yym7zvA0JgXpWLXe1e9GZWVDR14PIWpVv2msvPKARfAwveMf/HjrrIt46BEeJOCwRMuhuP2C6Hg6VOU4JLCEDHf+c9PmgQ/tsazsfB4d5GH9i1vQnA4o5RoeA68A1kjG/Vl8kH5x1gIwMCSXg1ktZXIE4vlxPIy83QjkaPN8e/fygKX8ne8XqIz3RR2SqkWsvoAIu/eYK/Um7U70J8+ImMPEqHnWjdEUa7Bx4LGQzjwcS+uNVDhfkuZVzuIg5mK+4O/8RMf02Uyf0+SQ8JsmGQQCpmvDYH7yTRwPejsG5BlwwTrB3knlbgfl4ovfW8IbUkv5dds7AmEk8hF10XSsds3ZeJxByGrvIWLoR41StPA6gv8ekHNepyPUyuMknJJMCt7TqLy6bOS13NyNVj53PZlLjhs5fvb/DGmmUfA79+6XF2GMhsHPjm9iHbWgAwhzEkAKuwJ6i9wb4pudjcGRbEy2RjuXrxuLpedKhEJwV7WtRTfxaATQUGmLRQVUlcZVZlLBwlvJtkXMHTJhTuS6CJ3D3UnDnWmihjFl0GCwcZKEvPCxY/Fjxfh/akzJ3O0n1ILfL8p+O+C/OFeg/nYNEorr5cp8IouQG6wVoP/OeZf1C2PbQJzmQtypwG38+hZPkye5aPMKgML4SfRC57PRUwRHLKnipAhUX5efaI9IazkxtfN/vv0wgw+EVg6MrvQ/rkK3InEjXW1cWNvW760qAb29FliAjAbauTrDrvq3SAzQAZvKBNXSPEZYxw/4H+p1wADTj4nRU75krS/hLl7qnRxLiV4NVHfUMAE7HzR9N2LO2SmbyrEl5tl5WVoxaMbFO0Y92zwzuzLR5jedBrom2ToJY+ER3wbYlZaVZunuziDLgRwag4jrDKjVmkH+4cjYhWDsXb1meGS1xGTVANEGej5KQRrKZKTywnFkzcutrPm0bmZInk0L86aiDhJaT/NoiotONbUuh5HY6dOzbEcofNGloDCcOVRUVNEWS9ZGI+nZRLbOeiSgmsyYQ7gglHgBfzpF8DV3KAZR3xS9gdTMrYSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgy/G0VOSQIKjfMnAmRIglo4FbF6ZU6TEh4ZipYmAUJTJaR0TU0N+II22uc31aBIWG/c06/TFYjyokIYhHNHLB8Py7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VTvQ6CMBBu+YmCMqiJbia+QREMjCbuvkMDMuqAixuPLjXX9FKbMLQ18Uuaa+Hy/ZSDEgUKNSIWkCQHqAnUAL0Px3WGM7NDnmi6LvlrVhaJIZ9D/x9+6sm/gOT3dP9sBjyXQfHjLFJ3Pq4UzYSvzPKb+cy8mci5+kHOEcdM08aghmehoYci3zvYZ4Y+iQVR/3Q0uM9V1YxJvRD4Y/LtHevHWv8WzqnmX9TIwmdX8bwreMdPvG3Lhq81foEA3dM/z8Ie9lOzgDMuiZqN/nVvro/nrScTECRvfuFT84YGAAA=",
-      "debug_symbols": "ndLBCoMwDAbgd8nZQ9Npdb6KDKlapVBaqXUwxHdf3UTc8NJeQlL6JZd/gU4081BL3ZsJymoBZVrupNF+WtYEGiuVkkN9fgayFcTP/2nkehsnx62DkmY0AaE73zHifS+VgJLR9ZEA0mBxCxZpsMhCBb28gYTgfTe+T9mhMP2yLI6xOJbHsSKK3fCaISkOhjT/Zasfn9xK3iixx62fdXtKn3uN4i+IozWt6GYrtkie0uhrhXlCqV/rV78B",
-      "brillig_names": [
-        "sync_notes"
-      ]
     }
   ],
   "outputs": {
@@ -1917,31 +2029,31 @@
     }
   },
   "file_map": {
-    "129": {
+    "130": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "130": {
+    "131": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
-      "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
+      "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "142": {
+    "144": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "238": {
+    "242": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\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\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
+      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "255": {
+    "259": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::new((in_len as Field) * two_pow_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "26": {
-      "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
+    "276": {
+      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
+      "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "319": {
+    "324": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
@@ -1963,7 +2075,7 @@
     },
     "79": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            /// Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            /// for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        /// Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        /// execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        /// the number of side effects that took place), along with the hash of the return values. We validate these\n        /// by requesting a private kernel iteration in which the return values are constrained to hash\n        /// to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "92": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/hash.nr",