@aztec/protocol-contracts 2.0.0-nightly.20250821 → 2.0.0-nightly.20250823

package/artifacts/AuthRegistry.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.11+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.11+nightly-2025-08-20-aztec",
   "name": "AuthRegistry",
   "functions": [
     {
@@ -2457,7 +2457,7 @@
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "set_reject_all",
@@ -3383,7 +3383,7 @@
     },
     "153": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
-      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
+      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
     "154": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
@@ -3543,7 +3543,7 @@
     },
     "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",
-      "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\n/// A hash that represents a private contract function call's return value. Call `get_preimage` to get the underlying\n/// value.\n///\n/// The kernels don't process the actual return values but instead their hashes, so it is up to contracts to populate\n/// oracles with the preimages of these hashes on return to make them available to their callers.\n///\n/// Public calls don't utilize this mechanism since the AVM does process the full return values.\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    /// Fetches the underlying return value from an oracle, constraining that it corresponds to the return data hash.\n    pub fn get_preimage<T>(self) -> T\n    where\n        T: Deserialize,\n    {\n        // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it. If `T`\n        // is `()`, then `preimage` must be an array of length 0 (since that is `()`'s deserialization length).\n        // `hash_args_array` handles empty arrays following the protocol rules (i.e. an empty args array is signaled\n        // with a zero hash), correctly constraining `self.hash`.\n        let preimage = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage), \"Preimage mismatch\");\n\n        Deserialize::deserialize(preimage)\n    }\n}\n\nmod test {\n    use crate::{\n        hash::hash_args_array,\n        oracle::execution_cache,\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use super::ReturnsHash;\n    use protocol_types::traits::Serialize;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn retrieves_preimage() {\n        let env = TestEnvironment::_new();\n        env.private_context(|_| {\n            let value = MockStruct::new(4, 7);\n            let serialized = value.serialize();\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn retrieves_empty_preimage() {\n        let env = TestEnvironment::_new();\n        env.private_context(|_| {\n            let value = ();\n            let serialized = [];\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test(should_fail_with = \"Preimage mismatch\")]\n    unconstrained fn rejects_bad_preimage() {\n        let value = MockStruct::new(4, 7);\n        let serialized = value.serialize();\n\n        let mut bad_serialized = serialized;\n        bad_serialized[0] += 1;\n\n        let hash = hash_args_array(serialized);\n\n        let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns(bad_serialized);\n        assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    }\n\n    // This test passes due to a Noir bug.\n    // #[test(should_fail_with=\"Preimage mismatch\")]\n    // unconstrained fn rejects_bad_empty_preimage() {\n    //     let value = ();\n    //     let serialized = [];\n\n    //     let hash = hash_args_array(serialized);\n\n    //     let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns([1]);\n    //     assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    // }\n}\n"
+      "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\n/// A hash that represents a private contract function call's return value. Call `get_preimage` to get the underlying\n/// value.\n///\n/// The kernels don't process the actual return values but instead their hashes, so it is up to contracts to populate\n/// oracles with the preimages of these hashes on return to make them available to their callers.\n///\n/// Public calls don't utilize this mechanism since the AVM does process the full return values.\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    /// Fetches the underlying return value from an oracle, constraining that it corresponds to the return data hash.\n    pub fn get_preimage<T>(self) -> T\n    where\n        T: Deserialize,\n    {\n        // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it. If `T`\n        // is `()`, then `preimage` must be an array of length 0 (since that is `()`'s deserialization length).\n        // `hash_args_array` handles empty arrays following the protocol rules (i.e. an empty args array is signaled\n        // with a zero hash), correctly constraining `self.hash`.\n        let preimage = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage), \"Preimage mismatch\");\n\n        Deserialize::deserialize(preimage)\n    }\n}\n\nmod test {\n    use crate::{\n        hash::hash_args_array,\n        oracle::execution_cache,\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use super::ReturnsHash;\n    use protocol_types::traits::Serialize;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn retrieves_preimage() {\n        let env = TestEnvironment::new();\n        env.private_context(|_| {\n            let value = MockStruct::new(4, 7);\n            let serialized = value.serialize();\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn retrieves_empty_preimage() {\n        let env = TestEnvironment::new();\n        env.private_context(|_| {\n            let value = ();\n            let serialized = [];\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test(should_fail_with = \"Preimage mismatch\")]\n    unconstrained fn rejects_bad_preimage() {\n        let value = MockStruct::new(4, 7);\n        let serialized = value.serialize();\n\n        let mut bad_serialized = serialized;\n        bad_serialized[0] += 1;\n\n        let hash = hash_args_array(serialized);\n\n        let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns(bad_serialized);\n        assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    }\n\n    // This test passes due to a Noir bug.\n    // #[test(should_fail_with=\"Preimage mismatch\")]\n    // unconstrained fn rejects_bad_empty_preimage() {\n    //     let value = ();\n    //     let serialized = [];\n\n    //     let hash = hash_args_array(serialized);\n\n    //     let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns([1]);\n    //     assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    // }\n}\n"
     },
     "71": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",

