@aztec/protocol-contracts 4.0.0-devnet.1-patch.0 → 4.0.0-devnet.2-patch.0

package/artifacts/ContractInstanceRegistry.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.18+f1db9754dd26736a9bdbfd41c5ce15fe5d62ba6b",
+  "noir_version": "1.0.0-beta.18+2db78f8894936db05c53430f364360ac9cc5c61f",
   "name": "ContractInstanceRegistry",
   "functions": [
     {
@@ -36,7 +36,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBFJwAABEUlAAAAQScCAQQAJwICBAAfCgABAAIARCUAAABCLQIBRCcCAgREJwIDBAE7DgADAAImJQAAAnUeAgACCScCAwEBJAIAAgAAAF4lAAACmx4CAAIBKQIAAwDvUlNNJwIEAAErAgAFAAAAAAAAAAADAAAAAAAAAAAtCAEGJwIHBAUACAEHAScDBgQBACIGAgctCgcILQ4DCAAiCAIILQ4ECAAiCAIILQ4CCAAiCAIILQ4FCC0LBgIAIgICAi0OAgYtCAECJwIDBAUACAEDAScDAgQBACIGAgMAIgICBD8PAAMABCcCAwQBACoCAwUtCwUEJwICAAAKKgQCAycCAgEACioDAgUkAgAFAAABICUAAAKtHgIAAgYeAgADAC8qAAQAAwAFHAoFBAQcCgQDAAIqBQMELAIAAwAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBAMFHAoFBgQcCgYEAAIqBQQGBCoGAwUcCgUHARwKBwYAHAoGBwECKgUGCCwCAAUAMDPqJG5QbomOl/Vwyv/XBMsLtGAxP7cgsp4TnlwQAAEEKggFCRwKCQoEHAoKCAACKgkICgQqCgMJHAoJCgEcCgoDABwKAwoBAioJAwsEKgsFCRwKCQsEHAoLBQAcCgUJBRYKCgUcCgMKBRwKBQMFBCoKCQUcCggJBRYKBwgcCgYHBRwKCAYFBCoHCQgcCgQJBQwqAgkEKQIAAgUAAVGAJAIABAAAAlwjAAACRAQqBwgDBCoGAgQAKgMEAi0KAgEjAAACdAQqCgUEBCoDAgUAKgQFAi0KAgEjAAACdCYoAAAEBHhFDAAABAMkAAADAAACmioBAAEF2sX11rRKMm08BAIBJioBAAEFT99KitfP8NM8BAIBJioBAAEFursh14IzGGQ8BAIBJg==",
-      "debug_symbols": "nZjdbtswDIXfxde5kEjqh3mVoSjS1h0CBGmRJQOGIu8+MjElp4CETTf18XH8mZJIWvXX9Da/XH4+74/vH7+m7Y+v6eW0Pxz2P58PH6+78/7jKO7X5PRP8tMWN1OK05Y2U/b3A98OTNM2ykHOvPzGu7wIj4tAMmGXyC6ROcGcYE4EE3ERGsVdhEVkZ8IekS0MNiCnuwAHJhQYRHhnIiwCzAFz0Bw0hzSMqCIuIpgT9DdZRHQmzEnmJHMympAhA4jQmEEdFgfdZkINFeUSem9CHRkFgjoy/6gzdhNRbsegIi8iqRNVqJNE6EMxq8iLYHNuD+XNRE4ckqcTORMSM3kRwZlQR+IhHSmhCnUkDNKR3oU5ukwUVKgj8RCrk1SEuwhOnaxiuSs4XhxPJswBdVgF34MPiIujOXYTZI7mWJBRBM2xANfrZrIMfz6f5lkTfJXyUgifu9N8PE/b4+Vw2Ey/d4fL7Ue/PnfH2/G8O8lVQc7HNzkK8H1/mFVdN/Vu175VasP55XbRgAUR/APDtxkcIS4IjpQqgR8I0InCZSpBuEpIMDqO0BpHl0GhMihSixHaDNSFvhFwdf//jIO0AC2G4FoxpA4DNMXvCOA6E5keCLlNgGwpJbVY7icfHwDcG4b3JQaRUCBS7o955bppEdAojp1rUzrpiQHKYGpqSWd7JHTSE3zOCwI8xzFGXRSQhttmUJtBiY1BGeucev7nMJC5Lu1qbb+H0Usvz5bjUnSxlV6+h3C+IByuEDhYJ7ndtzpZCswlNZynVhjQiSPLu2VBZGLf7H2d/IxlOpNvtr7eMNCV/ouOcnMY2EEkLDORQmoiqLemEGJZVEjt90DoQZzmzQJxSE1I7ExoLdcoe60mopOgkErBc7ON9wbCnKCOY7Uo34PorWsg634YOmF01zWX1MjArXVF3ysSKI2LMa9asPsPRixdR1Z4kBG4FmsYYqArL3jpXH6QUSpe9sI4yqDCgDTG8CEVRoyDjJoe4EfjyGU+5H+UMQbUsUAcjANyWVv0o3HUjQ8CjTGw7FkQIwwycmnH5IcZZT4IBuulboiRRuslIdVXy+Cc5tJNMfNgzXGy/kHOcZPxz2/a1dp+a6eh18bkrWbt1NE61YXxJKe71/3p4cPHVWGn/e7lMC+n75fj6+rq+c+nXbEPJ5+nj9f57XKalVS/nuhnhh+yk97IlulJP4zoqfzn78E9XfXxfwE="
+      "debug_symbols": "nZjbbuJADIbfJddcjA9zMK+yqira0hUSohULK60q3n1tiCdQaUa7c1N+/pAv9tjjpPma3rYv55/Pu8P7x69p/eNrejnu9vvdz+f9x+vmtPs4qPs1BfuTYVrTasppWvNqKnD7kOuH8LRO+qHfQH8DocwCaBbELvwQ+yF2J7oT3UnoIs3CoriJOIsSXPgliochDpR8ExjQhQGjCggu4izQHXSH3CF32MJIJtIsojvRflNUpODCnexOdqeQC00ZUYXFjOaIOhRWE1mopIcIwIU5mgWhObr+ZCt2FUlPp2iizCKbk0yYk1XYRamYKLMQd64XldXEQR3WqzMHFxozg4oYXJij8bBlymTCHA2DLdObcMfKxNGEORoPiznZRLyJGMwpJuazYpDZAXbhDpojJuQWfCSaHeuxq2B3rMeiZhGtxyJeLqvJO/z5dNxurcHvWl43wufmuD2cpvXhvN+vpt+b/fn6o1+fm8P187Q56lFFbg9v+qnA991+a+qyWs4O7VNB28pPV41YEREeGNBmSMI0IyRxXgjyQMBOFKGwBwFhIWQczYNbeXQZHBcGJ2oxYptBVugrgRIP5cEISwwsrRhyP4+KkFgJhR8IpU3A4uuge7Gez5AeANJpCagFFUSoCCr5sas6S1HERtGVUSRJm9FpTYpYE1naSqfaI6HTmgilzAgESWOMpSCow7bN4DaDsziDCy3bFOSfwyCRpax3df0eRq+1QLy/QW8JrdaCHiJARQS6Q9DgHintmdXpUBSprRGAW2Fgr0H1vuINygLNudfpz1SXM0Nz7PXSoFBnLwUuzTSog8hUVyLH3ERwr6YYUy0q5vY9IPYgwfpmhgTiJiR1FnTZrkmfs5qIToNirhtemiO8l4hIxiWPu6J8D6JX12iPMreixE4Y3bqW2hoFpVVXgt4mwTq4hJZEKMt/MFKdOlrhQUaUZbPGIQaFCJWRYJBRd7w+B9MogysD8xgDYq6MlAYZS3sgjMZR6nroA9gYA5dcMA3GgaXWlmA0juWh5/758b8YFOuupYSDjFLHMcMwo64H4+B+4WW/8Oh+ycTLrWVwTUudplRkcM9J9vnBIUiT8c932rvafhunsTfG9K7m4zTc/aOkFb9cnvTr5nV3fHjpcTHYcbd52W/nr+/nw+vd0dOfTz/iL00+jx+v27fzcWuk5c2JvWL4AUFWAPxkL0Xsq/7XDxieLnb5vw=="
     },
     {
       "name": "public_dispatch",
@@ -108,7 +108,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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"
+      "debug_symbols": "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"
     },
     {
       "name": "publish_for_public_execution",
@@ -1240,7 +1240,7 @@
                 }
               },
               {
-                "name": "include_by_timestamp",
+                "name": "expiration_timestamp",
                 "type": {
                   "kind": "integer",
                   "sign": "unsigned",
@@ -1416,7 +1416,7 @@
                 }
               },
               {
-                "name": "key_validation_requests_and_generators",
+                "name": "key_validation_requests_and_separators",
                 "type": {
                   "kind": "struct",
                   "path": "aztec::protocol_types::utils::arrays::claimed_length_array::ClaimedLengthArray",
@@ -1428,7 +1428,7 @@
                         "length": 16,
                         "type": {
                           "kind": "struct",
-                          "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator",
+                          "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_separator::KeyValidationRequestAndSeparator",
                           "fields": [
                             {
                               "name": "request",
@@ -1473,7 +1473,7 @@
                               }
                             },
                             {
-                              "name": "sk_app_generator",
+                              "name": "key_type_domain_separator",
                               "type": {
                                 "kind": "field"
                               }
@@ -1955,7 +1955,7 @@
                                           "name": "fields",
                                           "type": {
                                             "kind": "array",
-                                            "length": 18,
+                                            "length": 16,
                                             "type": {
                                               "kind": "field"
                                             }
@@ -2094,9 +2094,9 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "verification_key": "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"
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "verification_key": "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"
     },
     {
       "name": "set_update_delay",
@@ -2153,7 +2153,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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"
+      "debug_symbols": "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"
     },
     {
       "name": "update",
@@ -2217,7 +2217,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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"
+      "debug_symbols": "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"
     }
   ],
   "outputs": {
@@ -2823,7 +2823,7 @@
     },
     "230": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/version.nr",
-      "source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 11;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n}\n\n#[oracle(utilityAssertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(version: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n    }\n\n    #[test(should_fail_with = \"Incompatible oracle version. TXE is using version\")]\n    unconstrained fn incompatible_oracle_version() {\n        let arbitrary_incorrect_version = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_version);\n    }\n}\n"
+      "source": "/// The ORACLE_VERSION constant is used to check that the oracle interface is in sync between PXE and Aztec.nr. We need\n/// to version the oracle interface to ensure that developers get a reasonable error message if they use incompatible\n/// versions of Aztec.nr and PXE. The TypeScript counterpart is in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called\n/// and if the oracle version is incompatible an error is thrown.\npub global ORACLE_VERSION: Field = 12;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n}\n\n#[oracle(utilityAssertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(version: Field) {}\n\nmod test {\n    use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION};\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION);\n    }\n\n    #[test(should_fail_with = \"Incompatible oracle version. TXE is using version\")]\n    unconstrained fn incompatible_oracle_version() {\n        let arbitrary_incorrect_version = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_version);\n    }\n}\n"
     },
     "298": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.2.3/src/poseidon2.nr",
@@ -2845,25 +2845,25 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::DOM_SEP__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            DOM_SEP__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "378": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
-      "source": "// TODO: Expose other wrapped functions than debug (info, warn)\n// ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace']\n\npub global SILENT_LOG_LEVEL: u8 = 0;\npub global FATAL_LOG_LEVEL: u8 = 1;\npub global ERROR_LOG_LEVEL: u8 = 2;\npub global WARN_LOG_LEVEL: u8 = 3;\npub global INFO_LOG_LEVEL: u8 = 4;\npub global VERBOSE_LOG_LEVEL: u8 = 5;\npub global DEBUG_LOG_LEVEL: u8 = 6;\npub global TRACE_LOG_LEVEL: u8 = 7;\n\n/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Same as debug_log, but allows to customize the log level.\n/// Consider changing just to 'log'\npub fn debug_log_with_level<let N: u32>(log_level: u8, msg: str<N>) {\n    debug_log_format_with_level(log_level, msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_array_oracle_wrapper(DEBUG_LOG_LEVEL, msg, args) };\n}\n\n/// Same as debug_log_format, but allows to customize the log level.\n/// Consider changing just to 'log_format'\npub fn debug_log_format_with_level<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_array_oracle_wrapper(log_level, msg, args) };\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` slice.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole slice: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format_slice<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_slice_oracle_wrapper(log_level, msg, args) };\n}\n\n// We provide two versions of the debug log oracle: one that takes args as a slice and another one that takes args as an array.\n// We do this since conversion from array to slice generates overhead in public functions, since opcodes need to be emitted for the conversion.\n// By exposing the two flavors, we avoid conversions since the AVM is able to handle both arrays an slices in this oracle.\n\nunconstrained fn debug_log_slice_oracle_wrapper<let M: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field],\n) {\n    debug_log_slice_oracle(log_level, msg, args);\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_slice_oracle<let M: u32>(log_level: u8, msg: str<M>, args: [Field]) {}\n\nunconstrained fn debug_log_array_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_array_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityDebugLog)]\nunconstrained fn debug_log_array_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
-    },
-    "380": {
+    "379": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
       "source": "use crate::{\n    delayed_public_mutable::{\n        scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n    },\n    hash::poseidon2_hash,\n    traits::{Hash, Packable},\n    utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n    pub svc: ScheduledValueChange<T>,\n    pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n    pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n        DelayedPublicMutableValues { svc, sdc }\n    }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n    T: Packable<N = M>,\n{\n    let svc_pre_packed = arrays::subarray(packed, 1);\n    let svc_post_packed = arrays::subarray(packed, M + 1);\n\n    // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n    // occupies the first 32 bits of the field.\n    let timestamp_of_change = (packed[0] as u32) as u64;\n    ScheduledValueChange::new(\n        T::unpack(svc_pre_packed),\n        T::unpack(svc_post_packed),\n        timestamp_of_change,\n    )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n    packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n    // This function expects to be called with just the first field of the packed representation, which contains sdc\n    // and svc timestamp_of_change. We'll discard the svc component.\n    let svc_timestamp_of_change = packed as u32;\n\n    let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_timestamp_of_change = tmp as u32;\n\n    tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_post_is_some = (tmp as u1) != 0;\n\n    tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n    let sdc_post_inner = tmp as u32;\n\n    tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n    let sdc_pre_is_some = (tmp as u1) != 0;\n\n    tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n    let sdc_pre_inner = tmp as u32;\n\n    // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n    // the values as u32 is a tech debt that is not worth tackling.\n    ScheduledDelayChange {\n        pre: if sdc_pre_is_some {\n            Option::some(sdc_pre_inner as u64)\n        } else {\n            Option::none()\n        },\n        post: if sdc_post_is_some {\n            Option::some(sdc_post_inner as u64)\n        } else {\n            Option::none()\n        },\n        timestamp_of_change: sdc_timestamp_of_change as u64,\n    }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    let N: u32 = 2 * <T as Packable>::N + 1;\n\n    fn pack(self) -> [Field; Self::N] {\n        let mut result = [0; Self::N];\n\n        // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n        // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n        result[0] = self.svc.timestamp_of_change as Field\n            + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n            + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n            + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n            + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n            + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n        // Pack the pre and post values from ScheduledValueChange\n        let svc_pre_packed = self.svc.pre.pack();\n        let svc_post_packed = self.svc.post.pack();\n        for i in 0..<T as Packable>::N {\n            result[i + 1] = svc_pre_packed[i];\n            result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n        }\n        result\n    }\n\n    // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let svc = unpack_value_change::<T, _>(fields);\n        let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n        Self::new(svc, sdc)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    fn hash(self) -> Field {\n        poseidon2_hash(self.pack())\n    }\n}\n"
     },
-    "383": {
+    "382": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_delay_change.nr",
-      "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to store the minimum delay with which a ScheduledValueChange object can\n// schedule a change.\n// This delay is initially equal to INITIAL_DELAY, and can be safely mutated to any other value over time. This mutation\n// is performed via `schedule_change` in order to satisfy ScheduleValueChange constraints: if e.g. we allowed for the\n// delay to be decreased immediately then it'd be possible for the state variable to schedule a value change with a\n// reduced delay, invalidating prior private reads.\npub struct ScheduledDelayChange<let INITIAL_DELAY: u64> {\n    // Both pre and post are stored in public storage, so by default they are zeroed. By wrapping them in an Option,\n    // they default to Option::none(), which we detect and replace with INITIAL_DELAY. The end result is that a\n    // ScheduledDelayChange that has not been initialized has a delay equal to INITIAL_DELAY, which is the desired\n    // effect. Once initialized, the Option will never be none again.\n    pub(crate) pre: Option<u64>,\n    pub(crate) post: Option<u64>,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<let INITIAL_DELAY: u64> ScheduledDelayChange<INITIAL_DELAY> {\n    pub fn new(pre: Option<u64>, post: Option<u64>, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the current value of the delay stored in the data structure.\n    /// WARNING: This function only returns a meaningful value when called in public with the current timestamp - for\n    /// historical private reads use `get_effective_minimum_delay_at` instead.\n    pub fn get_current(self, current_timestamp: u64) -> u64 {\n        // The post value becomes the current one at the timestamp of change, so any transaction that is included at or after\n        // the timestamp of change will use the post value.\n        if current_timestamp < self.timestamp_of_change {\n            self.pre.unwrap_or(INITIAL_DELAY)\n        } else {\n            self.post.unwrap_or(INITIAL_DELAY)\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change delay and the timestamp at which it will become the current\n    /// delay. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (u64, u64) {\n        (self.post.unwrap_or(INITIAL_DELAY), self.timestamp_of_change)\n    }\n\n    /// Schedules a change to the delay, given the `current_timestamp` and the `current` delay.\n    /// This function is only meaningful when called in public with the current timestamp.\n    /// The timestamp at which the new delay will become effective is determined automatically:\n    ///  - when increasing the delay, the change is effective immediately\n    ///  - when reducing the delay, the change will take effect after a delay equal to the difference between old and\n    ///    new delay. For example, if reducing from 3 days to 1 day, the reduction will be scheduled to happen after 2\n    ///    days.\n    pub fn schedule_change(&mut self, new: u64, current_timestamp: u64) {\n        let current = self.get_current(current_timestamp);\n\n        // When changing the delay value we must ensure that it is not possible to produce a value change with a delay\n        // shorter than the current one.\n        let time_until_delay_change = if new > current {\n            // Increasing the delay value can therefore be done immediately: this does not invalidate prior constraints\n            // about how quickly a value might be changed (indeed it strengthens them).\n            //\n            //\n            //                                Earliest `svc.timestamp_of_change`,     Earliest `svc.timestamp_of_change`\n            //   `current_timestamp`          if the delay had remained unchanged     immediately after this scheduling fn.\n            //      v                                                          v              v\n            //  ====|==========================================================|==============|==>\n            //      |                                                          |              |\n            //      [------------------`current` delay-------------------------]              |\n            //      |                                                                         |\n            //      [-------------------------`new` (longer) delay----------------------------]\n            //      |\n            //      [] <--- `time_until_delay_change` is `0`; the change is immediate.\n            //      |\n            //      ^\n            //      The newly-calculated `self.timestamp_of_change` (unchanged)\n\n            0\n        } else {\n            // Decreasing the delay requires waiting for the difference between current and new delay in order to ensure\n            // that overall the current delay is respected.\n            //\n            //\n            //                                                   Earliest `svc.timestamp_of_change`,\n            //                                                   if the delay had remained unchanged\n            //                                                   AND\n            //                                                   Earliest `svc.timestamp_of_change`,\n            //   `current_timestamp`                             immediately after this scheduling fn.\n            //  ====|============================|=============================|=================>\n            //      |                                                          |\n            //      [---------------------`current` delay----------------------]\n            //                                   |                             |\n            //                                   [- --`new` (shorter) delay----]\n            //                                   |                             ^\n            //      [-`time_until_delay_change`--]                             |\n            //                                   |                             |\n            //                                   ^                             |\n            //                                   The newly-calculated          |\n            //                                  `self.timestamp_of_change`     |\n            //                                                                 |\n            //                                                      The new `self.timestamp_of_change`\n            //                                                      is calculated so that these ends\n            //                                                      align.\n            current - new\n        };\n\n        self.pre = Option::some(current);\n        self.post = Option::some(new);\n        self.timestamp_of_change = current_timestamp + time_until_delay_change;\n    }\n\n    /// Returns the minimum delay before a value might mutate due to a scheduled change, from the perspective of some\n    /// historical timestamp. It only returns a meaningful value when called in private with historical timestamps.\n    /// The output of this function can be passed into `ScheduledValueChange.get_time_horizon` to properly\n    /// constrain the `include_by_timestamp` when reading delayed mutable state.\n    /// This value typically equals the current delay at the timestamp following the historical one (the earliest one in\n    /// which a value change could be scheduled), but it also considers scenarios in which a delay reduction is\n    /// scheduled to happen in the near future, resulting in a way to schedule a change with an overall delay lower than\n    /// the current one.\n    ///\n    /// Alternative explanation: returns the maximum amount of time (from the historical timestamp) that a state read\n    /// (as at the historical timestamp) will remain valid.\n    /// A read might end up being valid for less time in the case where a `svc.timestamp_of_change` has already been\n    /// set and if it's sooner than the output of this function. In that case, the `scheduled_value_change.nr`'s\n    /// `get_time_horizon` function will realize this.\n    ///\n    pub fn get_effective_minimum_delay_at(self, historical_timestamp: u64) -> u64 {\n        // If a change is scheduled, then the effective delay might be lower than the current one (pre). At the\n        // timestamp of change the current delay will be the scheduled one, with an overall delay from the historical\n        // timestamp equal to the time until the change plus the new delay. If this value is lower\n        // than the current delay, then that is the effective minimum delay.\n\n        // If using some block as the anchor block of some tx, then note that if you\n        // read a `delayed_mutable` from that anchor block, you're actually reading the\n        // `delayed_mutable` _as at the very end_ of that block.\n        // Therefore the `delayed_mutable` that you will read _as at the very start of the next\n        // block_ will be _the very same_ `delayed_mutable` (nothing can possibly have changed).\n        // Therefore the first opportunity to schedule a value change (from the anchor timestamp)\n        // is the first tx of that next block, which takes place at least 1 second after the\n        // anchor block.\n        // So should you choose to go ahead and schedule a value change in the first tx of that\n        // next block, it will only take effect after the \"current delay\" (as dictated by the\n        // `delayed_mutable` of that tx, which is the same as the `delayed_mutable` as at the\n        // anchor timestamp).\n        // In all, the time between the anchor block's timestamp and the earliest-possible value\n        // timestamp_of_change, is therefore: 1 second + the \"current\" delay (as at the time of\n        // the anchor timestamp).\n        // Reads must only be valid until _just before_ the earliest-possible value change --\n        // i.e. 1 second before the earliest-possible value change.\n        // That is, reads are only valid for the \"current\" delay (as at the time of the anchor\n        // timestamp) _at most_.\n        // (I.e. the read remains valid for 1 + \"current delay\" - 1 = \"current delay\", from the\n        // anchor timestamp).\n        //\n        //  ____________                               ____________\n        // |            |                             |            |\n        // |  Block     |<--At least a 1 second gap-->|  Block     |\n        // |____________|                             |____________|\n        //              ^                              ^\n        //              |                              You can schedule a value change from here.\n        //              |\n        //    Suppose this is your anchor block.\n        //    The delayed_mutable (and hence the \"current\" delay) as at the end of this block will\n        //    be the same as at the start of the next block.\n        //\n        if self.timestamp_of_change <= historical_timestamp {\n            //\n            //              `self.timestamp_of_change` <= `historical_timestamp`\n            //                    v                              v\n            // ===================|==============================|=========\n            // ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            // `self.pre` is      |`self.post` takes effect from here.\n            // effective before.  |\n            //\n            // So in this `if` case, `self.post` is in effect at the time of the `historical_timestamp`.\n            //\n            // If no delay changes are scheduled (as at the time of the anchor timestamp), then the\n            // \"current delay\" (as at the time of the historical timestamp) is `self.post` (or the\n            // INITIAL_DELAY if never set).\n            self.post.unwrap_or(INITIAL_DELAY)\n        } else {\n            //\n            //          `historical_timestamp` < `self.timestamp_of_change`\n            //                                           v\n            // ===================|======================|====================================\n            // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            //           `self.pre` is effective         |`self.post` takes effect from here.\n            //           during this period.             |\n            //\n            // So in this `else` case, `self.pre` is in effect at the time of the `historical_timestamp`.\n            //\n            // If a delay change _is_ already scheduled (as at the time of the historical timestamp):\n            //      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            //                   |________________\n            //                                    |\n            //                                    v                          Earliest possible\n            //  `historical_           Scheduled delay change:               `svc.timestamp_of_change`\n            //  timestamp`      <      `self.timestamp_of_change`            (if not already set [^1])\n            //     v                              v                                    v\n            //  ===||=============================|====================================|================>\n            //     .|                             .                                    .\n            //     .|                             .                                    .\n            //     .|__ Earliest possible timestamp at which a                         .\n            //     .    function could call `schedule_change` for a new                .\n            //     .    _value_ change..................................................And the earliest timestamp at\n            //     .                              .                                    .which the new value would take effect.\n            //     .[---------------`self.pre` delay-----------------------------------]\n            //     .                              .                                    .\n            //     [******************************************************************].\n            //     [                                                                  ].\n            //     [----------------`self.pre` delay----------------------------------].\n            //     [                                                                  ].\n            //     [ If reading a _value_ at that (<--) anchor timestamp, then the    ].\n            //     [ read will remain valid for this duration, unless a shorter       ].\n            //     [ delay has been scheduled (see just below in this diagram).       ].\n            //     [ If a _deferred, longer_ delay has been scheduled, it might yet   ].\n            //     [ still be cancelled, in which case this `pre` delay would         ].\n            //     [ bite (see the `min` calc below) -- meaning reads would remain    ].\n            //     [ valid for this duration.                                         ].\n            //     [                                                                  ].\n            //     [******************************************************************].\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     [---`time_until_delay_change`--]                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     SCENARIO 1: scheduled delay is shorter than the `self.pre` delay:   .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              [-`self.post` delay-]                .\n            //     .                              . (if shorter      ^^                .\n            //     .                              .  than `pre`)     ||_ new values can take effect from here.\n            //     .                              .                  |\n            //     .                              .                  |_ reads are only valid until here:\n            //     .                              .                  .  `historic_timestamp + time_until_delay_change + self.post - 1`\n            //     .                              .                  .                 .\n            //     [*************************************************]                 .\n            //     [                                                 ]                 .\n            //     [----`time_until_delay_change + self.post - 1`----]                 .\n            //     [                                                 ]                 .\n            //     [ If reading a _value_ at that (<--) anchor       ]                 .\n            //     [ timestamp, then the read will remain valid      ]                 .\n            //     [ for this duration:                              ]                 .\n            //     [                                                 ]                 .\n            //     [*************************************************]                 .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     SCENARIO 2: scheduled delay is longer than the `self.pre` delay, AND is deferred:\n            //     (note: scheduling deferred delay changes is not yet possible)\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              [-`self.post` delay (if longer than `pre` & deferred)------------------]\n            //     .                              .  (scheduling deferred delay changes is not yet possible)            ^^\n            //     .                              .                                                                     ||\n            //     .                              .     reads would only be valid until here:___________________________||\n            //     .                              .     `historic_timestamp + time_until_delay_change + self.post - 1`   |\n            //     .                              .                                                                      |\n            //     .                              .                        new values would take effect from here,_______|\n            //     .                              .                        but only once this longer delay takes effect  .\n            //     .                              .                                    .                                 .\n            //     .                              .                                    .                                 .\n            //     [****************************************************************************************************].\n            //     [                                                                                                    ].\n            //     [----`time_until_delay_change + self.post - 1`-------------------------------------------------------].\n            //     [                                                                                                    ].\n            //     [ Given a longer, deferred delay, then if reading a _value_ at that (<--) historical timestamp, then ].\n            //     [ you might think the read would remain valid for this duration.                                     ].\n            //     [ BUT, in this case of this deferred, longer-than-`self.pre` delay, the `pre` delay ends sooner (by  ].\n            //     [ construction) (see above in this diagram).                                                         ].\n            //     [ And since this scheduled delay (`post`) can be cancelled up until the time it takes effect,        ].\n            //     [ any reads as at that (<--) historical timestamp would cautiously only be valid until the earlier   ].\n            //     [ `pre` delay expiry.                                                                                ].\n            //     [                                                                                                    ].\n            //     [****************************************************************************************************].\n            //\n            //\n            //\n            // [^1] If a svc.timestamp_of_change has already been set, and if it's sooner than the\n            //      output of this function, then it will bite within `scheduled_value_change.nr`'s\n            //      `get_time_horizon` function.\n            let time_until_delay_change = self.timestamp_of_change - historical_timestamp;\n\n            min(\n                self.pre.unwrap_or(INITIAL_DELAY), // in case the scheduled delay (`post`) gets cancelled before it takes effect.\n                time_until_delay_change + self.post.unwrap_or(INITIAL_DELAY) - 1,\n            )\n        }\n    }\n}\n\nimpl<let INITIAL_DELAY: u64> Eq for ScheduledDelayChange<INITIAL_DELAY> {\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<let INITIAL_DELAY: u64> Empty for ScheduledDelayChange<INITIAL_DELAY> {\n    fn empty() -> Self {\n        Self { pre: Option::none(), post: Option::none(), timestamp_of_change: 0 }\n    }\n}\n"
+      "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to store the minimum delay with which a ScheduledValueChange\n// object can schedule a change.\n// This delay is initially equal to INITIAL_DELAY, and can be safely mutated to any other value over time. This mutation\n// is performed via `schedule_change` in order to satisfy ScheduleValueChange constraints: if e.g. we allowed for the\n// delay to be decreased immediately then it'd be possible for the state variable to schedule a value change with a\n// reduced delay, invalidating prior private reads.\npub struct ScheduledDelayChange<let INITIAL_DELAY: u64> {\n    // Both pre and post are stored in public storage, so by default they are zeroed. By wrapping them in an Option,\n    // they default to Option::none(), which we detect and replace with INITIAL_DELAY. The end result is that a\n    // ScheduledDelayChange that has not been initialized has a delay equal to INITIAL_DELAY, which is the desired\n    // effect. Once initialized, the Option will never be none again.\n    pub(crate) pre: Option<u64>,\n    pub(crate) post: Option<u64>,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<let INITIAL_DELAY: u64> ScheduledDelayChange<INITIAL_DELAY> {\n    pub fn new(pre: Option<u64>, post: Option<u64>, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the current value of the delay stored in the data structure.\n    /// WARNING: This function only returns a meaningful value when called in public with the current timestamp - for\n    /// historical private reads use `get_effective_minimum_delay_at` instead.\n    pub fn get_current(self, current_timestamp: u64) -> u64 {\n        // The post value becomes the current one at the timestamp of change, so any transaction that is included at or\n        // after the timestamp of change will use the post value.\n        if current_timestamp < self.timestamp_of_change {\n            self.pre.unwrap_or(INITIAL_DELAY)\n        } else {\n            self.post.unwrap_or(INITIAL_DELAY)\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change delay and the timestamp at which it will become the current\n    /// delay. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (u64, u64) {\n        (self.post.unwrap_or(INITIAL_DELAY), self.timestamp_of_change)\n    }\n\n    /// Schedules a change to the delay, given the `current_timestamp` and the `current` delay.\n    /// This function is only meaningful when called in public with the current timestamp.\n    /// The timestamp at which the new delay will become effective is determined automatically:\n    ///  - when increasing the delay, the change is effective immediately\n    ///  - when reducing the delay, the change will take effect after a delay equal to the difference between old and\n    ///    new delay. For example, if reducing from 3 days to 1 day, the reduction will be scheduled to happen after 2\n    ///    days.\n    pub fn schedule_change(&mut self, new: u64, current_timestamp: u64) {\n        let current = self.get_current(current_timestamp);\n\n        // When changing the delay value we must ensure that it is not possible to produce a value change with a delay\n        // shorter than the current one.\n        let time_until_delay_change = if new > current {\n            // Increasing the delay value can therefore be done immediately: this does not invalidate prior constraints\n            // about how quickly a value might be changed (indeed it strengthens them).\n            //\n            //\n            //                                Earliest `svc.timestamp_of_change`,     Earliest `svc.timestamp_of_change`\n            //   `current_timestamp`          if the delay had remained unchanged     immediately after this scheduling fn.\n            //      v                                                          v              v\n            //  ====|==========================================================|==============|==>\n            //      |                                                          |              |\n            //      [------------------`current` delay-------------------------]              |\n            //      |                                                                         |\n            //      [-------------------------`new` (longer) delay----------------------------]\n            //      |\n            //      [] <--- `time_until_delay_change` is `0`; the change is immediate.\n            //      |\n            //      ^\n            //      The newly-calculated `self.timestamp_of_change` (unchanged)\n\n            0\n        } else {\n            // Decreasing the delay requires waiting for the difference between current and new delay in order to ensure\n            // that overall the current delay is respected.\n            //\n            //\n            //                                                   Earliest `svc.timestamp_of_change`,\n            //                                                   if the delay had remained unchanged\n            //                                                   AND\n            //                                                   Earliest `svc.timestamp_of_change`,\n            //   `current_timestamp`                             immediately after this scheduling fn.\n            //  ====|============================|=============================|=================>\n            //      |                                                          |\n            //      [---------------------`current` delay----------------------]\n            //                                   |                             |\n            //                                   [- --`new` (shorter) delay----]\n            //                                   |                             ^\n            //      [-`time_until_delay_change`--]                             |\n            //                                   |                             |\n            //                                   ^                             |\n            //                                   The newly-calculated          |\n            //                                  `self.timestamp_of_change`     |\n            //                                                                 |\n            //                                                      The new `self.timestamp_of_change`\n            //                                                      is calculated so that these ends\n            //                                                      align.\n            current - new\n        };\n\n        self.pre = Option::some(current);\n        self.post = Option::some(new);\n        self.timestamp_of_change = current_timestamp + time_until_delay_change;\n    }\n\n    /// Returns the minimum delay before a value might mutate due to a scheduled change, from the perspective of some\n    /// anchor block timestamp. It only returns a meaningful value when called in private with anchor block timestamps.\n    /// The output of this function can be passed into `ScheduledValueChange.get_time_horizon` to properly\n    /// constrain the `expiration_timestamp` when reading delayed mutable state.\n    /// This value typically equals the current delay at the timestamp following the anchor block one (the earliest one\n    /// in which a value change could be scheduled), but it also considers scenarios in which a delay reduction is\n    /// scheduled to happen in the near future, resulting in a way to schedule a change with an overall delay lower than\n    /// the current one.\n    ///\n    /// Alternative explanation: returns the maximum amount of time (from the anchor block timestamp) that a state read\n    /// (as at the anchor block timestamp) will remain valid.\n    /// A read might end up being valid for less time in the case where a `svc.timestamp_of_change` has already been\n    /// set and if it's sooner than the output of this function. In that case, the `scheduled_value_change.nr`'s\n    /// `get_time_horizon` function will realize this.\n    ///\n    pub fn get_effective_minimum_delay_at(self, anchor_block_timestamp: u64) -> u64 {\n        // If a change is scheduled, then the effective delay might be lower than the current one (pre). At the\n        // timestamp of change the current delay will be the scheduled one, with an overall delay from the anchor block\n        // timestamp equal to the time until the change plus the new delay. If this value is lower\n        // than the current delay, then that is the effective minimum delay.\n\n        // If using some block as the anchor block of some tx, then note that if you\n        // read a `delayed_mutable` from that anchor block, you're actually reading the\n        // `delayed_mutable` _as at the very end_ of that block.\n        // Therefore the `delayed_mutable` that you will read _as at the very start of the next\n        // block_ will be _the very same_ `delayed_mutable` (nothing can possibly have changed).\n        // Therefore the first opportunity to schedule a value change (from the anchor block timestamp)\n        // is the first tx of a subsequent block. Blocks within the same checkpoint can share\n        // timestamps, so the earliest scheduling timestamp can equal the anchor block timestamp.\n        // So should you choose to go ahead and schedule a value change in a subsequent block,\n        // it will only take effect after the \"current\" delay (as dictated by the\n        // `delayed_mutable` of that tx, which is the same as the `delayed_mutable` as at the\n        // anchor block timestamp).\n        // In all, the time between the anchor block's timestamp and the earliest-possible value\n        // timestamp_of_change, is therefore: the \"current\" delay (as at the time of the anchor\n        // timestamp).\n        // Reads must only be valid until _just before_ the earliest-possible value change --\n        // i.e. 1 second before the earliest-possible value change.\n        // That is, reads are only valid for the \"current\" delay (as at the time of the anchor\n        // block timestamp) _at most_.\n        //\n        //  ____________                               ____________\n        // |            |                             |            |\n        // |  Block     |<-- 0 or more seconds gap -->|  Block     |\n        // |____________|                             |____________|\n        //              ^                              ^\n        //              |                              You can schedule a value change from here.\n        //              |\n        //    Suppose this is your anchor block.\n        //    The delayed_mutable (and hence the \"current\" delay) as at the end of this block will\n        //    be the same as at the start of the next block.\n        //\n        if self.timestamp_of_change <= anchor_block_timestamp {\n            //\n            //              `self.timestamp_of_change` <= `anchor_block_timestamp`\n            //                    v                              v\n            // ===================|==============================|=========\n            // ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            // `self.pre` is      |`self.post` takes effect from here.\n            // effective before.  |\n            //\n            // So in this `if` case, `self.post` is in effect at the time of the `anchor_block_timestamp`.\n            //\n            // If no delay changes are scheduled (as at the time of the anchor timestamp), then the \"current delay\" (as\n            // at the time of the anchor block timestamp) is `self.post - 1` (or the `INITIAL_DELAY - 1` if never set).\n            self.post.unwrap_or(INITIAL_DELAY) - 1\n        } else {\n            //\n            //          `anchor_block_timestamp` < `self.timestamp_of_change`\n            //                                           v\n            // ===================|======================|====================================\n            // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            //           `self.pre` is effective         |`self.post` takes effect from here.\n            //           during this period.             |\n            //\n            //\n            // So in this `else` case, `self.pre` is in effect at the time of the `anchor_block_timestamp`.\n            //\n            //\n            //\n            // If a delay change _is_ already scheduled (as at the time of the anchor block timestamp):\n            //      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            //                   |________________\n            //                                    |\n            //                                    v                          Earliest possible\n            //  `anchor_block_          Scheduled delay change:               `svc.timestamp_of_change`\n            //  timestamp`      <      `self.timestamp_of_change`            (if not already set [^1])\n            //     v                              v                                    v\n            //  ===|==============================|====================================|================>\n            //     |                              .                                    .\n            //     |                              .                                    .\n            //     |__ Earliest possible timestamp at which a                          .\n            //     .    function could call `schedule_change` for a new                .\n            //     .    _value_ change.................................................| And the earliest timestamp at\n            //     .                              .                                    . which the new value would take effect,\n            //     .                              .                                    . as dictated by `self.pre`.\n            //     .                              .                                    .\n            //     [---------------`self.pre` delay------------------------------------]\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     ********************************************************************.\n            //     *                                                                  *.\n            //     [----------------`self.pre - 1`------------------------------------].\n            //     *                                                                  *.\n            //     * If reading a _value_ at that (<--) anchor timestamp, then the    *.\n            //     * read will remain valid for this duration, unless a shorter       *.\n            //     * delay has been scheduled (see just below in this diagram).       *.\n            //     * See the `min` calc in the code below.                            *.\n            //     *                                                                  *.\n            //     * Future enhancement, recorded here so we don't have to            *.\n            //     * re-remember it:                                                  *.\n            //     * If a _deferred, longer_ delay has been scheduled (not yet        *.\n            //     * possible), it might yet still be cancelled, in which case this   *.\n            //     * `pre - 1` delay would also bite (meaning reads would remain      *.\n            //     * valid for this duration).                                        *.\n            //     *                                                                  *.\n            //     ********************************************************************.\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     [---`time_until_delay_change`--]                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     SCENARIO 1: an already-scheduled delay is shorter than the `self.pre` delay:\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              [-`self.post` delay-]                .\n            //     .                              . (if shorter      ^^                .\n            //     .                              .  than `pre`)     ||_ new values can take effect from here.\n            //     .                              .                  |\n            //     .                              .                  |_ reads are only valid until here:\n            //     .                              .                  .  `anchor_block_timestamp + time_until_delay_change + self.post - 1`\n            //     .                              .                  .                 .\n            //     ***************************************************                 .\n            //     *                                                 *                 .\n            //     [----`time_until_delay_change + self.post - 1`----]                 .\n            //     *                                                 *                 .\n            //     * If reading a _value_ at that (<--) anchor       *                 .\n            //     * timestamp, then the read will remain valid      *                 .\n            //     * for this duration:                              *                 .\n            //     *                                                 *                 .\n            //     ***************************************************                 .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     SCENARIO 2: an already-scheduled delay is longer than the `self.pre` delay, AND is deferred:\n            //     (note: scheduling deferred delay changes is not yet possible)\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              [-`self.post` delay (if longer than `pre` & deferred)------------------]\n            //     .                              .  (scheduling deferred delay changes is not yet possible)            ^^\n            //     .                              .                                                                     ||\n            //     .                              .     reads would only be valid until here:___________________________||\n            //     .                              .     `anchor_block_timestamp + time_until_delay_change + self.post - 1` |\n            //     .                              .                                                                      |\n            //     .                              .                        new values would take effect from here,_______|\n            //     .                              .                        but only once this longer delay takes effect  .\n            //     .                              .                                    .                                 .\n            //     .                              .                                    .                                 .\n            //     .                              .                                    .                                 .\n            //     ******************************************************************************************************.\n            //     *                                                                                                    *.\n            //     [----`time_until_delay_change + self.post - 1`-------------------------------------------------------].\n            //     *                                                                                                    *.\n            //     * Given a longer, deferred delay, then if reading a _value_ at that (<--) anchor block timestamp, then *.\n            //     * you might think the read would remain valid for this duration.                                     *.\n            //     * BUT, in this case of this deferred, longer-than-`self.pre` delay, the `pre` delay ends sooner (by  *.\n            //     * construction) (see above in this diagram).                                                         *.\n            //     * And since this scheduled delay (`post`) can be cancelled up until the time it takes effect,        *.\n            //     * any reads as at that (<--) anchor block timestamp would cautiously only be valid until the earlier   *.\n            //     * `pre` delay expiry.                                                                                *.\n            //     *                                                                                                    *.\n            //     ******************************************************************************************************.\n            //\n            //\n            //\n            // [^1] If a svc.timestamp_of_change has already been set, and if it's sooner than the\n            //      output of this function, then it will bite within `scheduled_value_change.nr`'s\n            //      `get_time_horizon` function.\n            let time_until_delay_change = self.timestamp_of_change - anchor_block_timestamp;\n\n            let time_until_next_delay_change = min(\n                self.pre.unwrap_or(INITIAL_DELAY), // in case the scheduled delay (`post`) gets cancelled before it takes effect.\n                time_until_delay_change + self.post.unwrap_or(INITIAL_DELAY),\n            );\n\n            // The effective minimum delay equals the minimum time until a value change, minus 1, since reads are\n            // valid only up to (but not including) the moment the value can change.\n            time_until_next_delay_change - 1\n        }\n    }\n}\n\nimpl<let INITIAL_DELAY: u64> Eq for ScheduledDelayChange<INITIAL_DELAY> {\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<let INITIAL_DELAY: u64> Empty for ScheduledDelayChange<INITIAL_DELAY> {\n    fn empty() -> Self {\n        Self { pre: Option::none(), post: Option::none(), timestamp_of_change: 0 }\n    }\n}\n"
     },
-    "385": {
+    "384": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
-      "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n    pub(crate) pre: T,\n    pub(crate) post: T,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n    pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n    /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n    /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n    /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon (see\n    /// `get_time_horizon()`).\n    pub fn get_current_at(self, timestamp: u64) -> T {\n        // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n        // - in public, any transaction that is included at the timestamp of change will use the post value\n        // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n        //   the post value (barring any follow-up changes)\n        if timestamp < self.timestamp_of_change {\n            self.pre\n        } else {\n            self.post\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n    /// value. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (T, u64) {\n        (self.post, self.timestamp_of_change)\n    }\n\n    // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n    // value might not be the current anymore since timestamp of change might have already passed.\n    pub fn get_previous(self) -> (T, u64) {\n        (self.pre, self.timestamp_of_change)\n    }\n\n    /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n    /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n    /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n    /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n    /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n    /// however, then this value is the 'effective minimum delay' (obtained by calling\n    /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n    /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n    /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n    /// if the transaction's `include_by_timestamp` property is set to a value lower or equal to the time horizon\n    /// computed using the same anchor timestamp.\n    pub fn get_time_horizon(self, anchor_timestamp: u64, minimum_delay: u64) -> u64 {\n        // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n        // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n        // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n        // to the time horizon.\n        if anchor_timestamp >= self.timestamp_of_change {\n            // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n            // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n            // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n            // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n            // timestamp, and so the smallest possible next timestamp of change equals `anchor_timestamp + 1 +\n            // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n            //\n            //   timestamp of    anchor\n            //      change       timestamp          time horizon\n            //   =======|=============N===================H===========>\n            //                         ^                   ^\n            //                         ---------------------\n            //                             minimum delay\n            anchor_timestamp + minimum_delay\n        } else {\n            // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n            //   a) It could be so far into the future that the time horizon is actually determined by the minimum\n            //      delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n            //      This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n            //      the timestamp prior to the earliest one in which a new timestamp of change might land.\n            //\n            //         anchor\n            //         timestamp                      time horizon    timestamp of change\n            //        =====N=================================H=================|=========>\n            //              ^                                 ^\n            //              |                                 |\n            //              -----------------------------------\n            //                        minimum delay\n            //\n            //   b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n            //      the timestamp of change would become the limiting factor for the time horizon, which would equal\n            //      the timestamp right before the timestamp of change (since by definition the value changes at the\n            //      timestamp of change).\n            //\n            //           anchor                         time horizon\n            //           timestamp   timestamp of change    if not scheduled\n            //        =======N=============|===================H=================>\n            //                ^           ^                     ^\n            //                |     actual horizon              |\n            //                -----------------------------------\n            //                          minimum delay\n            //\n            // Note that the current implementation does not allow the caller to set the timestamp of change to an\n            // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n            // allow for this to happen.\n            // Because anchor_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n            // subtract 1.\n            min(\n                self.timestamp_of_change - 1,\n                anchor_timestamp + minimum_delay,\n            )\n        }\n    }\n\n    /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n    /// called in public with the current timestamp.\n    pub fn schedule_change(\n        &mut self,\n        new_value: T,\n        current_timestamp: u64,\n        minimum_delay: u64,\n        timestamp_of_change: u64,\n    ) {\n        assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n        self.pre = self.get_current_at(current_timestamp);\n        self.post = new_value;\n        self.timestamp_of_change = timestamp_of_change;\n    }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n    T: Empty,\n{\n    fn empty() -> Self {\n        Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n    }\n}\n"
+      "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n    pub(crate) pre: T,\n    pub(crate) post: T,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n    pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n    /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n    /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon (see\n    /// `get_time_horizon()`).\n    pub fn get_current_at(self, timestamp: u64) -> T {\n        // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n        // - in public, any transaction that is included at the timestamp of change will use the post value\n        // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n        //   the post value (barring any follow-up changes)\n        if timestamp < self.timestamp_of_change {\n            self.pre\n        } else {\n            self.post\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n    /// value. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (T, u64) {\n        (self.post, self.timestamp_of_change)\n    }\n\n    // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n    // value might not be the current anymore since timestamp of change might have already passed.\n    pub fn get_previous(self) -> (T, u64) {\n        (self.pre, self.timestamp_of_change)\n    }\n\n    /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n    /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n    /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n    /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n    /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n    /// however, then this value is the 'effective minimum delay' (obtained by calling\n    /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n    /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n    /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon\n    /// computed using the same anchor timestamp.\n    pub fn get_time_horizon(self, anchor_block_timestamp: u64, minimum_delay: u64) -> u64 {\n        // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n        // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n        // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n        // to the time horizon.\n        if anchor_block_timestamp >= self.timestamp_of_change {\n            // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n            // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n            // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n            // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n            // timestamp, and so the smallest possible next timestamp of change equals `anchor_block_timestamp + 1 +\n            // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n            //\n            //   timestamp of    anchor\n            //      change       timestamp          time horizon\n            //   =======|=============N===================H===========>\n            //                         ^                   ^\n            //                         ---------------------\n            //                             minimum delay\n            anchor_block_timestamp + minimum_delay\n        } else {\n            // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n            //   a) It could be so far into the future that the time horizon is actually determined by the minimum\n            //      delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n            //      This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n            //      the timestamp prior to the earliest one in which a new timestamp of change might land.\n            //\n            //         anchor\n            //         timestamp                      time horizon    timestamp of change\n            //        =====N=================================H=================|=========>\n            //              ^                                 ^\n            //              |                                 |\n            //              -----------------------------------\n            //                        minimum delay\n            //\n            //   b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n            //      the timestamp of change would become the limiting factor for the time horizon, which would equal\n            //      the timestamp right before the timestamp of change (since by definition the value changes at the\n            //      timestamp of change).\n            //\n            //           anchor                         time horizon\n            //           timestamp   timestamp of change    if not scheduled\n            //        =======N=============|===================H=================>\n            //                ^           ^                     ^\n            //                |     actual horizon              |\n            //                -----------------------------------\n            //                          minimum delay\n            //\n            // Note that the current implementation does not allow the caller to set the timestamp of change to an\n            // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n            // allow for this to happen.\n            // Because anchor_block_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n            // subtract 1.\n            min(\n                anchor_block_timestamp + minimum_delay,\n                self.timestamp_of_change - 1,\n            )\n        }\n    }\n\n    /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n    /// called in public with the current timestamp.\n    pub fn schedule_change(\n        &mut self,\n        new_value: T,\n        current_timestamp: u64,\n        minimum_delay: u64,\n        timestamp_of_change: u64,\n    ) {\n        assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n        self.pre = self.get_current_at(current_timestamp);\n        self.post = new_value;\n        self.timestamp_of_change = timestamp_of_change;\n    }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n    T: Empty,\n{\n    fn empty() -> Self {\n        Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n    }\n}\n"
     },
-    "388": {
+    "387": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\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        compute_note_nonce_and_unique_note_hash(siloed_note_hash, first_nullifier, note_index_in_tx)\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: Scoped<Counted<NoteHash>>) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.innermost())\n    }\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: Scoped<Counted<Nullifier>>) -> Field {\n    let value = nullifier.innermost().value;\n    // Q: shouldn't we be checking whether the _whole_ scoped, counted, nullifier struct is empty?\n    // A: We don't have to. The init and inner circuits add a contract address only to non-empty nullifiers.\n    // So we know we should silo it if the contract address is not empty.\n    if nullifier.contract_address.is_zero() {\n        // Return `.value` instead of 0, because already-siloed nullifiers also have a zero\n        // contract_address field, and we of course want to return that already-siloed nullifier\n        // (we just don't want to silo it a second time).\n        value\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, value)\n    }\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn silo_private_log(private_log: Scoped<Counted<PrivateLogData>>) -> PrivateLog {\n    let log = private_log.innermost().log;\n    if private_log.contract_address.is_zero() {\n        log\n    } else {\n        let mut fields = log.fields;\n        fields[0] = compute_siloed_private_log_first_field(private_log.contract_address, fields[0]);\n        PrivateLog::new(fields, log.length)\n    }\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    app_secret_key_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        app_secret_key_domain_separator,\n    )\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 contract_address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: Scoped<L2ToL1Message>,\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.inner.recipient,\n            msg.inner.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// NB the below is the same as poseidon::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> 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.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0x3b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992);\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 == 0xaab2a5828156782b12a1dc6f336e2bc627eb1b9514b02d511f66296990c050);\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        L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n            AztecAddress::from_field(3),\n        ),\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
+      "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\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 compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\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        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> 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.get(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 subarray_hash_matches_fixed() {\n    let mut values_to_hash = [3; 17];\n    let mut padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let mut values_to_hash = [3; 17];\n    let mut padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
+    },
+    "389": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
+      "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n#[oracle(utilityLog)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
     "403": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
