init

noir-projects/noir-contracts/contracts/counter_contract/src/main.nr

@@ -1,11 +1,12 @@
 // docs:start:setup
 use dep::aztec::macros::aztec;
+mod test;
 
 #[aztec]
 contract Counter {
     // docs:end:setup
     // docs:start:imports
-    use aztec::macros::{functions::{initializer, private}, storage::storage};
+    use aztec::macros::{functions::{initializer, private, public}, storage::storage};
     use aztec::prelude::{AztecAddress, Map};
     use easy_private_state::EasyPrivateUint;
     use value_note::{balance_utils, value_note::ValueNote};
@@ -41,6 +42,45 @@ contract Counter {
         counters.at(owner).add(1, owner, outgoing_viewer, outgoing_viewer);
     }
     // docs:end:increment
+
+    #[private]
+    fn increment_twice(owner: AztecAddress, outgoing_viewer: AztecAddress) {
+        unsafe {
+            dep::aztec::oracle::debug_log::debug_log_format(
+                "Incrementing counter twice for owner {0}",
+                [owner.to_field()],
+            );
+        }
+        let counters = storage.counters;
+        counters.at(owner).add(1, owner, outgoing_viewer, outgoing_viewer);
+        counters.at(owner).add(1, owner, outgoing_viewer, outgoing_viewer);
+    }
+
+    #[private]
+    fn increment_and_decrement(owner: AztecAddress, outgoing_viewer: AztecAddress) {
+        unsafe {
+            dep::aztec::oracle::debug_log::debug_log_format(
+                "Incrementing and decrementing counter for owner {0}",
+                [owner.to_field()],
+            );
+        }
+        let counters = storage.counters;
+        counters.at(owner).add(1, owner, outgoing_viewer, outgoing_viewer);
+        counters.at(owner).sub(1, owner, outgoing_viewer, outgoing_viewer);
+    }
+
+    #[private]
+    fn decrement(owner: AztecAddress, outgoing_viewer: AztecAddress) {
+        unsafe {
+            dep::aztec::oracle::debug_log::debug_log_format(
+                "Decrementing counter for owner {0}",
+                [owner.to_field()],
+            );
+        }
+        let counters = storage.counters;
+        counters.at(owner).sub(1, owner, outgoing_viewer, outgoing_viewer);
+    }
+
     // docs:start:get_counter
     unconstrained fn get_counter(owner: AztecAddress) -> pub Field {
         let counters = storage.counters;
@@ -49,10 +89,15 @@ contract Counter {
 
     // docs:end:get_counter
     // docs:start:test_imports
+    use dep::aztec::note::lifecycle::destroy_note;
     use dep::aztec::note::note_getter::{MAX_NOTES_PER_PAGE, view_notes};
     use dep::aztec::note::note_viewer_options::NoteViewerOptions;
+
+    use dep::aztec::protocol_types::debug_log::debug_log_format;
     use dep::aztec::protocol_types::storage::map::derive_storage_slot_in_map;
     use dep::aztec::test::helpers::{cheatcodes, test_environment::TestEnvironment};
+    use crate::test;
+
     // docs:end:test_imports
     // docs:start:txe_test_increment
     #[test]
@@ -92,4 +137,109 @@ contract Counter {
         );
     }
     // docs:end:txe_test_increment
+
+    #[test]
+    unconstrained fn inclusion_proofs() {
+        let initial_value = 5;
+        let (env, contract_address, owner, outgoing_viewer) = test::setup(initial_value);
+        env.advance_block_by(1);
+
+        env.impersonate(contract_address);
+        let counter_slot = Counter::storage_layout().counters.slot;
+        let owner_slot = derive_storage_slot_in_map(counter_slot, owner);
+        let mut options = NoteViewerOptions::new();
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        let initial_note_value = notes.get(0).value;
+        assert(
+            initial_note_value == initial_value,
+            f"Expected {initial_value} but got {initial_note_value}",
+        );
+
+        let old_note = notes.get(0);
+
+        env.private().get_header().prove_note_validity(old_note, &mut env.private());
+
+        destroy_note(&mut env.private(), old_note);
+        env.advance_block_by(1);
+
+        env.private().get_header().prove_note_is_nullified(old_note, &mut env.private());
+        env.private().get_header().prove_note_inclusion(old_note);
+
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+
+        assert(notes.len() == 0);
+    }
+
+    #[test]
+    unconstrained fn extended_incrementing_and_decrementing() {
+        let initial_value = 5;
+        let (env, contract_address, owner, outgoing_viewer) = test::setup(initial_value);
+
+        // Checking from the note cache
+        env.impersonate(contract_address);
+        let counter_slot = Counter::storage_layout().counters.slot;
+        let owner_slot = derive_storage_slot_in_map(counter_slot, owner);
+        let mut options = NoteViewerOptions::new();
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        let initial_note_value = notes.get(0).value;
+        assert(
+            initial_note_value == initial_value,
+            f"Expected {initial_value} but got {initial_note_value}",
+        );
+
+        // Checking that the note was discovered from private logs
+        env.advance_block_by(1);
+        env.impersonate(contract_address);
+        let counter_slot = Counter::storage_layout().counters.slot;
+        let owner_slot = derive_storage_slot_in_map(counter_slot, owner);
+        let mut options = NoteViewerOptions::new();
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        let initial_note_value = notes.get(0).value;
+        assert(
+            initial_note_value == initial_value,
+            f"Expected {initial_value} but got {initial_note_value}",
+        );
+
+        Counter::at(contract_address).increment_twice(owner, outgoing_viewer).call(&mut env.private());
+
+        // Checking from the note cache
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        assert(notes.len() == 3);
+        assert(get_counter(owner) == 7);
+
+        // Checking that the note was discovered from private logs
+        env.advance_block_by(1);
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        assert(get_counter(owner) == 7);
+        assert(notes.len() == 3);
+
+        // Checking from the note cache
+        Counter::at(contract_address).increment_and_decrement(owner, outgoing_viewer).call(
+            &mut env.private(),
+        );
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        assert(get_counter(owner) == 7);
+        // We have a change note of 0
+        assert(notes.len() == 4);
+
+        // Checking that the note was discovered from private logs
+        env.advance_block_by(1);
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        assert(notes.len() == 4);
+        assert(get_counter(owner) == 7);
+
+        // Checking from the note cache, note that we MUST advance the block to get a correct and updated value.
+        Counter::at(contract_address).decrement(owner, outgoing_viewer).call(
+            &mut env.private(),
+        );
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        assert(get_counter(owner) == 11);
+        assert(notes.len() == 5);
+
+        // We advance the block here to have the nullification of the prior note be applied. Should we try nullifiying notes in our DB on notifyNullifiedNote ?
+        env.advance_block_by(1);
+        let notes: BoundedVec<ValueNote, MAX_NOTES_PER_PAGE> = view_notes(owner_slot, options);
+        assert(get_counter(owner) == 6);
+        assert(notes.len() == 4);
+    }
 }

noir-projects/noir-contracts/contracts/counter_contract/src/test.nr

@@ -0,0 +1,16 @@
+use dep::aztec::{prelude::AztecAddress, test::helpers::test_environment::TestEnvironment};
+use crate::Counter;
+
+pub unconstrained fn setup(initial_value: Field) -> (&mut TestEnvironment, AztecAddress, AztecAddress, AztecAddress) {
+    // Setup env, generate keys
+    let mut env = TestEnvironment::new();
+    let owner = env.create_account();
+    let outgoing_viewer = env.create_account();
+    env.impersonate(owner);
+    // Deploy contract and initialize
+    let initializer =
+        Counter::interface().initialize(initial_value as u64, owner, outgoing_viewer);
+    let counter_contract = env.deploy_self("Counter").with_private_initializer(initializer);
+    let contract_address = counter_contract.to_address();
+    (&mut env, contract_address, owner, outgoing_viewer)
+}

yarn-project/pxe/src/index.ts

@@ -12,3 +12,4 @@ export * from '@aztec/key-store';
 export * from './database/index.js';
 export { ContractDataOracle } from './contract_data_oracle/index.js';
 export { PrivateFunctionsTree } from './contract_data_oracle/private_functions_tree.js';
+export { SimulatorOracle } from './simulator_oracle/index.js';

yarn-project/simulator/src/client/execution_note_cache.ts

@@ -1,6 +1,6 @@
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
 
 import { type NoteData } from '../acvm/index.js';
 
@@ -146,4 +146,14 @@ export class ExecutionNoteCache {
     notes.push(note);
     this.noteMap.set(note.note.contractAddress.toBigInt(), notes);
   }
+
+  getAllNotes(): PendingNote[] {
+    return this.notes;
+  }
+
+  getAllNullifiers(): Fr[] {
+    return [...this.nullifierMap.values()].flatMap(nullifierArray =>
+      [...nullifierArray.values()].map(val => new Fr(val)),
+    );
+  }
 }