package/artifacts/ContractClassRegistry.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.11+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.11+nightly-2025-08-20-aztec",
   "name": "ContractClassRegistry",
   "functions": [
     {
@@ -1779,7 +1779,7 @@
       "bytecode": "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",
       "debug_symbols": "nZTbioMwEIbfJddeJDM59lWWpdg2LUJQSXVhKX33HVuNepGw9OpPMs7nnJgHu/jTeDs27bW7s8PXg51iE0JzO4buXA9N19Lr41mx5Xocovf0xDZ28urr6NuBHdoxhIr91GF8fXTv6/alQx3Jyivm2wspAa9N8NPpWa3ePO8KAGb2BnCQAIK7HUIUEGhwQaBTCWH2BMgTEMDOBEQucgTME4SSKGcEnaVNDBR7iCzVAkWqhVqLiah2CFWIA92CEJLLjxBS25SJUFlEKRHUqalo84mU5kLotRYOs3PhColwWDPhqDaTAf9nSFSJIY3IMQqpGC0WhNGbtiq5n/DSgFqKY5lQyzXPhSEKM2qcdSkQ50B+kIumQs4ILYTZt+WbrvW5ibsdw4DTDyoG4i3wFnyLnFxJ1ayalPoOZlY7zSOpm/Q5xRWb+hT8vL2uY3veLLPht18sy7rrY3f2lzH6KaiXjcL8Aw==",
       "brillig_names": [],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "broadcast_private_function",
@@ -3663,7 +3663,7 @@
         "trimmed_array_length_hint",
         "notify_created_contract_class_log"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "broadcast_utility_function",
@@ -5523,7 +5523,7 @@
         "trimmed_array_length_hint",
         "notify_created_contract_class_log"
       ],
-      "verification_key": "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"
+      "verification_key": "AAAAAAAAABIAAAAAAAAAEAAAAAAAAEJpH8GqgBrr+4SMBBPSRR4KG30QvaRQt5MYmvsYLQd9qM4ZqyKNOyjOau8pcfODpj5D6/ZSUd7bX05W1EbiPMqD6hqhSYD9TM1/MG+w7pGuPe+p2+lYUwBf2BcQzUWCN8OSFEndNh6DoWRyl3mFyFT4QlnYb8XpFgplRWnGbp2bkywG2L66DWkqTU6S2QvIpxR98rRRd6vaEGIACvJhwT8v/CtGWqqvgNzSE0VJ4+qI5OicTaNFVmQpCP3PdUCpYuZIByN3+db1b+O8Peveh+FfFsGDgW37aPhUHOen41+ZE6gX0AvB4E4V094Cdc+PI6eLVN2XWgl+LIulmstzhPsIaRPGZjbUeuv/NtEBrsLYxAnOujnZc65OeWuMG7il5sr1CwGSkAEgSYRMrke5/QM+I+01rwbLM2wMphHfueEibXQniRbFR/l3kp/i4mX3wOCpgs8wAeVgHtSosnzKLEs05y+0M4IkkvCMu6/nwGbmiHGTS9WhT8JJUWIzMhKxa2opCLFUon/AwusXS5V9XOK7mgwq91f09SFJVigyejeFCvQiqKqwFC76lCbUvzIesCHtEKe208Ag1iqSO1vTlhkdEx+UwAD9XMIkv9PnKVAsOKlg7QTtGCJq9+I0xQ+2jrMsCFFYbipA4EmuaGL29YSaf2bfOy4Wx90Wkg6Cp3acxZEwKrotexFj52vbevRZvgf2W/NWhRXQFgoHi/FccoAHlC619Di4BBB9FCrc7wtoNVG4AuK4JaYV5Xp4de1RgC6bCPivovl2XNfcrJvuuxEyCSxZYJTpQxOAHj0i288K9E8WcrzhwS9Sden73bab2VgKz0CB66wTuUn1WtbSSAvzHwEwwQ1KtB0R0sdPjyJwbvzbezJkHM1acYaOfNPXIyDkLx8By8pQV6gsMctX1LQSbGP6UV+RTMDMVJE9AtswcMAB+kqemFNv8lr9ZUhc1wsqwpY6j8Xw1sRoxeDxsv8a5BzavH0w7r3umf4j/H/g/ztGRHfo57rkT/WBa29/uyZlA9kDpPa1VtUy9UZ+1vddu40KrxWtUHMUKc6dUA+L7eAfgzJHCuZ1H66fvaGxUxX8Vj94Yb41mQJ3NQlAYrxSABJnSQHFdTb9Am+DFYXOdjSMzzMC1pi0NzxCf/GPL/rnK2y00Wu4RBIALfO7kVdXK05AymMJo6OMdKhGWhCOF5EXKy978/FdIerC0lH9N7eFkoeQLcfq4tmb0SrmPC0ChRuGhXdDnSbu13J8/thNYEl+AR3f49LzD/u9aA0A0hA1CYMaA4iIHaxs7iTl1Fx3BzJl/pZf2ehXfvH2dIjhPhAR65kqwPuxQQmy1sTOIxjosT02ZrJz0sXUg554bWle9ByCUmnH5T4GYzgC0p6CLeJJGrBSTtLeF9rg1CsbvAxyEVNIW9Ltxvol/GW7PkVc2gca66NRT+CEtOOpi+NXpOcjCU6bRVX4ETw9duwT8nVwXhpa34o3y4kmlfQxIOVPoST1YfwxoGubZsNDf5rBzjDTTEqHmDSGqCvCZcTe1HvYJaDNp42BdUflHTlvlXhwQ7DSN/qg9ij3us8UsgWx4KIqfbXXTeW0T1ElVGX3QhkWPoyGkzrh036HfLQydlKt9RcGSIQYWAzzwo4orMLb1kqa5ieWonqF1Kkxiaz52g7cLqPwneelaF6iTc2W/Dmz9IQDYMOZQxvzjdPYljLaPU0NYprjkHS525JAtZH9jfXcYTUtfnJTy6iZrgO8njeZ2gz+H29pwQFLbVX0wyFUr6uAOVgO+2ZtWgbycX7WUldMMBFH4SeTBO4jEqmGucClPg5b5EHu3NL7vICXmkJSZuEjw16UJ/g031ghLCRlzanem7STzeV0QXxvkGufVPQSWwEmGE6S4+OMqqgv/VRG+f8TgYDuC22VeJVrpE8PaX4aIBBbafEhmA5mlJkH9oZ/5PIEpF7FW0Z17D6gHNo3v9korT+MiWPqoo2xOyPO9TJYsz2SOt6LXQRIQZ1INF5fgR4V2tI0tWxhp6VSUKis5p7VfFH1TihcNO1JZ6n+3/nAIaqA2gm6kDVORX09BskYYx8/ayUS6OK6wi4J3r8TDiwgveQqOWlou79Of2EQxiZ00dNialeC4xIp1w+wI6sTjS0+1EkYm5sDBl+lwbdIfr9w4yBXkmZtEHgt+CTLiYMFIrB3dAjAnSCbxcFmSsLN70JLLYunou4TQHZUN+vS/1cXpSn4AHnnpj3rkDGPgS9gUrAxVqTDZRtk++SkJAgACAGccL4WcSU71mih1GxW6xSQLZ7l4/wx2Qy8goh2E4F6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiGdWp6tYcD3BjqhvwiVKlH6MBC5FhkEpZJpzT0594DICzFbOaZvzi4IdqLoZmaDBNhJZYVn8bChq20U1wYLqmAAxDcm91tv2g3iLODg36trzHoF/5WpayiUJMX3M2cNli+bbgtOLAGWjeXDJIKqfR0KCdcXjsk7rXhY+W5k8LSNAZqqHbc6mEMpfd1TBaA5s8PPbbWlw3xztOqrx8K9tdUFiSRi70jt/BTMpcaOrm7zKHzuJEIXU8m7FdcUUDHKbQ=="
     },
     {
       "name": "process_message",
@@ -7592,7 +7592,7 @@
         "directive_integer_quotient",
         "directive_invert"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "sync_private_state",
@@ -8228,7 +8228,7 @@
     },
     "157": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