@@ -2871,7 +2871,7 @@
     },
     "411": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
-      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, DOM_SEP__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse std::{default::Default, meta::derive};\nuse std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            DOM_SEP__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nmod test {\n    use crate::{\n        point::POINT_LENGTH,\n        public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n        traits::{Deserialize, Serialize},\n    };\n    use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\n    #[test]\n    unconstrained fn compute_public_keys_hash() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n            ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n            ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n            tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n        };\n\n        let actual = keys.hash();\n\n        // The following value was generated by `public_keys.test.ts`.\n        let expected_public_keys_hash =\n            0x056998309f6c119e4d753e404f94fef859dddfa530a9379634ceb0854b29bf7a;\n\n        assert(actual.to_field() == expected_public_keys_hash);\n    }\n\n    #[test]\n    unconstrained fn compute_default_hash() {\n        let keys = PublicKeys::default();\n\n        let actual = keys.hash();\n\n        // The following value was generated by `public_keys.test.ts`.\n        let test_data_default_hash =\n            0x023547e676dba19784188825b901a0e70d8ad978300d21d6185a54281b734da0;\n\n        assert(actual.to_field() == test_data_default_hash);\n    }\n\n    #[test]\n    unconstrained fn serde() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n            ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n            ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n            tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n        };\n\n        // We use the PUBLIC_KEYS_LENGTH constant to ensure that there is a match between the derived trait\n        let serialized: [Field; POINT_LENGTH * 4] = keys.serialize();\n        let deserialized = PublicKeys::deserialize(serialized);\n\n        assert_eq(keys, deserialized);\n    }\n}\n"
+      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, DOM_SEP__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::validate_on_curve,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse std::{default::Default, meta::derive};\nuse std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            DOM_SEP__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n\n    pub fn validate_on_curve(self) {\n        validate_on_curve(self.npk_m.inner);\n        validate_on_curve(self.ivpk_m.inner);\n        validate_on_curve(self.ovpk_m.inner);\n        validate_on_curve(self.tpk_m.inner);\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nmod test {\n    use crate::{\n        point::POINT_LENGTH,\n        public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n        traits::{Deserialize, Serialize},\n    };\n    use std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\n    #[test]\n    unconstrained fn compute_public_keys_hash() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n            ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n            ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n            tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n        };\n\n        let actual = keys.hash();\n\n        // The following value was generated by `public_keys.test.ts`.\n        let expected_public_keys_hash =\n            0x056998309f6c119e4d753e404f94fef859dddfa530a9379634ceb0854b29bf7a;\n\n        assert(actual.to_field() == expected_public_keys_hash);\n    }\n\n    #[test]\n    unconstrained fn compute_default_hash() {\n        let keys = PublicKeys::default();\n\n        let actual = keys.hash();\n\n        // The following value was generated by `public_keys.test.ts`.\n        let test_data_default_hash =\n            0x023547e676dba19784188825b901a0e70d8ad978300d21d6185a54281b734da0;\n\n        assert(actual.to_field() == test_data_default_hash);\n    }\n\n    #[test]\n    unconstrained fn serde() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n            ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n            ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n            tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n        };\n\n        // We use the PUBLIC_KEYS_LENGTH constant to ensure that there is a match between the derived trait\n        let serialized: [Field; POINT_LENGTH * 4] = keys.serialize();\n        let deserialized = PublicKeys::deserialize(serialized);\n\n        assert_eq(keys, deserialized);\n    }\n}\n"
     },
     "416": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
@@ -2891,7 +2891,7 @@
     },
     "439": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
-      "source": "pub(crate) mod assert_trailing_zeros;\npub(crate) mod copy_items_into_array;\npub(crate) mod find_index;\npub(crate) mod get_sorted_tuples;\npub(crate) mod claimed_length_array;\n\n// Re-exports.\npub use assert_trailing_zeros::assert_trailing_zeros;\npub use claimed_length_array::ClaimedLengthArray;\npub use copy_items_into_array::copy_items_into_array;\npub use find_index::{find_first_index, find_last_index};\npub use get_sorted_tuples::{get_sorted_tuples, SortedTuple};\n\nuse crate::traits::Empty;\n\n// TODO: Consider making this a part of the noir stdlib.\n/// Helper fn to create a subarray from a given array.\npub fn subarray<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\n/// Helper function to count the number of non-empty elements in a validated array.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\n/// 1. All elements before the first empty element are non-empty\n/// 2. All elements after and including the first empty element are empty\n/// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc comment above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_first_index(array, |elem: T| elem.is_empty()) };\n\n    validate_array_length_hint(array, length);\n\n    length\n}\n\n// Extracted into a standalone function to enable testing of bad hints.\nfn validate_array_length_hint<T, let N: u32>(array: [T; N], length: u32)\nwhere\n    T: Empty,\n{\n    // Note: if length > N, the below `array` access will throw an out of bounds error.\n\n    if length != N {\n        array[length].assert_empty(\"Expected array[length] to be empty\");\n    }\n\n    if length != 0 {\n        assert(\n            !array[length - 1].is_empty(),\n            \"Expected claimed final element of array (array[length - 1]) to be nonempty\",\n        );\n    }\n}\n\n// Returns an array length defined by fully trimming _all_ \"empty\" items\n// from the RHS.\npub unconstrained fn trimmed_array_length_hint<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty,\n{\n    let index_of_last_nonempty = find_last_index(array, |elem: T| !elem.is_empty());\n    let length: u32 = if index_of_last_nonempty != N {\n        1 + index_of_last_nonempty\n    } else {\n        0\n    };\n    length\n}\n\n// Returns the number of consecutive elements at the start of the array for which the predicate returns false.\n// This function ensures that any element after the first matching element (predicate returns true) also matches the predicate.\npub fn array_length_until<T, let N: u32, Env>(array: [T; N], predicate: fn[Env](T) -> bool) -> u32 {\n    let mut length = 0;\n    let mut stop = false;\n    for i in 0..N {\n        if predicate(array[i]) {\n            stop = true;\n        } else {\n            assert(\n                stop == false,\n                \"matching element found after already encountering a non-matching element\",\n            );\n            length += 1;\n        }\n    }\n    length\n}\n\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n\n    validate_array_merge_hint(array1, array2, result);\n\n    result\n}\n\n// Danger: assumes the array's length has already been validated.\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        // This function should only be used with validated arrays, so it's fine to simply skip empty elements here.\n        if !elem.is_empty() {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !elem.is_empty() {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n/// Extracted into a standalone function to enable testing of bad hints.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\nfn validate_array_merge_hint<T, let N: u32>(array1: [T; N], array2: [T; N], result: [T; N])\nwhere\n    T: Empty,\n{\n    // We assume the array length has been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i], \"Incorrect array merge hint\");\n        } else {\n            assert_eq(result[i], array2[i - array1_len], \"Incorrect array merge hint\");\n        }\n    }\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to check if an array is padded with a given value from a given index.\npub fn array_padded_with<T, let N: u32>(array: [T; N], from_index: u32, padded_with: T) -> bool\nwhere\n    T: Eq,\n{\n    let mut is_valid = true;\n    let mut should_check = false;\n    for i in 0..N {\n        should_check |= i == from_index;\n        is_valid &= !should_check | (array[i] == padded_with);\n    }\n    is_valid\n}\n\n// ==================== subarray tests ====================\n\n#[test]\nfn test_subarray() {\n    assert_eq(subarray::<_, 5, 3>([10, 20, 30, 40, 50], 1), [20, 30, 40]);\n    assert_eq(subarray::<_, 5, 2>([10, 20, 30, 40, 50], 0), [10, 20]);\n    assert_eq(subarray::<_, 3, 0>([10, 20, 30], 2), []);\n    assert_eq(subarray::<_, 3, 1>([10, 20, 30], 2), [30]);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_offset_out_of_bounds() {\n    let _: [Field; 1] = subarray([10, 20, 30], 5);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_result_size_exceeds_available() {\n    let _: [Field; 3] = subarray([10, 20, 30, 40, 50], 3);\n}\n\n// ==================== array_length tests ====================\n\n#[test]\nfn test_array_length_empty_array() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    // This is why the arrays being passed-into `array_length` must already have been \"validated\"\n    // (dense lhs, empty rhs).\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n// ==================== validate_array_length_hint tests ====================\n\n#[test]\nfn test_validate_array_length_hint_valid() {\n    validate_array_length_hint([0, 0, 0], 0);\n    validate_array_length_hint([10, 20, 0], 2);\n    validate_array_length_hint([10, 20, 30], 3);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_claims_zero_when_not_empty() {\n    // Invalid: hint says length 0, but first element is not empty\n    validate_array_length_hint([10, 20, 30], 0);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_too_short() {\n    // Invalid: hint says length 1, but element at index 1 is not empty\n    validate_array_length_hint([10, 20, 0], 1);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_too_long() {\n    // Invalid: hint says length 2, but element at index 1 is empty\n    validate_array_length_hint([10, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_of_empty_too_long() {\n    // Invalid: hint says length 2, but element at index 1 is empty\n    validate_array_length_hint([0, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_validate_array_length_hint_out_of_bounds() {\n    // Invalid: hint says length 4, but array only has 3 elements\n    validate_array_length_hint([10, 20, 30], 4);\n}\n\n// ==================== trimmed_array_length_hint tests ====================\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_trailing_empties() {\n    assert_eq(trimmed_array_length_hint([10, 20, 30, 0, 0]), 3);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_fully_empty() {\n    assert_eq(trimmed_array_length_hint([0, 0, 0, 0, 0]), 0);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_no_empties() {\n    assert_eq(trimmed_array_length_hint([10, 20, 30, 40, 50]), 5);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_gaps() {\n    // Unlike array_length, this trims from the right only, so gaps don't matter\n    assert_eq(trimmed_array_length_hint([10, 0, 30, 0, 0]), 3);\n}\n\n// ==================== array_length_until tests ====================\n\n#[test]\nfn test_array_length_until() {\n    let array = [11, 22, 33, 44, 55];\n    assert_eq(array_length_until(array, |x| x == 55), 4);\n    assert_eq(array_length_until(array, |x| x == 56), 5);\n    assert_eq(array_length_until(array, |x| x > 40), 3);\n    assert_eq(array_length_until(array, |x| x > 10), 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_non_consecutive_fails() {\n    let array = [1, 1, 0, 1, 0];\n    let _ = array_length_until(array, |x| x == 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_first_non_matching_fails() {\n    let array = [1, 0, 0, 0, 0];\n    let _ = array_length_until(array, |x| x == 1);\n}\n\n// ==================== array_merge tests ====================\n\n#[test]\nfn test_array_merge() {\n    assert_eq(array_merge([10, 20, 0, 0, 0], [30, 40, 50, 0, 0]), [10, 20, 30, 40, 50]);\n    assert_eq(array_merge([0, 0, 0], [10, 20, 0]), [10, 20, 0]);\n    assert_eq(array_merge([10, 20, 0], [0, 0, 0]), [10, 20, 0]);\n    assert_eq(array_merge::<Field, 3>([0, 0, 0], [0, 0, 0]), [0, 0, 0]);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_array_merge_combined_exceeds_capacity() {\n    let _ = array_merge([10, 20, 30, 0, 0], [40, 50, 60, 0, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_array_merge_rejects_array1_with_gaps() {\n    // array_merge assumes validated arrays (no gaps). The helper compacts empties,\n    // but the validation expects array1's structure to be preserved, causing failure.\n    let _ = array_merge([10, 0, 20, 0, 0], [30, 0, 0, 0, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_array_merge_rejects_array2_with_gaps() {\n    // array_merge assumes validated arrays (no gaps). The helper compacts empties,\n    // but the validation expects array2's structure to be preserved, causing failure.\n    let _ = array_merge([10, 0, 0, 0, 0], [0, 20, 0, 30, 0]);\n}\n\n// ==================== validate_array_merge_hint tests ====================\n\n#[test]\nfn test_validate_array_merge_hint_valid() {\n    validate_array_merge_hint([10, 20, 0], [30, 0, 0], [10, 20, 30]);\n    validate_array_merge_hint([0, 0, 0], [10, 20, 0], [10, 20, 0]);\n    validate_array_merge_hint([10, 20, 0], [0, 0, 0], [10, 20, 0]);\n    validate_array_merge_hint([0, 0, 0], [0, 0, 0], [0, 0, 0]);\n    validate_array_merge_hint([10, 20, 0, 0], [30, 40, 0, 0], [10, 20, 30, 40]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_wrong_result_from_array1() {\n    // Invalid: result doesn't match array1 elements\n    validate_array_merge_hint([10, 20, 0], [30, 0, 0], [99, 20, 30]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_wrong_result_from_array2() {\n    // Invalid: result doesn't match array2 elements\n    validate_array_merge_hint([10, 20, 0], [30, 0, 0], [10, 20, 99]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_swapped_order() {\n    // Invalid: result has array2 elements before array1 elements\n    validate_array_merge_hint([10, 20, 0], [30, 0, 0], [30, 10, 20]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_missing_element_from_array1() {\n    // Invalid: result is missing an element from array1\n    validate_array_merge_hint([10, 20, 0], [30, 0, 0], [10, 30, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_missing_element_from_array2() {\n    // Invalid: result is missing an element from array2 (truncated)\n    validate_array_merge_hint([10, 20, 0, 0], [30, 40, 0, 0], [10, 20, 30, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_extra_element_in_padding() {\n    // Invalid: result has garbage where array2's empties should be\n    validate_array_merge_hint([10, 0, 0], [20, 0, 0], [10, 20, 99]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_rejects_compacted_result_for_array1_with_gaps() {\n    // If array1 has gaps, a compacted result won't match the expected structure\n    validate_array_merge_hint([10, 0, 20, 0, 0], [30, 0, 0, 0, 0], [10, 20, 30, 0, 0]);\n}\n\n#[test(should_fail_with = \"Incorrect array merge hint\")]\nfn test_validate_array_merge_hint_rejects_compacted_result_for_array2_with_gaps() {\n    // If array2 has gaps, a compacted result won't match the expected structure\n    validate_array_merge_hint([10, 0, 0, 0, 0], [0, 20, 0, 30, 0], [10, 20, 30, 0, 0]);\n}\n\n// ==================== check_permutation tests ====================\n\n#[test]\nfn test_check_permutation() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn test_check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn test_check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n// ==================== array_padded_with tests ====================\n\n#[test]\nfn test_array_padded_with() {\n    let array = [11, 22, 33, 44, 44];\n    assert_eq(array_padded_with(array, 0, 44), false);\n    assert_eq(array_padded_with(array, 1, 44), false);\n    assert_eq(array_padded_with(array, 2, 44), false);\n    assert_eq(array_padded_with(array, 3, 44), true);\n    assert_eq(array_padded_with(array, 4, 44), true);\n    assert_eq(array_padded_with(array, 4, 33), false);\n    assert_eq(array_padded_with(array, 5, 44), true); // Index out of bounds.\n    assert_eq(array_padded_with(array, 0, 11), false);\n}\n"
+      "source": "pub(crate) mod assert_trailing_zeros;\npub(crate) mod splice_at_count;\npub(crate) mod find_index;\npub(crate) mod get_sorted_tuples;\npub(crate) mod claimed_length_array;\n\n// Re-exports.\npub use assert_trailing_zeros::assert_trailing_zeros;\npub use claimed_length_array::ClaimedLengthArray;\npub use find_index::{find_first_index, find_last_index};\npub use get_sorted_tuples::{get_sorted_tuples, SortedTuple};\npub use splice_at_count::splice_at_count;\n\nuse crate::traits::Empty;\n\n// TODO: Consider making this a part of the noir stdlib.\n/// Helper fn to create a subarray from a given array.\npub fn subarray<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\n/// Helper function to count the number of non-empty elements in a validated array.\n/// Danger: This is only safe to call if the input arrays have been \"validated\" (dense lhs, empty rhs).\n/// 1. All elements before the first empty element are non-empty\n/// 2. All elements after and including the first empty element are empty\n/// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc comment above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_first_index(array, |elem: T| elem.is_empty()) };\n\n    validate_array_length_hint(array, length);\n\n    length\n}\n\n// Extracted into a standalone function to enable testing of bad hints.\nfn validate_array_length_hint<T, let N: u32>(array: [T; N], length: u32)\nwhere\n    T: Empty,\n{\n    // Note: if length > N, the below `array` access will throw an out of bounds error.\n\n    if length != N {\n        array[length].assert_empty(\"Expected array[length] to be empty\");\n    }\n\n    if length != 0 {\n        assert(\n            !array[length - 1].is_empty(),\n            \"Expected claimed final element of array (array[length - 1]) to be nonempty\",\n        );\n    }\n}\n\n// Returns an array length defined by fully trimming _all_ \"empty\" items\n// from the RHS.\npub unconstrained fn trimmed_array_length_hint<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty,\n{\n    let index_of_last_nonempty = find_last_index(array, |elem: T| !elem.is_empty());\n    let length: u32 = if index_of_last_nonempty != N {\n        1 + index_of_last_nonempty\n    } else {\n        0\n    };\n    length\n}\n\n// Returns the number of consecutive elements at the start of the array for which the predicate returns false.\n// This function ensures that any element after the first matching element (predicate returns true) also matches the predicate.\npub fn array_length_until<T, let N: u32, Env>(array: [T; N], predicate: fn[Env](T) -> bool) -> u32 {\n    let mut length = 0;\n    let mut stop = false;\n    for i in 0..N {\n        if predicate(array[i]) {\n            stop = true;\n        } else {\n            assert(\n                stop == false,\n                \"matching element found after already encountering a non-matching element\",\n            );\n            length += 1;\n        }\n    }\n    length\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to check if an array is padded with a given value from a given index.\npub fn array_padded_with<T, let N: u32>(array: [T; N], from_index: u32, padded_with: T) -> bool\nwhere\n    T: Eq,\n{\n    let mut is_valid = true;\n    let mut should_check = false;\n    for i in 0..N {\n        should_check |= i == from_index;\n        is_valid &= !should_check | (array[i] == padded_with);\n    }\n    is_valid\n}\n\n// ==================== subarray tests ====================\n\n#[test]\nfn test_subarray() {\n    assert_eq(subarray::<_, 5, 3>([10, 20, 30, 40, 50], 1), [20, 30, 40]);\n    assert_eq(subarray::<_, 5, 2>([10, 20, 30, 40, 50], 0), [10, 20]);\n    assert_eq(subarray::<_, 3, 0>([10, 20, 30], 2), []);\n    assert_eq(subarray::<_, 3, 1>([10, 20, 30], 2), [30]);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_offset_out_of_bounds() {\n    let _: [Field; 1] = subarray([10, 20, 30], 5);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_subarray_result_size_exceeds_available() {\n    let _: [Field; 3] = subarray([10, 20, 30, 40, 50], 3);\n}\n\n// ==================== array_length tests ====================\n\n#[test]\nfn test_array_length_empty_array() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    // This is why the arrays being passed-into `array_length` must already have been \"validated\"\n    // (dense lhs, empty rhs).\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n// ==================== validate_array_length_hint tests ====================\n\n#[test]\nfn test_validate_array_length_hint_valid() {\n    validate_array_length_hint([0, 0, 0], 0);\n    validate_array_length_hint([10, 20, 0], 2);\n    validate_array_length_hint([10, 20, 30], 3);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_claims_zero_when_not_empty() {\n    // Invalid: hint says length 0, but first element is not empty\n    validate_array_length_hint([10, 20, 30], 0);\n}\n\n#[test(should_fail_with = \"Expected array[length] to be empty\")]\nfn test_validate_array_length_hint_too_short() {\n    // Invalid: hint says length 1, but element at index 1 is not empty\n    validate_array_length_hint([10, 20, 0], 1);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_too_long() {\n    // Invalid: hint says length 2, but element at index 1 is empty\n    validate_array_length_hint([10, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"Expected claimed final element of array (array[length - 1]) to be nonempty\")]\nfn test_validate_array_length_hint_of_empty_too_long() {\n    // Invalid: hint says length 2, but element at index 1 is empty\n    validate_array_length_hint([0, 0, 0], 2);\n}\n\n#[test(should_fail_with = \"out of bounds\")]\nfn test_validate_array_length_hint_out_of_bounds() {\n    // Invalid: hint says length 4, but array only has 3 elements\n    validate_array_length_hint([10, 20, 30], 4);\n}\n\n// ==================== trimmed_array_length_hint tests ====================\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_trailing_empties() {\n    assert_eq(trimmed_array_length_hint([10, 20, 30, 0, 0]), 3);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_fully_empty() {\n    assert_eq(trimmed_array_length_hint([0, 0, 0, 0, 0]), 0);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_no_empties() {\n    assert_eq(trimmed_array_length_hint([10, 20, 30, 40, 50]), 5);\n}\n\n#[test]\nunconstrained fn test_trimmed_array_length_hint_with_gaps() {\n    // Unlike array_length, this trims from the right only, so gaps don't matter\n    assert_eq(trimmed_array_length_hint([10, 0, 30, 0, 0]), 3);\n}\n\n// ==================== array_length_until tests ====================\n\n#[test]\nfn test_array_length_until() {\n    let array = [11, 22, 33, 44, 55];\n    assert_eq(array_length_until(array, |x| x == 55), 4);\n    assert_eq(array_length_until(array, |x| x == 56), 5);\n    assert_eq(array_length_until(array, |x| x > 40), 3);\n    assert_eq(array_length_until(array, |x| x > 10), 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_non_consecutive_fails() {\n    let array = [1, 1, 0, 1, 0];\n    let _ = array_length_until(array, |x| x == 0);\n}\n\n#[test(should_fail_with = \"matching element found after already encountering a non-matching element\")]\nfn test_array_length_until_first_non_matching_fails() {\n    let array = [1, 0, 0, 0, 0];\n    let _ = array_length_until(array, |x| x == 1);\n}\n\n// ==================== check_permutation tests ====================\n\n#[test]\nfn test_check_permutation() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn test_check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn test_check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n// ==================== array_padded_with tests ====================\n\n#[test]\nfn test_array_padded_with() {\n    let array = [11, 22, 33, 44, 44];\n    assert_eq(array_padded_with(array, 0, 44), false);\n    assert_eq(array_padded_with(array, 1, 44), false);\n    assert_eq(array_padded_with(array, 2, 44), false);\n    assert_eq(array_padded_with(array, 3, 44), true);\n    assert_eq(array_padded_with(array, 4, 44), true);\n    assert_eq(array_padded_with(array, 4, 33), false);\n    assert_eq(array_padded_with(array, 5, 44), true); // Index out of bounds.\n    assert_eq(array_padded_with(array, 0, 11), false);\n}\n"
     },
     "446": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
