feat!: add test env note discovery (#16384)

This adds `TestEnvironment::discover_note`, which is needed to emulate
the note discovery that happens in real contracts for notes created in a
`TestEnvironment::pirvate_context`. With this we can now extend our
testing of note-based state variables, as well as properly tests
constructs such as `DelayedPrivateMutable`.

I introduced some minor adjustments to the internals of the message
encoding functions to better reuse those capabitilies. These are part of
a larger set of changes we'll likely want to introduce as we unify and
improve the note and event emission APIs.

edit: I also added some tests for note destruction and checking that we
do not return those notes, both in transient and settled scenarios. I'm
only testing private context and not utility context to keep the number
of tests here small, but we should later expand these, perhaps with some
more organization of the internals of the note getter API.

Interestingly, I had to pseudo introduce the notion of 'syncing' and how
it relates to nullified note discovery (#12553) here, since direct
context usage does not run the autogenerated note discovery code. This
resulted in some findings, notably the note data provider being a bit
annoying about requiring knowledge of the recipient of the notes that
were being nullified, seemingly for no good reason. I had to remove all
of that because `env::discover_note` sets the zero address as the
recipient as none are assumed to exist, and so when looking up notes
we'd want to check for nullification we'd find none since our PXE had no
accounts. This now searches _all_ notes in scope, regardless of who
their recipient is.

Author: AztecBot

noir-projects/aztec-nr/aztec/src/macros/aztec.nr

@@ -276,7 +276,7 @@ comptime fn generate_process_message() -> Quoted {
             message_ciphertext: BoundedVec<Field, aztec::messages::encoding::MESSAGE_CIPHERTEXT_LEN>,
             message_context: aztec::messages::processing::message_context::MessageContext,
         ) {
-            aztec::messages::discovery::process_message::do_process_message(
+            aztec::messages::discovery::process_message::process_message_ciphertext(
                 context.this_address(),
                 _compute_note_hash_and_nullifier,
                 message_ciphertext,

noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr

@@ -8,7 +8,9 @@ pub mod process_message;
 
 use crate::{
     messages::{
-        discovery::{private_notes::MAX_NOTE_PACKED_LEN, process_message::do_process_message},
+        discovery::{
+            private_notes::MAX_NOTE_PACKED_LEN, process_message::process_message_ciphertext,
+        },
         processing::{
             get_private_logs, pending_tagged_log::PendingTaggedLog,
             validate_enqueued_notes_and_events,
@@ -59,7 +61,7 @@ pub struct NoteHashAndNullifier {
 ///     };
 /// }
 /// ```
-type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;
+pub type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;
 
 /// Performs the message discovery process, in which private logs are downloaded and inspected to find new private
 /// notes, partial notes and events, etc., and pending partial notes are processed to search for their completion logs.
@@ -88,7 +90,7 @@ pub unconstrained fn discover_new_messages<Env>(
         // We remove the tag from the pending tagged log and process the message ciphertext contained in it.
         let message_ciphertext = array::subbvec(pending_tagged_log.log, 1);
 
-        do_process_message(
+        process_message_ciphertext(
             contract_address,
             compute_note_hash_and_nullifier,
             message_ciphertext,

noir-projects/aztec-nr/aztec/src/messages/discovery/process_message.nr

@@ -3,7 +3,7 @@ use crate::messages::{
         ComputeNoteHashAndNullifier, partial_notes::process_partial_note_private_msg,
         private_events::process_private_event_msg, private_notes::process_private_note_msg,
     },
-    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN},
+    encoding::{decode_message, MESSAGE_CIPHERTEXT_LEN, MESSAGE_PLAINTEXT_LEN},
     encryption::{aes128::AES128, log_encryption::LogEncryption},
     msg_type::{
         PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_EVENT_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID,
@@ -25,19 +25,31 @@ use protocol_types::{address::AztecAddress, debug_log::{debug_log, debug_log_for
 ///
 /// Events are processed by computing an event commitment from the serialized event data and its randomness field, then
 /// enqueueing the event data and commitment for validation.
-pub unconstrained fn do_process_message<Env>(
+pub unconstrained fn process_message_ciphertext<Env>(
     contract_address: AztecAddress,
     compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,
     message_ciphertext: BoundedVec<Field, MESSAGE_CIPHERTEXT_LEN>,
     message_context: MessageContext,
 ) {
-    let message = AES128::decrypt_log(message_ciphertext, message_context.recipient);
+    process_message_plaintext(
+        contract_address,
+        compute_note_hash_and_nullifier,
+        AES128::decrypt_log(message_ciphertext, message_context.recipient),
+        message_context,
+    );
+}
 
+pub unconstrained fn process_message_plaintext<Env>(
+    contract_address: AztecAddress,
+    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,
+    message_plaintext: BoundedVec<Field, MESSAGE_PLAINTEXT_LEN>,
+    message_context: MessageContext,
+) {
     // The first thing to do after decrypting the message is to determine what type of message we're processing. We
     // have 3 message types: private notes, partial notes and events.
 
     // We decode the message to obtain the message type id, metadata and content.
-    let (msg_type_id, msg_metadata, msg_content) = decode_message(message);
+    let (msg_type_id, msg_metadata, msg_content) = decode_message(message_plaintext);
 
     if msg_type_id == PRIVATE_NOTE_MSG_TYPE_ID {
         debug_log("Processing private note msg");

noir-projects/aztec-nr/aztec/src/messages/logs/note.nr

@@ -3,43 +3,36 @@ use crate::{
         encoding::encode_message,
         encryption::{aes128::AES128, log_encryption::LogEncryption},
         logs::utils::prefix_with_tag,
-        msg_type::PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,
+        msg_type::{PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID, PRIVATE_NOTE_MSG_TYPE_ID},
     },
     note::note_interface::NoteType,
 };
 use protocol_types::{
-    address::AztecAddress,
-    constants::{PRIVATE_LOG_CIPHERTEXT_LEN, PRIVATE_LOG_SIZE_IN_FIELDS},
-    traits::Packable,
+    address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS, traits::Packable,
 };
 
 // TODO(#16881): once partial notes support emission via an offchain message we will most likely want to remove this.
-pub fn compute_partial_note_log<Note>(
-    note: Note,
+pub fn compute_partial_note_private_content_log<PartialNotePrivateContent>(
+    partial_note_private_content: PartialNotePrivateContent,
     storage_slot: Field,
     recipient: AztecAddress,
 ) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]
 where
-    Note: NoteType + Packable,
+    PartialNotePrivateContent: NoteType + Packable,
 {
-    let ciphertext = compute_note_message_ciphertext(
-        note,
+    let message_plaintext = partial_note_private_content_to_message_plaintext(
+        partial_note_private_content,
         storage_slot,
-        recipient,
-        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,
     );
+    let message_ciphertext = AES128::encrypt_log(message_plaintext, recipient);
 
-    let log = prefix_with_tag(ciphertext, recipient);
-
-    log
+    prefix_with_tag(message_ciphertext, recipient)
 }
 
-pub fn compute_note_message_ciphertext<Note>(
+pub fn private_note_to_message_plaintext<Note>(
     note: Note,
     storage_slot: Field,
-    recipient: AztecAddress,
-    msg_type: u64,
-) -> [Field; PRIVATE_LOG_CIPHERTEXT_LEN]
+) -> [Field; <Note as Packable>::N + 2]
 where
     Note: NoteType + Packable,
 {
@@ -53,7 +46,29 @@ where
     }
 
     // Notes use the note type id for metadata
-    let plaintext = encode_message(msg_type, Note::get_id() as u64, msg_content);
+    encode_message(PRIVATE_NOTE_MSG_TYPE_ID, Note::get_id() as u64, msg_content)
+}
+
+pub fn partial_note_private_content_to_message_plaintext<PartialNotePrivateContent>(
+    partial_note_private_content: PartialNotePrivateContent,
+    storage_slot: Field,
+) -> [Field; <PartialNotePrivateContent as Packable>::N + 2]
+where
+    PartialNotePrivateContent: NoteType + Packable,
+{
+    let packed_private_content = partial_note_private_content.pack();
 
-    AES128::encrypt_log(plaintext, recipient)
+    // A partial note message's content is the storage slot followed by the packed private content representation
+    let mut msg_content = [0; 1 + <PartialNotePrivateContent as Packable>::N];
+    msg_content[0] = storage_slot;
+    for i in 0..packed_private_content.len() {
+        msg_content[1 + i] = packed_private_content[i];
+    }
+
+    encode_message(
+        PARTIAL_NOTE_PRIVATE_MSG_TYPE_ID,
+        // Notes use the note type id for metadata
+        PartialNotePrivateContent::get_id() as u64,
+        msg_content,
+    )
 }

noir-projects/aztec-nr/aztec/src/note/note_emission.nr

@@ -1,9 +1,9 @@
 use crate::{
     context::PrivateContext,
     messages::{
-        logs::{note::compute_note_message_ciphertext, utils::prefix_with_tag},
+        encryption::{aes128::AES128, log_encryption::LogEncryption},
+        logs::{note::private_note_to_message_plaintext, utils::prefix_with_tag},
         message_delivery::MessageDelivery,
-        msg_type::PRIVATE_NOTE_MSG_TYPE_ID,
         offchain_messages::emit_offchain_message,
     },
     note::note_interface::NoteType,
@@ -52,11 +52,9 @@ where
 
         let ciphertext = remove_constraints_if(
             !constrained_encryption,
-            || compute_note_message_ciphertext(
-                self.note,
-                self.storage_slot,
+            || AES128::encrypt_log(
+                private_note_to_message_plaintext(self.note, self.storage_slot),
                 recipient,
-                PRIVATE_NOTE_MSG_TYPE_ID,
             ),
         );
 

noir-projects/aztec-nr/aztec/src/note/note_getter.nr

@@ -81,7 +81,7 @@ where
 {
     // Safety: Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do
     // is check that the metadata is correct, and that the note exists.
-    let retrieved_note = unsafe { get_note_internal::<Note>(storage_slot) };
+    let retrieved_note = unsafe { view_note::<Note>(storage_slot) };
 
     // For settled notes, the contract address is implicitly checked since the hash returned from
     // `compute_note_hash_for_read_request` is siloed and kernels verify the siloing during note read request
@@ -189,7 +189,7 @@ where
     (notes, note_hashes)
 }
 
-unconstrained fn get_note_internal<Note>(storage_slot: Field) -> RetrievedNote<Note>
+pub unconstrained fn view_note<Note>(storage_slot: Field) -> RetrievedNote<Note>
 where
     Note: NoteType + Packable,
 {
@@ -210,7 +210,7 @@ where
         NoteStatus.ACTIVE,
     );
 
-    opt_notes[0].expect(f"Failed to get a note") // Notice: we don't allow dummies to be returned from get_note (singular).
+    opt_notes[0].expect(f"Failed to get a note")
 }
 
 unconstrained fn get_notes_internal<Note, let M: u32, PreprocessorArgs, FilterArgs>(

noir-projects/aztec-nr/aztec/src/note/note_getter/test.nr

@@ -37,7 +37,7 @@ where
 }
 
 #[test]
-unconstrained fn processes_single_note() {
+unconstrained fn constrain_get_notes_processes_single_note() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -55,7 +55,7 @@ unconstrained fn processes_single_note() {
 }
 
 #[test]
-unconstrained fn processes_many_notes() {
+unconstrained fn constrain_get_notes_processes_many_notes() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -75,7 +75,7 @@ unconstrained fn processes_many_notes() {
 }
 
 #[test]
-unconstrained fn collapses_notes_at_the_beginning_of_the_array() {
+unconstrained fn constrain_get_notes_collapses_notes_at_the_beginning_of_the_array() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -106,7 +106,7 @@ unconstrained fn collapses_notes_at_the_beginning_of_the_array() {
 }
 
 #[test]
-unconstrained fn can_return_zero_notes() {
+unconstrained fn constrain_get_notes_can_return_zero_notes() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -120,7 +120,7 @@ unconstrained fn can_return_zero_notes() {
 }
 
 #[test(should_fail_with = "Got more notes than limit.")]
-unconstrained fn rejects_mote_notes_than_limit() {
+unconstrained fn constrain_get_notes_rejects_mote_notes_than_limit() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -138,7 +138,7 @@ unconstrained fn rejects_mote_notes_than_limit() {
 }
 
 #[test]
-unconstrained fn applies_filter_before_constraining() {
+unconstrained fn constrain_get_notes_applies_filter_before_constraining() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -175,7 +175,7 @@ unconstrained fn applies_filter_before_constraining() {
 }
 
 #[test(should_fail_with = "Note contract address mismatch.")]
-unconstrained fn rejects_mismatched_address() {
+unconstrained fn constrain_get_notes_rejects_mismatched_address() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -189,7 +189,7 @@ unconstrained fn rejects_mismatched_address() {
 }
 
 #[test(should_fail_with = "Mismatch return note field.")]
-unconstrained fn rejects_mismatched_selector() {
+unconstrained fn constrain_get_notes_rejects_mismatched_selector() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -211,7 +211,7 @@ unconstrained fn rejects_mismatched_selector() {
 }
 
 #[test(should_fail_with = "Return notes not sorted in descending order.")]
-unconstrained fn rejects_mismatched_desc_sort_order() {
+unconstrained fn constrain_get_notes_rejects_mismatched_desc_sort_order() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {
@@ -229,7 +229,7 @@ unconstrained fn rejects_mismatched_desc_sort_order() {
 }
 
 #[test(should_fail_with = "Return notes not sorted in ascending order.")]
-unconstrained fn rejects_mismatched_asc_sort_order() {
+unconstrained fn constrain_get_notes_rejects_mismatched_asc_sort_order() {
     let env = TestEnvironment::new();
 
     env.private_context(|context| {

noir-projects/aztec-nr/aztec/src/state_vars/private_mutable.nr

@@ -7,14 +7,15 @@ use crate::context::{PrivateContext, UtilityContext};
 use crate::note::{
     lifecycle::{create_note, destroy_note_unsafe},
     note_emission::NoteEmission,
-    note_getter::{get_note, view_notes},
+    note_getter::{get_note, view_note},
     note_interface::{NoteHash, NoteType},
-    note_viewer_options::NoteViewerOptions,
 };
 use crate::note::retrieved_note::RetrievedNote;
 use crate::oracle::notes::check_nullifier_exists;
 use crate::state_vars::storage::HasStorageSlot;
 
+mod test;
+
 /// # PrivateMutable
 ///
 /// PrivateMutable is a private state variable type, which enables you to read, mutate,
@@ -108,8 +109,6 @@ pub struct PrivateMutable<Note, Context> {
 }
 // docs:end:struct
 
-mod test;
-
 // Private storage slots are not really 'slots' but rather a value in the note hash preimage, so there is no notion of a
 // value spilling over multiple slots. For this reason PrivateMutable (and all other private state variables) needs just
 // one slot to be reserved, regardless of what it stores.
@@ -465,8 +464,7 @@ where
     where
         Note: Packable,
     {
-        let mut options = NoteViewerOptions::<Note, <Note as Packable>::N>::new();
-        view_notes(self.storage_slot, options.set_limit(1)).get(0)
+        view_note(self.storage_slot).note
     }
     // docs:end:view_note
 }