-      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
+      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
     "159": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",

package/artifacts/ContractInstanceRegistry.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.11+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.11+nightly-2025-08-20-aztec",
   "name": "ContractInstanceRegistry",
   "functions": [
     {
@@ -2346,7 +2346,7 @@
         "debug_log_oracle_wrapper",
         "directive_invert"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "set_update_delay",
@@ -3426,7 +3426,7 @@
     },
     "153": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
-      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
+      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
     "155": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
@@ -3610,7 +3610,7 @@
     },
     "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",
-      "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\n/// A hash that represents a private contract function call's return value. Call `get_preimage` to get the underlying\n/// value.\n///\n/// The kernels don't process the actual return values but instead their hashes, so it is up to contracts to populate\n/// oracles with the preimages of these hashes on return to make them available to their callers.\n///\n/// Public calls don't utilize this mechanism since the AVM does process the full return values.\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    /// Fetches the underlying return value from an oracle, constraining that it corresponds to the return data hash.\n    pub fn get_preimage<T>(self) -> T\n    where\n        T: Deserialize,\n    {\n        // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it. If `T`\n        // is `()`, then `preimage` must be an array of length 0 (since that is `()`'s deserialization length).\n        // `hash_args_array` handles empty arrays following the protocol rules (i.e. an empty args array is signaled\n        // with a zero hash), correctly constraining `self.hash`.\n        let preimage = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage), \"Preimage mismatch\");\n\n        Deserialize::deserialize(preimage)\n    }\n}\n\nmod test {\n    use crate::{\n        hash::hash_args_array,\n        oracle::execution_cache,\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use super::ReturnsHash;\n    use protocol_types::traits::Serialize;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn retrieves_preimage() {\n        let env = TestEnvironment::_new();\n        env.private_context(|_| {\n            let value = MockStruct::new(4, 7);\n            let serialized = value.serialize();\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn retrieves_empty_preimage() {\n        let env = TestEnvironment::_new();\n        env.private_context(|_| {\n            let value = ();\n            let serialized = [];\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test(should_fail_with = \"Preimage mismatch\")]\n    unconstrained fn rejects_bad_preimage() {\n        let value = MockStruct::new(4, 7);\n        let serialized = value.serialize();\n\n        let mut bad_serialized = serialized;\n        bad_serialized[0] += 1;\n\n        let hash = hash_args_array(serialized);\n\n        let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns(bad_serialized);\n        assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    }\n\n    // This test passes due to a Noir bug.\n    // #[test(should_fail_with=\"Preimage mismatch\")]\n    // unconstrained fn rejects_bad_empty_preimage() {\n    //     let value = ();\n    //     let serialized = [];\n\n    //     let hash = hash_args_array(serialized);\n\n    //     let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns([1]);\n    //     assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    // }\n}\n"
+      "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\n/// A hash that represents a private contract function call's return value. Call `get_preimage` to get the underlying\n/// value.\n///\n/// The kernels don't process the actual return values but instead their hashes, so it is up to contracts to populate\n/// oracles with the preimages of these hashes on return to make them available to their callers.\n///\n/// Public calls don't utilize this mechanism since the AVM does process the full return values.\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    /// Fetches the underlying return value from an oracle, constraining that it corresponds to the return data hash.\n    pub fn get_preimage<T>(self) -> T\n    where\n        T: Deserialize,\n    {\n        // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it. If `T`\n        // is `()`, then `preimage` must be an array of length 0 (since that is `()`'s deserialization length).\n        // `hash_args_array` handles empty arrays following the protocol rules (i.e. an empty args array is signaled\n        // with a zero hash), correctly constraining `self.hash`.\n        let preimage = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage), \"Preimage mismatch\");\n\n        Deserialize::deserialize(preimage)\n    }\n}\n\nmod test {\n    use crate::{\n        hash::hash_args_array,\n        oracle::execution_cache,\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use super::ReturnsHash;\n    use protocol_types::traits::Serialize;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn retrieves_preimage() {\n        let env = TestEnvironment::new();\n        env.private_context(|_| {\n            let value = MockStruct::new(4, 7);\n            let serialized = value.serialize();\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn retrieves_empty_preimage() {\n        let env = TestEnvironment::new();\n        env.private_context(|_| {\n            let value = ();\n            let serialized = [];\n\n            let hash = hash_args_array(serialized);\n            execution_cache::store(serialized, hash);\n\n            assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n        });\n    }\n\n    #[test(should_fail_with = \"Preimage mismatch\")]\n    unconstrained fn rejects_bad_preimage() {\n        let value = MockStruct::new(4, 7);\n        let serialized = value.serialize();\n\n        let mut bad_serialized = serialized;\n        bad_serialized[0] += 1;\n\n        let hash = hash_args_array(serialized);\n\n        let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns(bad_serialized);\n        assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    }\n\n    // This test passes due to a Noir bug.\n    // #[test(should_fail_with=\"Preimage mismatch\")]\n    // unconstrained fn rejects_bad_empty_preimage() {\n    //     let value = ();\n    //     let serialized = [];\n\n    //     let hash = hash_args_array(serialized);\n\n    //     let _ = OracleMock::mock(\"privateLoadFromExecutionCache\").returns([1]);\n    //     assert_eq(ReturnsHash::new(hash).get_preimage(), value);\n    // }\n}\n"
     },
     "71": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",