@@ -2911,11 +2911,11 @@
     },
     "51": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
-      "source": "/**\n * @title ContractInstanceRegistry Contract\n * @notice Manages the registration and updating of contract instances\n * @dev This contract allows deploying new contract instances and updating their class IDs\n */\npub contract ContractInstanceRegistry {\n    use aztec::{\n        context::{PrivateContext, PublicContext},\n        hash::hash_args,\n        nullifier::utils::compute_nullifier_existence_request,\n        oracle::{avm, debug_log::debug_log_format, version::assert_compatible_oracle_version},\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, PartialAddress},\n            constants::{\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n            },\n            contract_class_id::ContractClassId,\n            point::validate_on_curve,\n            public_keys::PublicKeys,\n            traits::{Deserialize, Serialize, ToField},\n            utils::reader::Reader,\n        },\n        state_vars::{DelayedPublicMutable, Map, StateVariable},\n    };\n\n    #[abi(events)]\n    struct ContractInstancePublished {\n        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // We need to impl this separately because ts deserializes a point as two fields only.\n    // We had issues that:\n    // Notice how the 'is_infinite' field is deserialized as the next point.\n    // {\n    //     masterNullifierPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000012>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000034>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterIncomingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000056>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterOutgoingViewingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000078>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000000000>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // },\n    // masterTaggingPublicKey: Point {\n    //   x: Fr<0x0000000000000000000000000000000000000000000000000000000000000910>,\n    //   y: Fr<0x0000000000000000000000000000000000000000000000000000000000001112>,\n    //   isInfinite: false,\n    //   kind: 'point'\n    // }\n\n    impl ContractInstancePublished {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[abi(events)]\n    #[derive(Serialize)]\n    struct ContractInstanceUpdated {\n        CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        timestamp_of_change: u64,\n    }\n\n    struct Storage<Context> {\n        updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn publish_for_public_execution(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // body, I have removed that check.\n        assert_compatible_oracle_version();\n\n        let serialized_params: [Field; 16] = [\n            salt,\n            contract_class_id.to_field(),\n            initialization_hash,\n        ]\n            .concat(public_keys.serialize())\n            .concat([universal_deploy.to_field()]);\n\n        let args_hash: Field = hash_args(serialized_params);\n        let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        // Verify that the contract class is registered\n        let nullifier_existence_request = compute_nullifier_existence_request(\n            contract_class_id.to_field(),\n            CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n        );\n        context.assert_nullifier_exists(nullifier_existence_request);\n\n        // Determine the deployer based on universal_deploy flag\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.maybe_msg_sender().unwrap()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        // Note: Out of all the public keys, only the Ivpk_m is checked to be on the curve\n        // (implicitly as part of the `add` operation of deriving the address). This at least\n        // protects the AVM against DoS attacks.\n        // For thoroughness, we also ensure the other points are on the curve:\n        validate_on_curve(public_keys.npk_m.inner);\n        validate_on_curve(public_keys.ovpk_m.inner);\n        validate_on_curve(public_keys.tpk_m.inner);\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit the address as a nullifier:\n        // - to demonstrate that this contract instance hasn't been published before\n        // - to enable apps to read that this contract instance has been published.\n        context.push_nullifier(address.to_field());\n\n        // Emit the deployment event\n        let event = ContractInstancePublished {\n            CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n        let payload = event.serialize_non_standard();\n        debug_log_format(\"ContractInstancePublished: {}\", payload);\n        let padded_log = payload.concat([0; 3]);\n        let length = payload.len();\n        context.emit_private_log(padded_log, length);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn update(new_contract_class_id: ContractClassId) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let address = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n        // information through registration, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(\n                new_contract_class_id.to_field(),\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n            ),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update = storage\n            .updated_class_ids\n            .at(address)\n            .schedule_and_return_value_change(new_contract_class_id);\n        let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            timestamp_of_change,\n        };\n        context.emit_public_log(event);\n    }\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn set_update_delay(new_update_delay: u64) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let msg_sender = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n    }\n\n    /**\n     * Gets the current update delay for the caller's contract instance.\n     *\n     * @return The current update delay value\n     */\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn get_update_delay() -> pub u64 {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n        // MACRO CODE END\n\n        storage.updated_class_ids.at(avm::sender()).get_current_delay()\n    }\n\n    // // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    // Function selectors computed at comptime from function signatures\n    global UPDATE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n    global SET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n    global GET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == UPDATE_SELECTOR {\n            let input_calldata: [Field; 1] =\n                avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: ContractClassId =\n                <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n            update(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == SET_UPDATE_DELAY_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n            set_update_delay(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == GET_UPDATE_DELAY_SELECTOR {\n            let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n            avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    // Parameter structs for ABI\n    pub struct publish_for_public_execution_parameters {\n        pub _salt: Field,\n        pub _contract_class_id: ContractClassId,\n        pub _initialization_hash: Field,\n        pub _public_keys: PublicKeys,\n        pub _universal_deploy: bool,\n    }\n\n    pub struct update_parameters {\n        pub _new_contract_class_id: ContractClassId,\n    }\n\n    pub struct set_update_delay_parameters {\n        pub _new_update_delay: u64,\n    }\n\n    pub struct get_update_delay_parameters {}\n\n    // ABI structs\n    #[abi(functions)]\n    pub struct publish_for_public_execution_abi {\n        parameters: publish_for_public_execution_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct update_abi {\n        parameters: update_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct set_update_delay_abi {\n        parameters: set_update_delay_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct get_update_delay_abi {\n        parameters: get_update_delay_parameters,\n        return_type: u64,\n    }\n}\n"
+      "source": "/// Protocol contract responsible for deploying contract instances and managing contract upgrades.\n///\n/// In Aztec, contracts are split into *classes* (code, registered via ContractClassRegistry) and *instances*\n/// (deployments of a class at a unique address). This contract handles contract instance publishing and contract\n/// updates (updating instance to a new class).\npub contract ContractInstanceRegistry {\n    use aztec::{\n        context::{PrivateContext, PublicContext},\n        hash::hash_args,\n        nullifier::utils::compute_nullifier_existence_request,\n        oracle::{avm, logging::debug_log_format, version::assert_compatible_oracle_version},\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, PartialAddress},\n            constants::{\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n            },\n            contract_class_id::ContractClassId,\n            public_keys::PublicKeys,\n            traits::{Deserialize, Serialize, ToField},\n            utils::reader::Reader,\n        },\n        state_vars::{DelayedPublicMutable, Map, StateVariable},\n    };\n\n    #[abi(events)]\n    struct ContractInstancePublished {\n        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // Custom serialization is required because we don't want to waste one field for the `is_infinite` flag of public\n    // key points (public key points will never be the infinity point).\n    impl ContractInstancePublished {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[abi(events)]\n    #[derive(Serialize)]\n    struct ContractInstanceUpdated {\n        CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        timestamp_of_change: u64,\n    }\n\n    struct Storage<Context> {\n        /// Map from contract instance address to a `DelayedPublicMutable` holding the updated contract class ID.\n        updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    /// Publishes a new contract instance.\n    ///\n    /// The caller provides deployment parameters (salt, class_id, init_hash, public_keys, universal_deploy).\n    /// The `universal_deploy` flag controls whether the deployer address is bound into the contract address:\n    /// when true, deployer is zero (anyone can deploy the same instance); when false, deployer is the caller.\n    ///\n    /// This function:\n    /// 1. Verifies the contract class is registered in ContractClassRegistry (nullifier existence check).\n    /// 2. Validates public key points are on the Grumpkin curve (preventing AVM DoS via invalid points).\n    /// 3. Computes the deterministic contract address from the deployment parameters.\n    /// 4. Emits the address as a nullifier (proving publication preventing duplicate deployment)\n    ///    --> this address nullifier is then checked to exist by the AVM upon public function execution (if it doesn't\n    ///        exist AVM reverts)\n    /// 5. Broadcasts a `ContractInstancePublished` event so nodes can reconstruct the instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn publish_for_public_execution(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // body, I have removed that check.\n        assert_compatible_oracle_version();\n\n        let serialized_params: [Field; 16] = [\n            salt,\n            contract_class_id.to_field(),\n            initialization_hash,\n        ]\n            .concat(public_keys.serialize())\n            .concat([universal_deploy.to_field()]);\n\n        let args_hash: Field = hash_args(serialized_params);\n        let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        // Verify the contract class is registered by checking for its nullifier at the ContractClassRegistry address.\n        let nullifier_existence_request = compute_nullifier_existence_request(\n            contract_class_id.to_field(),\n            CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n        );\n        context.assert_nullifier_exists(nullifier_existence_request);\n\n        // For universal deployments, deployer is zero so the resulting address is the same regardless of who initiates\n        // deployment.\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.maybe_msg_sender().unwrap()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        // Validate public key points lie on the Grumpkin curve to prevent AVM DoS attacks.\n        public_keys.validate_on_curve();\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit address as nullifier: prevents duplicate deployment and proves publication.\n        context.push_nullifier(address.to_field());\n\n        // Broadcast deployment event. Uses non-standard serialization (2 fields per point,\n        // omitting is_infinite) for TypeScript SDK compatibility.\n        let event = ContractInstancePublished {\n            CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n        let payload = event.serialize_non_standard();\n        debug_log_format(\"ContractInstancePublished: {}\", payload);\n        // We pad the payload with [0] to match the length required by emit_private_log. Since the log is not\n        // encrypted, padding with zero rather than a random value is acceptable (we don't care about privacy here).\n        let padded_log = payload.concat([0]);\n        let length = payload.len();\n        context.emit_private_log(padded_log, length);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Schedules an upgrade of the calling contract instance to a new contract class.\n    ///\n    /// The change is time-delayed via `DelayedPublicMutable` and only takes effect after the configured\n    /// delay has elapsed. Only the contract instance itself can call this function (msg.sender == address).\n    ///\n    /// This function:\n    /// 1. Verifies msg.sender is a deployed contract (its address nullifier exists).\n    /// 2. Verifies the new class is registered in ContractClassRegistry.\n    /// 3. Schedules the class ID change and emits a `ContractInstanceUpdated` event.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn update(new_contract_class_id: ContractClassId) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let address = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n        // information through registration, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(\n                new_contract_class_id.to_field(),\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n            ),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update = storage\n            .updated_class_ids\n            .at(address)\n            .schedule_and_return_value_change(new_contract_class_id);\n        let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            timestamp_of_change,\n        };\n        context.emit_public_log(event);\n    }\n\n    /// Schedules a change to the upgrade delay for the calling contract instance. The delay change is\n    /// itself delayed (preventing atomically reducing delay + scheduling an instant upgrade). The new\n    /// delay must be at least `MINIMUM_UPDATE_DELAY`.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn set_update_delay(new_update_delay: u64) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let msg_sender = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n    }\n\n    /// Returns the current update delay for the calling contract instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn get_update_delay() -> pub u64 {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n        // MACRO CODE END\n\n        storage.updated_class_ids.at(avm::sender()).get_current_delay()\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    global UPDATE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n    global SET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n    global GET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == UPDATE_SELECTOR {\n            let input_calldata: [Field; 1] =\n                avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: ContractClassId =\n                <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n            update(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == SET_UPDATE_DELAY_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n            set_update_delay(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == GET_UPDATE_DELAY_SELECTOR {\n            let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n            avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    pub struct publish_for_public_execution_parameters {\n        pub _salt: Field,\n        pub _contract_class_id: ContractClassId,\n        pub _initialization_hash: Field,\n        pub _public_keys: PublicKeys,\n        pub _universal_deploy: bool,\n    }\n\n    pub struct update_parameters {\n        pub _new_contract_class_id: ContractClassId,\n    }\n\n    pub struct set_update_delay_parameters {\n        pub _new_update_delay: u64,\n    }\n\n    pub struct get_update_delay_parameters {}\n\n    #[abi(functions)]\n    pub struct publish_for_public_execution_abi {\n        parameters: publish_for_public_execution_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct update_abi {\n        parameters: update_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct set_update_delay_abi {\n        parameters: set_update_delay_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct get_update_delay_abi {\n        parameters: get_update_delay_parameters,\n        return_type: u64,\n    }\n}\n"
     },
     "58": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, NullifierExistenceRequest, ReturnsHash},\n    hash::hash_args,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            is_side_effect_counter_revertible_oracle_wrapper, notify_enqueued_public_function_call,\n            notify_set_min_revertible_side_effect_counter,\n        },\n        execution_cache,\n        logs::notify_created_contract_class_log,\n        nullifiers::notify_created_nullifier,\n    },\n};\nuse crate::protocol::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, MAX_CONTRACT_CLASS_LOGS_PER_CALL,\n        MAX_ENQUEUED_CALLS_PER_CALL, MAX_INCLUDE_BY_TIMESTAMP_DURATION, MAX_L2_TO_L1_MSGS_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        NULL_MSG_SENDER_CONTRACT_ADDRESS, PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    hash::poseidon2_hash,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    side_effect::{Counted, scoped::Scoped},\n    traits::Empty,\n    utils::arrays::{ClaimedLengthArray, trimmed_array_length_hint},\n};\n\n/// Minimal PrivateContext for protocol contracts going to audit.\n/// Contains only the methods actually used by: fee_juice, auth_registry, contract_class_registry, contract_instance_registry\n#[derive(Eq)]\npub struct PrivateContext {\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 include_by_timestamp: u64,\n\n    pub nullifier_read_requests: BoundedVec<Scoped<Counted<Field>>, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n\n    pub nullifiers: BoundedVec<Counted<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<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub anchor_block_header: BlockHeader,\n\n    pub private_logs: BoundedVec<Counted<PrivateLogData>, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    pub expected_non_revertible_side_effect_counter: u32,\n    pub expected_revertible_side_effect_counter: u32,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        let max_allowed_include_by_timestamp = inputs.anchor_block_header.global_variables.timestamp\n            + MAX_INCLUDE_BY_TIMESTAMP_DURATION;\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            include_by_timestamp: max_allowed_include_by_timestamp,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            anchor_block_header: inputs.anchor_block_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            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call (similar to msg.sender in Solidity).\n    pub fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.inputs.call_context.msg_sender;\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the contract address of the current function being executed.\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    /// Returns the protocol version.\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    /// Returns the gas settings for the current transaction.\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    /// Returns the function selector of the currently executing function.\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    /// Returns the anchor block header.\n    pub fn get_anchor_block_header(self) -> BlockHeader {\n        self.anchor_block_header\n    }\n\n    /// Sets the hash of the return values for this private function.\n    pub fn set_return_hash<let N: u32>(&mut self, serialized_return_values: [Field; N]) {\n        let return_hash = hash_args(serialized_return_values);\n        self.return_hash = return_hash;\n        execution_cache::store(serialized_return_values, return_hash);\n    }\n\n    /// Builds the PrivateCircuitPublicInputs for this private function.\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            include_by_timestamp: self.include_by_timestamp,\n            note_hash_read_requests: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifier_read_requests: ClaimedLengthArray::from_bounded_vec(\n                self.nullifier_read_requests,\n            ),\n            key_validation_requests_and_generators: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            note_hashes: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifiers: ClaimedLengthArray::from_bounded_vec(self.nullifiers),\n            private_call_requests: ClaimedLengthArray::from_bounded_vec(self.private_call_requests),\n            public_call_requests: ClaimedLengthArray::from_bounded_vec(self.public_call_requests),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: ClaimedLengthArray::from_bounded_vec(self.l2_to_l1_msgs),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: ClaimedLengthArray::from_bounded_vec(self.private_logs),\n            contract_class_logs_hashes: ClaimedLengthArray::from_bounded_vec(\n                self.contract_class_logs_hashes,\n            ),\n            anchor_block_header: self.anchor_block_header,\n            tx_context: self.inputs.tx_context,\n            expected_non_revertible_side_effect_counter: self\n                .expected_non_revertible_side_effect_counter,\n            expected_revertible_side_effect_counter: self.expected_revertible_side_effect_counter,\n        }\n    }\n\n    /// Declares the end of the \"setup phase\" of this tx. Used by fee_juice.\n    pub fn end_setup(&mut self) {\n        self.side_effect_counter += 1;\n        self.min_revertible_side_effect_counter = self.next_counter();\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    pub fn in_revertible_phase(&mut self) -> bool {\n        let current_counter = self.side_effect_counter;\n\n        // Safety: Kernel will validate that the claim is correct by validating the expected counters.\n        let is_revertible =\n            unsafe { is_side_effect_counter_revertible_oracle_wrapper(current_counter) };\n\n        if is_revertible {\n            if (self.expected_revertible_side_effect_counter == 0)\n                | (current_counter < self.expected_revertible_side_effect_counter) {\n                self.expected_revertible_side_effect_counter = current_counter;\n            }\n        } else if current_counter > self.expected_non_revertible_side_effect_counter {\n            self.expected_non_revertible_side_effect_counter = current_counter;\n        }\n\n        is_revertible\n    }\n\n    /// Sets a deadline for when this transaction must be included in a block.\n    pub fn set_include_by_timestamp(&mut self, include_by_timestamp: u64) {\n        self.include_by_timestamp = std::cmp::min(self.include_by_timestamp, include_by_timestamp);\n    }\n\n    /// Pushes a new nullifier. Used by class_registry and instance_registry.\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(Nullifier { value: nullifier, note_hash: 0 }.count(self.next_counter()));\n    }\n\n    /// Asserts that a nullifier has been emitted. Used by instance_registry.\n    pub fn assert_nullifier_exists(\n        &mut self,\n        nullifier_existence_request: NullifierExistenceRequest,\n    ) {\n        let nullifier = nullifier_existence_request.nullifier();\n        let contract_address =\n            nullifier_existence_request.maybe_contract_address().unwrap_or(AztecAddress::zero());\n\n        let request = Scoped::new(\n            Counted::new(nullifier, self.next_counter()),\n            contract_address,\n        );\n\n        self.nullifier_read_requests.push(request);\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2). Used by fee_juice.\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        let nullifier = process_l1_to_l2_message(\n            self.anchor_block_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\n    /// Emits a private log. Used by instance_registry.\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0 }\n            .count(counter);\n        self.private_logs.push(private_log);\n    }\n\n    /// Emits a contract class log. Used by class_registry.\n    pub fn emit_contract_class_log<let N: u32>(&mut self, log: [Field; N]) {\n        let contract_address = self.this_address();\n        let counter = self.next_counter();\n\n        let log_to_emit: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS] =\n            log.concat([0; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - N]);\n        // Safety: The below length is constrained in the base rollup, which will make sure that all the fields beyond\n        // length are zero. However, it won't be able to check that we didn't add extra padding (trailing zeroes) or\n        // that we cut trailing zeroes from the end.\n        let length = unsafe { trimmed_array_length_hint(log_to_emit) };\n        // We hash the entire padded log to ensure a user cannot pass a shorter length and so emit incorrect shorter\n        // bytecode.\n        let log_hash = poseidon2_hash(log_to_emit);\n        // Safety: the below only exists to broadcast the raw log, so we can provide it to the base rollup later to be\n        // constrained.\n        unsafe {\n            notify_created_contract_class_log(contract_address, log_to_emit, length, counter);\n        }\n\n        self.contract_class_logs_hashes.push(LogHash { value: log_hash, length: length }.count(\n            counter,\n        ));\n    }\n\n    /// Makes a read-only call to a private function. Used by auth_registry for authwit.\n    pub fn static_call_private_function<let ArgsCount: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ArgsCount],\n    ) -> ReturnsHash {\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    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.\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        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    /// Enqueues a call to a public function with a calldata hash. Used by fee_juice and auth_registry.\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n        hide_msg_sender: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let msg_sender = if hide_msg_sender {\n            NULL_MSG_SENDER_CONTRACT_ADDRESS\n        } else {\n            self.this_address()\n        };\n\n        let call_request =\n            PublicCallRequest { msg_sender, contract_address, is_static_call, calldata_hash };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\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            include_by_timestamp: 0,\n            nullifier_read_requests: 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            anchor_block_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, NullifierExistenceRequest, ReturnsHash},\n    hash::hash_args,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            is_side_effect_counter_revertible_oracle_wrapper, notify_enqueued_public_function_call,\n            notify_set_min_revertible_side_effect_counter,\n        },\n        execution_cache,\n        logs::notify_created_contract_class_log,\n        nullifiers::notify_created_nullifier,\n    },\n};\nuse crate::protocol::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, MAX_CONTRACT_CLASS_LOGS_PER_CALL,\n        MAX_ENQUEUED_CALLS_PER_CALL, MAX_TX_LIFETIME, MAX_L2_TO_L1_MSGS_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        NULL_MSG_SENDER_CONTRACT_ADDRESS, PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    hash::poseidon2_hash,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    side_effect::{Counted, scoped::Scoped},\n    traits::Empty,\n    utils::arrays::{ClaimedLengthArray, trimmed_array_length_hint},\n};\n\n/// Minimal PrivateContext for protocol contracts going to audit.\n/// Contains only the methods actually used by: fee_juice, auth_registry, contract_class_registry, contract_instance_registry\n#[derive(Eq)]\npub struct PrivateContext {\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 expiration_timestamp: u64,\n\n    pub nullifier_read_requests: BoundedVec<Scoped<Counted<Field>>, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n\n    pub nullifiers: BoundedVec<Counted<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<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub anchor_block_header: BlockHeader,\n\n    pub private_logs: BoundedVec<Counted<PrivateLogData>, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    pub expected_non_revertible_side_effect_counter: u32,\n    pub expected_revertible_side_effect_counter: u32,\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            expiration_timestamp: inputs.anchor_block_header.global_variables.timestamp\n            + MAX_TX_LIFETIME,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            anchor_block_header: inputs.anchor_block_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            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call (similar to msg.sender in Solidity).\n    pub fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.inputs.call_context.msg_sender;\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the contract address of the current function being executed.\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    /// Returns the protocol version.\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    /// Returns the gas settings for the current transaction.\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    /// Returns the function selector of the currently executing function.\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    /// Returns the anchor block header.\n    pub fn get_anchor_block_header(self) -> BlockHeader {\n        self.anchor_block_header\n    }\n\n    /// Sets the hash of the return values for this private function.\n    pub fn set_return_hash<let N: u32>(&mut self, serialized_return_values: [Field; N]) {\n        let return_hash = hash_args(serialized_return_values);\n        self.return_hash = return_hash;\n        execution_cache::store(serialized_return_values, return_hash);\n    }\n\n    /// Builds the PrivateCircuitPublicInputs for this private function.\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            expiration_timestamp: self.expiration_timestamp,\n            note_hash_read_requests: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifier_read_requests: ClaimedLengthArray::from_bounded_vec(\n                self.nullifier_read_requests,\n            ),\n            key_validation_requests_and_separators: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            note_hashes: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifiers: ClaimedLengthArray::from_bounded_vec(self.nullifiers),\n            private_call_requests: ClaimedLengthArray::from_bounded_vec(self.private_call_requests),\n            public_call_requests: ClaimedLengthArray::from_bounded_vec(self.public_call_requests),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: ClaimedLengthArray::from_bounded_vec(self.l2_to_l1_msgs),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: ClaimedLengthArray::from_bounded_vec(self.private_logs),\n            contract_class_logs_hashes: ClaimedLengthArray::from_bounded_vec(\n                self.contract_class_logs_hashes,\n            ),\n            anchor_block_header: self.anchor_block_header,\n            tx_context: self.inputs.tx_context,\n            expected_non_revertible_side_effect_counter: self\n                .expected_non_revertible_side_effect_counter,\n            expected_revertible_side_effect_counter: self.expected_revertible_side_effect_counter,\n        }\n    }\n\n    /// Declares the end of the \"setup phase\" of this tx. Used by fee_juice.\n    pub fn end_setup(&mut self) {\n        self.side_effect_counter += 1;\n        self.min_revertible_side_effect_counter = self.next_counter();\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    pub fn in_revertible_phase(&mut self) -> bool {\n        let current_counter = self.side_effect_counter;\n\n        // Safety: Kernel will validate that the claim is correct by validating the expected counters.\n        let is_revertible =\n            unsafe { is_side_effect_counter_revertible_oracle_wrapper(current_counter) };\n\n        if is_revertible {\n            if (self.expected_revertible_side_effect_counter == 0)\n                | (current_counter < self.expected_revertible_side_effect_counter) {\n                self.expected_revertible_side_effect_counter = current_counter;\n            }\n        } else if current_counter > self.expected_non_revertible_side_effect_counter {\n            self.expected_non_revertible_side_effect_counter = current_counter;\n        }\n\n        is_revertible\n    }\n\n    /// Sets a deadline for when this transaction must be included in a block.\n    pub fn set_expiration_timestamp(&mut self, expiration_timestamp: u64) {\n        self.expiration_timestamp = std::cmp::min(self.expiration_timestamp, expiration_timestamp);\n    }\n\n    /// Pushes a new nullifier. Used by class_registry and instance_registry.\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(Nullifier { value: nullifier, note_hash: 0 }.count(self.next_counter()));\n    }\n\n    /// Asserts that a nullifier has been emitted. Used by instance_registry.\n    pub fn assert_nullifier_exists(\n        &mut self,\n        nullifier_existence_request: NullifierExistenceRequest,\n    ) {\n        let nullifier = nullifier_existence_request.nullifier();\n        let contract_address =\n            nullifier_existence_request.maybe_contract_address().unwrap_or(AztecAddress::zero());\n\n        let request = Scoped::new(\n            Counted::new(nullifier, self.next_counter()),\n            contract_address,\n        );\n\n        self.nullifier_read_requests.push(request);\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2). Used by fee_juice.\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        let nullifier = process_l1_to_l2_message(\n            self.anchor_block_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\n    /// Emits a private log. Used by instance_registry.\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0 }\n            .count(counter);\n        self.private_logs.push(private_log);\n    }\n\n    /// Emits a contract class log. Used by class_registry.\n    pub fn emit_contract_class_log<let N: u32>(&mut self, log: [Field; N]) {\n        let contract_address = self.this_address();\n        let counter = self.next_counter();\n\n        let log_to_emit: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS] =\n            log.concat([0; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - N]);\n        // Safety: The below length is constrained in the base rollup, which will make sure that all the fields beyond\n        // length are zero. However, it won't be able to check that we didn't add extra padding (trailing zeroes) or\n        // that we cut trailing zeroes from the end.\n        let length = unsafe { trimmed_array_length_hint(log_to_emit) };\n        // We hash the entire padded log to ensure a user cannot pass a shorter length and so emit incorrect shorter\n        // bytecode.\n        let log_hash = poseidon2_hash(log_to_emit);\n        // Safety: the below only exists to broadcast the raw log, so we can provide it to the base rollup later to be\n        // constrained.\n        unsafe {\n            notify_created_contract_class_log(contract_address, log_to_emit, length, counter);\n        }\n\n        self.contract_class_logs_hashes.push(LogHash { value: log_hash, length: length }.count(\n            counter,\n        ));\n    }\n\n    /// Makes a read-only call to a private function. Used by auth_registry for authwit.\n    pub fn static_call_private_function<let ArgsCount: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ArgsCount],\n    ) -> ReturnsHash {\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    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.\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        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    /// Enqueues a call to a public function with a calldata hash. Used by fee_juice and auth_registry.\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n        hide_msg_sender: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let msg_sender = if hide_msg_sender {\n            NULL_MSG_SENDER_CONTRACT_ADDRESS\n        } else {\n            self.this_address()\n        };\n\n        let call_request =\n            PublicCallRequest { msg_sender, contract_address, is_static_call, calldata_hash };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\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            expiration_timestamp: 0,\n            nullifier_read_requests: 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            anchor_block_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n}\n"
     },
     "59": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/public_context.nr",