package/artifacts/FeeJuice.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.11+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.11+nightly-2025-08-20-aztec",
   "name": "FeeJuice",
   "functions": [
     {
@@ -2010,7 +2010,7 @@
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "process_message",
@@ -2868,7 +2868,7 @@
     },
     "154": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
-      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
+      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
     "155": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",

package/artifacts/MultiCallEntrypoint.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.11+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.11+nightly-2025-08-20-aztec",
   "name": "MultiCallEntrypoint",
   "functions": [
     {
@@ -1859,7 +1859,7 @@
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "process_message",
@@ -2581,7 +2581,7 @@
     },
     "153": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
-      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
+      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
     "154": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",

package/artifacts/Router.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.11+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.11+nightly-2025-08-20-aztec",
   "name": "Router",
   "functions": [
     {
@@ -1908,7 +1908,7 @@
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "check_timestamp",
@@ -3695,7 +3695,7 @@
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "process_message",
@@ -4490,7 +4490,7 @@
     },
     "155": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
-      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::_new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
+      "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize,\n{\n    let serialized_option = load_oracle(contract_address, slot, <T as Deserialize>::N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(utilityStoreCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(utilityLoadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(utilityDeleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(utilityCopyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), value);\n        });\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n\n            let new_value = MockStruct::new(7, 8);\n            store(contract_address, SLOT, new_value);\n\n            assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n        });\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let value = MockStruct::new(5, 6);\n            store(contract_address, SLOT, value);\n            delete(contract_address, SLOT);\n\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            delete(contract_address, SLOT);\n            let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n            assert_eq(loaded_value, Option::none());\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 5;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 10;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 1;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 2;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n            assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n            assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n        });\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            let src = 2;\n\n            let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n            store(contract_address, src, values[0]);\n            store(contract_address, src + 1, values[1]);\n            store(contract_address, src + 2, values[2]);\n\n            let dst = 1;\n            copy(contract_address, src, dst, 3);\n\n            assert_eq(load(contract_address, dst).unwrap(), values[0]);\n            assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n            assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n            // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n            assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n            assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n            assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n        });\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n\n            copy(contract_address, SLOT, SLOT, 1);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let value = MockStruct::new(5, 6);\n            store(other_contract_address, SLOT, value);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            let _: Option<MockStruct> = load(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            delete(other_contract_address, SLOT);\n        });\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let env = TestEnvironment::new();\n        env.private_context(|context| {\n            let contract_address = context.this_address();\n            let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n            copy(other_contract_address, SLOT, SLOT, 0);\n        });\n    }\n}\n"
     },
     "156": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",

package/dest/protocol_contract_data.js

@@ -26,12 +26,12 @@ export const ProtocolContractAddress = {
     Router: AztecAddress.fromBigInt(6n)
 };
 export const ProtocolContractLeaves = {
-    AuthRegistry: Fr.fromHexString('0x109bdda46bd3f489bd813cedd2bc186707963edda3443b6046d734a90442f4e5'),
-    ContractInstanceRegistry: Fr.fromHexString('0x05e6565c3ebbe91a7112673feff21c7d5527687b3b4db66cfd88831fbf433b1a'),
-    ContractClassRegistry: Fr.fromHexString('0x2c244ce78c87d63e5032ffc46fbef69210f183be6afa1e42381fa79dd9d17715'),
-    MultiCallEntrypoint: Fr.fromHexString('0x23735c9459e09cacbe998e5559ca3fc57002e8353fbd91bc7c918b907c71454b'),
-    FeeJuice: Fr.fromHexString('0x018b61e98ad3333fe83947b048051b040e4d07fb786a59eb65eac7012cf11f72'),
-    Router: Fr.fromHexString('0x0173971127d23d9a0a38d6477a17372c1f2415417ce0e3d27da1021d369b7817')
+    AuthRegistry: Fr.fromHexString('0x104a37c43a41fdf34a71d06fa780402bd0b0804f8a613dfb496f095571715e6c'),
+    ContractInstanceRegistry: Fr.fromHexString('0x2dccba74102f5b7c61f8be4b30c64b315f1e7b87feda0fb995b1894787f01be5'),
+    ContractClassRegistry: Fr.fromHexString('0x2812bbf56aaad8150091a6955c28d2d03dd3f8b44db3d187f5aa5691fac0460c'),
+    MultiCallEntrypoint: Fr.fromHexString('0x176d1226837f8a62786bb56f4f0608555652086da37fa68612224fc6e01fb6e8'),
+    FeeJuice: Fr.fromHexString('0x1cbddf5ccc7b24a792a73f2978f83e79e26e708306dc7ee3dbaea13544a4a8ef'),
+    Router: Fr.fromHexString('0x05ddc935a5fb32161b30f7ce53f9234b10eec29ede2d0a0ca943f5b5c0eb989e')
 };
-export const protocolContractTreeRoot = Fr.fromHexString('0x1747a3563cf866404da13c34803371eb1df681bef473e0c015575891f129c3e2');
+export const protocolContractTreeRoot = Fr.fromHexString('0x098c04256d17627c3e38ad88a48aeed6719230a3363933001f252222bb213299');
 export const CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG = Fr.fromHexString('0x28da3fc471387d4e20b646b77abc8cdfc02a339a7507285a73d84f9b97b13486');

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aztec/protocol-contracts",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/protocol-contracts",
   "description": "Canonical Noir contracts for the Aztec Network",
-  "version": "2.0.0-nightly.20250821",
+  "version": "2.0.0-nightly.20250823",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -73,9 +73,9 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "2.0.0-nightly.20250821",
-    "@aztec/foundation": "2.0.0-nightly.20250821",
-    "@aztec/stdlib": "2.0.0-nightly.20250821",
+    "@aztec/constants": "2.0.0-nightly.20250823",
+    "@aztec/foundation": "2.0.0-nightly.20250823",
+    "@aztec/stdlib": "2.0.0-nightly.20250823",
     "lodash.chunk": "^4.2.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.4.0"

package/src/protocol_contract_data.ts

@@ -40,17 +40,17 @@ Router: AztecAddress.fromBigInt(6n)
 
     
     export const ProtocolContractLeaves = {
-      AuthRegistry: Fr.fromHexString('0x109bdda46bd3f489bd813cedd2bc186707963edda3443b6046d734a90442f4e5'),
-ContractInstanceRegistry: Fr.fromHexString('0x05e6565c3ebbe91a7112673feff21c7d5527687b3b4db66cfd88831fbf433b1a'),
-ContractClassRegistry: Fr.fromHexString('0x2c244ce78c87d63e5032ffc46fbef69210f183be6afa1e42381fa79dd9d17715'),
-MultiCallEntrypoint: Fr.fromHexString('0x23735c9459e09cacbe998e5559ca3fc57002e8353fbd91bc7c918b907c71454b'),
-FeeJuice: Fr.fromHexString('0x018b61e98ad3333fe83947b048051b040e4d07fb786a59eb65eac7012cf11f72'),
-Router: Fr.fromHexString('0x0173971127d23d9a0a38d6477a17372c1f2415417ce0e3d27da1021d369b7817')
+      AuthRegistry: Fr.fromHexString('0x104a37c43a41fdf34a71d06fa780402bd0b0804f8a613dfb496f095571715e6c'),
+ContractInstanceRegistry: Fr.fromHexString('0x2dccba74102f5b7c61f8be4b30c64b315f1e7b87feda0fb995b1894787f01be5'),
+ContractClassRegistry: Fr.fromHexString('0x2812bbf56aaad8150091a6955c28d2d03dd3f8b44db3d187f5aa5691fac0460c'),
+MultiCallEntrypoint: Fr.fromHexString('0x176d1226837f8a62786bb56f4f0608555652086da37fa68612224fc6e01fb6e8'),
+FeeJuice: Fr.fromHexString('0x1cbddf5ccc7b24a792a73f2978f83e79e26e708306dc7ee3dbaea13544a4a8ef'),
+Router: Fr.fromHexString('0x05ddc935a5fb32161b30f7ce53f9234b10eec29ede2d0a0ca943f5b5c0eb989e')
     };
   
 
     
-    export const protocolContractTreeRoot = Fr.fromHexString('0x1747a3563cf866404da13c34803371eb1df681bef473e0c015575891f129c3e2');
+    export const protocolContractTreeRoot = Fr.fromHexString('0x098c04256d17627c3e38ad88a48aeed6719230a3363933001f252222bb213299');