@@ -2923,7 +2923,7 @@
     },
     "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/hash.nr",
-      "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE,\n        DOM_SEP__PUBLIC_CALLDATA, DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([separator, ...bytecode])`\n/// where bytecode omits the length prefix present in `packed_bytecode`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with separator instead\n/// of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 =\n        (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Replace it with separator before hashing.\n    let separator = DOM_SEP__PUBLIC_BYTECODE.to_field();\n    packed_public_bytecode[0] = separator;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the separator.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n"
+      "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE,\n        DOM_SEP__PUBLIC_CALLDATA, DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the separator.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n"
     },
     "71": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/nullifier/utils.nr",
@@ -2931,7 +2931,7 @@
     },
     "72": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
-      "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> u1 {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> u1 {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeMinFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeMinFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> u1 {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
+      "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> u1 {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> u1 {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeMinFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeMinFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> u1 {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(avmOpcodeEmitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
     "81": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
@@ -2939,7 +2939,7 @@
     },
     "83": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/delayed_public_mutable.nr",
-      "source": "use crate::protocol::{\n    delayed_public_mutable::{\n        delayed_public_mutable_values::{unpack_delay_change, unpack_value_change},\n        DelayedPublicMutableValues,\n        ScheduledDelayChange,\n        ScheduledValueChange,\n    },\n    traits::Packable,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext, UtilityContext},\n    state_vars::StateVariable,\n    utils::WithHash,\n};\n\n/// Public mutable values with private read access.\npub struct DelayedPublicMutable<T, let InitialDelay: u64, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n\n// DelayedPublicMutable<T> stores a value of type T that is:\n//  - publicly known (i.e. unencrypted)\n//  - mutable in public\n//  - readable in private with no contention\nimpl<T, let InitialDelay: u64, Context, let M: u32> StateVariable<M + 1, Context> for DelayedPublicMutable<T, InitialDelay, Context>\nwhere\n    DelayedPublicMutableValues<T, InitialDelay>: Packable<N = M>,\n{\n    fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, PublicContext>\nwhere\n    T: Eq,\n{\n\n    pub fn schedule_value_change(self, new_value: T)\n    where\n        T: Packable,\n    {\n        let _value_change = self.schedule_and_return_value_change(new_value);\n    }\n\n    pub fn schedule_and_return_value_change(self, new_value: T) -> ScheduledValueChange<T>\n    where\n        T: Packable,\n    {\n        let mut value_change = self.read_value_change();\n        let delay_change = self.read_delay_change();\n\n        let current_timestamp = self.context.timestamp();\n        let current_delay = delay_change.get_current(current_timestamp);\n\n        // TODO: make this configurable https://github.com/AztecProtocol/aztec-packages/issues/5501\n        let timestamp_of_change = current_timestamp + current_delay;\n        value_change.schedule_change(\n            new_value,\n            current_timestamp,\n            current_delay,\n            timestamp_of_change,\n        );\n\n        self.write(value_change, delay_change);\n\n        value_change\n    }\n\n    pub fn schedule_delay_change(self, new_delay: u64)\n    where\n        T: Packable,\n    {\n        let mut delay_change = self.read_delay_change();\n\n        let current_timestamp = self.context.timestamp();\n\n        delay_change.schedule_change(new_delay, current_timestamp);\n\n        self.write(self.read_value_change(), delay_change);\n    }\n\n    pub fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        let current_timestamp = self.context.timestamp();\n        let value_change = self.read_value_change();\n\n        value_change.get_current_at(current_timestamp)\n    }\n\n    pub fn get_current_delay(self) -> u64\n    where\n        T: Packable,\n    {\n        let current_timestamp = self.context.timestamp();\n        self.read_delay_change().get_current(current_timestamp)\n    }\n\n    pub fn get_scheduled_value(self) -> (T, u64)\n    where\n        T: Packable,\n    {\n        self.read_value_change().get_scheduled()\n    }\n\n    pub fn get_scheduled_delay(self) -> (u64, u64)\n    where\n        T: Packable,\n    {\n        self.read_delay_change().get_scheduled()\n    }\n\n    fn read_value_change(self) -> ScheduledValueChange<T>\n    where\n        T: Packable,\n    {\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_value_change::<T, <T as Packable>::N>(packed)\n    }\n\n    fn read_delay_change(self) -> ScheduledDelayChange<InitialDelay>\n    where\n        T: Packable,\n    {\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_delay_change::<InitialDelay>(packed)\n    }\n\n    fn write(\n        self,\n        value_change: ScheduledValueChange<T>,\n        delay_change: ScheduledDelayChange<InitialDelay>,\n    )\n    where\n        T: Packable,\n    {\n        let values = WithHash::new(DelayedPublicMutableValues::new(value_change, delay_change));\n\n        self.context.storage_write(self.storage_slot, values);\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PrivateContext>\nwhere\n    T: Eq,\n{\n    pub fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        // When reading the current value in private we construct a historical state proof for the public value.\n        let (value_change, delay_change, anchor_timestamp) = self.anchor_read_from_public_storage();\n\n        let effective_minimum_delay = delay_change.get_effective_minimum_delay_at(anchor_timestamp);\n        let time_horizon = value_change.get_time_horizon(anchor_timestamp, effective_minimum_delay);\n\n        // We prevent this transaction from being included in any timestamp after the time horizon.\n        self.context.set_include_by_timestamp(time_horizon);\n\n        value_change.get_current_at(anchor_timestamp)\n    }\n\n    fn anchor_read_from_public_storage(\n        self,\n    ) -> (ScheduledValueChange<T>, ScheduledDelayChange<InitialDelay>, u64)\n    where\n        T: Packable,\n    {\n        let header = self.context.get_anchor_block_header();\n        let address = self.context.this_address();\n\n        let anchor_timestamp = header.global_variables.timestamp;\n\n        let values: DelayedPublicMutableValues<T, InitialDelay> =\n            WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n        (values.svc, values.sdc, anchor_timestamp)\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, UtilityContext>\nwhere\n    T: Eq,\n{\n    pub unconstrained fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        let dpmv: DelayedPublicMutableValues<T, InitialDelay> =\n            WithHash::utility_public_storage_read(self.context, self.storage_slot);\n\n        let current_timestamp = self.context.timestamp();\n        dpmv.svc.get_current_at(current_timestamp)\n    }\n}\n"
+      "source": "use crate::protocol::{\n    delayed_public_mutable::{\n        delayed_public_mutable_values::{unpack_delay_change, unpack_value_change},\n        DelayedPublicMutableValues,\n        ScheduledDelayChange,\n        ScheduledValueChange,\n    },\n    traits::Packable,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext, UtilityContext},\n    state_vars::StateVariable,\n    utils::WithHash,\n};\n\n/// Public mutable values with private read access.\npub struct DelayedPublicMutable<T, let InitialDelay: u64, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n\n// DelayedPublicMutable<T> stores a value of type T that is:\n//  - publicly known (i.e. unencrypted)\n//  - mutable in public\n//  - readable in private with no contention\nimpl<T, let InitialDelay: u64, Context, let M: u32> StateVariable<M + 1, Context> for DelayedPublicMutable<T, InitialDelay, Context>\nwhere\n    DelayedPublicMutableValues<T, InitialDelay>: Packable<N = M>,\n{\n    fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, PublicContext>\nwhere\n    T: Eq,\n{\n\n    pub fn schedule_value_change(self, new_value: T)\n    where\n        T: Packable,\n    {\n        let _value_change = self.schedule_and_return_value_change(new_value);\n    }\n\n    pub fn schedule_and_return_value_change(self, new_value: T) -> ScheduledValueChange<T>\n    where\n        T: Packable,\n    {\n        let mut value_change = self.read_value_change();\n        let delay_change = self.read_delay_change();\n\n        let current_timestamp = self.context.timestamp();\n        let current_delay = delay_change.get_current(current_timestamp);\n\n        // TODO: make this configurable https://github.com/AztecProtocol/aztec-packages/issues/5501\n        let timestamp_of_change = current_timestamp + current_delay;\n        value_change.schedule_change(\n            new_value,\n            current_timestamp,\n            current_delay,\n            timestamp_of_change,\n        );\n\n        self.write(value_change, delay_change);\n\n        value_change\n    }\n\n    pub fn schedule_delay_change(self, new_delay: u64)\n    where\n        T: Packable,\n    {\n        let mut delay_change = self.read_delay_change();\n\n        let current_timestamp = self.context.timestamp();\n\n        delay_change.schedule_change(new_delay, current_timestamp);\n\n        self.write(self.read_value_change(), delay_change);\n    }\n\n    pub fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        let current_timestamp = self.context.timestamp();\n        let value_change = self.read_value_change();\n\n        value_change.get_current_at(current_timestamp)\n    }\n\n    pub fn get_current_delay(self) -> u64\n    where\n        T: Packable,\n    {\n        let current_timestamp = self.context.timestamp();\n        self.read_delay_change().get_current(current_timestamp)\n    }\n\n    pub fn get_scheduled_value(self) -> (T, u64)\n    where\n        T: Packable,\n    {\n        self.read_value_change().get_scheduled()\n    }\n\n    pub fn get_scheduled_delay(self) -> (u64, u64)\n    where\n        T: Packable,\n    {\n        self.read_delay_change().get_scheduled()\n    }\n\n    fn read_value_change(self) -> ScheduledValueChange<T>\n    where\n        T: Packable,\n    {\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_value_change::<T, <T as Packable>::N>(packed)\n    }\n\n    fn read_delay_change(self) -> ScheduledDelayChange<InitialDelay>\n    where\n        T: Packable,\n    {\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_delay_change::<InitialDelay>(packed)\n    }\n\n    fn write(\n        self,\n        value_change: ScheduledValueChange<T>,\n        delay_change: ScheduledDelayChange<InitialDelay>,\n    )\n    where\n        T: Packable,\n    {\n        let values = WithHash::new(DelayedPublicMutableValues::new(value_change, delay_change));\n\n        self.context.storage_write(self.storage_slot, values);\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PrivateContext>\nwhere\n    T: Eq,\n{\n    pub fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        // When reading the current value in private we construct a historical state proof for the public value.\n        let (value_change, delay_change, anchor_timestamp) = self.anchor_read_from_public_storage();\n\n        let effective_minimum_delay = delay_change.get_effective_minimum_delay_at(anchor_timestamp);\n        let time_horizon = value_change.get_time_horizon(anchor_timestamp, effective_minimum_delay);\n\n        // We prevent this transaction from being included in any timestamp after the time horizon.\n        self.context.set_expiration_timestamp(time_horizon);\n\n        value_change.get_current_at(anchor_timestamp)\n    }\n\n    fn anchor_read_from_public_storage(\n        self,\n    ) -> (ScheduledValueChange<T>, ScheduledDelayChange<InitialDelay>, u64)\n    where\n        T: Packable,\n    {\n        let header = self.context.get_anchor_block_header();\n        let address = self.context.this_address();\n\n        let anchor_timestamp = header.global_variables.timestamp;\n\n        let values: DelayedPublicMutableValues<T, InitialDelay> =\n            WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n        (values.svc, values.sdc, anchor_timestamp)\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, UtilityContext>\nwhere\n    T: Eq,\n{\n    pub unconstrained fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        let dpmv: DelayedPublicMutableValues<T, InitialDelay> =\n            WithHash::utility_public_storage_read(self.context, self.storage_slot);\n\n        let current_timestamp = self.context.timestamp();\n        dpmv.svc.get_current_at(current_timestamp)\n    }\n}\n"
     },
     "84": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/map.nr",