feat: merge-train/fairies (AztecProtocol#23166)

BEGIN_COMMIT_OVERRIDE
fix: dropped tagging indices no longer cause a pxe crash on sync
(AztecProtocol#23044)
feat: forward-port upstream oxide aztec-nr changes (AztecProtocol#23183)
test: add noir tests for get_note_hash_membership_witness (AztecProtocol#23190)
fix(aztec-up): explicit exit in CLI acceptance test harness (AztecProtocol#23200)
refactor(pxe): batch nullifier sync across scopes (AztecProtocol#23129)
ci: revert ci-compat-e2e to AWS access keys (AztecProtocol#23212)
END_COMMIT_OVERRIDE

Author: nchamo

.github/workflows/ci3.yml

@@ -456,9 +456,6 @@ jobs:
   # Escape hatch: ci-skip-compat-e2e label makes failures non-blocking on release PRs.
   ci-compat-e2e:
     runs-on: ubuntu-latest
-    permissions:
-      id-token: write
-      contents: read
     needs: [ci]
     if: |
       always()
@@ -478,17 +475,11 @@ jobs:
         with:
           ref: ${{ github.event.pull_request.head.sha || github.sha }}
 
-      - name: Configure AWS credentials (OIDC)
-        uses: aws-actions/configure-aws-credentials@v4
-        with:
-          role-to-assume: ${{ secrets.AWS_OIDC_ROLE_ARN }}
-          aws-region: us-east-2
-          role-session-name: ci3-compat-e2e-${{ github.run_id }}
-          role-duration-seconds: 21600 # 6h – covers AWS_SHUTDOWN_TIME (300 min) + 60 min buffer
-
       - name: Run Backwards Compatibility E2E Tests
         timeout-minutes: 330
         env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           GITHUB_TOKEN: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
           BUILD_INSTANCE_SSH_KEY: ${{ secrets.BUILD_INSTANCE_SSH_KEY }}
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}

aztec-up/test/aztec-cli-acceptance-test/aztec-cli-acceptance-test.ts

@@ -72,10 +72,14 @@ if (result.ok) {
   log(`All steps PASSED (${msToSecs(Date.now() - totalStart)}s total)`);
   console.log(`TEST_RESULT=pass version=${result.aztecVersion}`);
   rmSync(TMP_DIR, { recursive: true, force: true });
+  // Explicit exit fires the 'exit' handler registered in startLocalNetwork(), which SIGTERMs the
+  // long-running `aztec start --local-network` child. Without this, the child keeps Node's event
+  // loop alive — the handler never fires and the process hangs until the CI timeout cancels it.
+  process.exit(0);
 } else {
   reportFailure(result.stepName, result.aztecVersion, result.error);
   leaveTmpDirForInspection();
-  process.exitCode = 1;
+  process.exit(1);
 }
 
 async function main(): Promise<RunResult> {

docs/docs-developers/docs/resources/migration_notes.md

@@ -9,6 +9,40 @@ Aztec is in active development. Each version may introduce breaking changes that
 
 ## TBD
 
+### [Aztec.nr] `attempt_note_discovery` is no longer exposed; use `process_private_note_msg`
+
+`attempt_note_discovery` is now crate-private. Custom message handlers (implementations of `CustomMessageHandler`) that previously called it directly should call `process_private_note_msg` instead, which runs the standard private note message decoding and discovery pipeline.
+
+`process_private_note_msg` takes the raw `msg_metadata` and `msg_content` rather than already-decoded note fields, so it handles decoding (and silently discards undecodable messages) on your behalf:
+
+```diff
+- attempt_note_discovery(
+-     contract_address,
+-     tx_hash,
+-     unique_note_hashes_in_tx,
+-     first_nullifier_in_tx,
+-     compute_note_hash,
+-     compute_note_nullifier,
+-     owner,
+-     storage_slot,
+-     randomness,
+-     note_type_id,
+-     packed_note,
+- );
++ process_private_note_msg(
++     contract_address,
++     tx_hash,
++     unique_note_hashes_in_tx,
++     first_nullifier_in_tx,
++     compute_note_hash,
++     compute_note_nullifier,
++     msg_metadata,
++     msg_content,
++ );
+```
+
+**Impact**: Custom message handlers that reused the standard note message processing pipeline must switch to `process_private_note_msg`. Contracts using only built-in private note handling are unaffected.
+
 ### [Aztec.nr] TXE `call_public_incognito` no longer takes a `from` parameter
 
 `TestEnvironment::call_public_incognito` previously accepted a `from` address that was silently ignored (the function always uses a null `msg_sender`). The `from` parameter has been removed.

noir-projects/aztec-nr/aztec/src/history/mod.nr

@@ -14,4 +14,4 @@ pub mod deployment;
 pub mod note;
 pub mod nullifier;
 pub mod storage;
-mod test;
+pub(crate) mod test;

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

@@ -126,9 +126,12 @@ comptime fn generate_contract_library_method_compute_note_hash() -> Quoted {
         let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});
 
         quote {
-            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash (non-siloed).
+            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash
+            /// (non-siloed).
             ///
-            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHash` type, and so it can be used to call functions from that module such as `do_sync_state` and `attempt_note_discovery`.
+            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteHash` type,
+            /// and so it can be used to call functions from that module such as `do_sync_state` and
+            /// `process_private_note_msg`.
             ///
             /// This function is automatically injected by the `#[aztec]` macro.
             #[contract_library_method]
@@ -240,7 +243,9 @@ comptime fn generate_contract_library_method_compute_note_nullifier() -> Quoted
         quote {
             /// Computes a note's inner nullifier (non-siloed) given its unique note hash, preimage and extra data.
             ///
-            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteNullifier` type, and so it can be used to call functions from that module such as `do_sync_state` and `attempt_note_discovery`.
+            /// The signature of this function notably matches the `aztec::messages::discovery::ComputeNoteNullifier`
+            /// type, and so it can be used to call functions from that module such as `do_sync_state` and
+            /// `process_private_note_msg`.
             ///
             /// This function is automatically injected by the `#[aztec]` macro.
             #[contract_library_method]

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

@@ -9,7 +9,26 @@ use crate::{
     protocol::{address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, traits::ToField},
 };
 
-pub(crate) unconstrained fn process_private_note_msg(
+/// Processes a private note message, attempting to discover and enqueue any notes it contains.
+///
+/// For each note recovered from the message whose computed note hash matches a unique note hash in the transaction,
+/// a [`NoteValidationRequest`](crate::messages::processing::NoteValidationRequest) is pushed onto the ephemeral array
+/// at `NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT` via
+/// [`enqueue_note_for_validation`](crate::messages::processing::enqueue_note_for_validation). PXE later drains this
+/// array during `validate_and_store_enqueued_notes_and_events`, after which the notes are retrievable via `get_notes`.
+///
+/// Messages that fail to decode, or whose computed note hash matches nothing in the transaction, are discarded
+/// (with a debug or warning log respectively) and produce no validation requests. Decode failures are not treated
+/// as errors since messages may originate from malicious senders and we don't want them to be able to brick message
+/// processing.
+///
+/// ## Use Cases
+///
+/// This function is invoked automatically by aztec-nr when handling messages with the built-in private note type id,
+/// so contracts do not normally need to call it directly. It is exposed for use by custom message handlers (see
+/// [`CustomMessageHandler`](crate::messages::discovery::CustomMessageHandler)) that might want to use the standard
+/// note message processing pipeline while extending it with custom logic.
+pub unconstrained fn process_private_note_msg(
     contract_address: AztecAddress,
     tx_hash: Field,
     unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,
@@ -48,7 +67,7 @@ pub(crate) unconstrained fn process_private_note_msg(
 
 /// Attempts discovery of a note given information about its contents and the transaction in which it is suspected the
 /// note was created.
-pub unconstrained fn attempt_note_discovery(
+unconstrained fn attempt_note_discovery(
     contract_address: AztecAddress,
     tx_hash: Field,
     unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,

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

@@ -19,10 +19,12 @@ pub(crate) global PRIVATE_NOTE_MSG_PLAINTEXT_RANDOMNESS_INDEX: u32 = 2;
 /// encryption overhead and extra fields in the message (e.g. message type id, storage slot, randomness, etc.).
 pub global MAX_NOTE_PACKED_LEN: u32 = MAX_MESSAGE_CONTENT_LEN - PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN;
 
-/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).
+/// Creates the plaintext for a private note message with the given `msg_type_id`.
 ///
-/// This plaintext is meant to be decoded via [`decode_private_note_message`].
-pub fn encode_private_note_message<Note>(
+/// Shared encoder used by [`encode_private_note_message`] and by custom message handlers that use the same format as
+/// standard private note message but perform additional validation logic.
+pub fn encode_private_note_message_with_msg_type_id<Note>(
+    msg_type_id: u64,
     note: Note,
     owner: AztecAddress,
     storage_slot: Field,
@@ -49,7 +51,28 @@ where
     }
 
     // Notes use the note type id for metadata
-    encode_message(PRIVATE_NOTE_MSG_TYPE_ID, Note::get_id() as u64, msg_content)
+    encode_message(msg_type_id, Note::get_id() as u64, msg_content)
+}
+
+/// Creates the plaintext for a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).
+///
+/// This plaintext is meant to be decoded via [`decode_private_note_message`].
+pub fn encode_private_note_message<Note>(
+    note: Note,
+    owner: AztecAddress,
+    storage_slot: Field,
+    randomness: Field,
+) -> [Field; PRIVATE_NOTE_MSG_PLAINTEXT_RESERVED_FIELDS_LEN + <Note as Packable>::N + MESSAGE_EXPANDED_METADATA_LEN]
+where
+    Note: NoteType + Packable,
+{
+    encode_private_note_message_with_msg_type_id(
+        PRIVATE_NOTE_MSG_TYPE_ID,
+        note,
+        owner,
+        storage_slot,
+        randomness,
+    )
 }
 
 /// Decodes the plaintext from a private note message (i.e. one of type [`PRIVATE_NOTE_MSG_TYPE_ID`]).

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

@@ -4,7 +4,9 @@ pub mod offchain;
 mod message_context;
 pub use message_context::MessageContext;
 
-pub(crate) mod note_validation_request;
+mod note_validation_request;
+pub use note_validation_request::NoteValidationRequest;
+
 pub(crate) mod log_retrieval_request;
 pub(crate) mod log_retrieval_response;
 pub(crate) mod pending_tagged_log;
@@ -17,10 +19,7 @@ use crate::{
         discovery::partial_notes::DeliveredPendingPartialNote,
         encoding::MESSAGE_CIPHERTEXT_LEN,
         logs::{event::MAX_EVENT_SERIALIZED_LEN, note::MAX_NOTE_PACKED_LEN},
-        processing::{
-            log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse,
-            note_validation_request::NoteValidationRequest,
-        },
+        processing::{log_retrieval_request::LogRetrievalRequest, log_retrieval_response::LogRetrievalResponse},
     },
     oracle::message_processing,
 };

noir-projects/aztec-nr/aztec/src/messages/processing/note_validation_request.nr

@@ -1,11 +1,11 @@
 use crate::messages::logs::note::MAX_NOTE_PACKED_LEN;
-use crate::protocol::{address::AztecAddress, traits::Serialize};
+use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};
 
 /// Intermediate struct used to perform batch note validation by PXE. The
 /// `aztec_utl_validateAndStoreEnqueuedNotesAndEvents` oracle expects for values of this type to be stored in a
 /// `EphemeralArray`.
-#[derive(Serialize)]
-pub(crate) struct NoteValidationRequest {
+#[derive(Serialize, Deserialize)]
+pub struct NoteValidationRequest {
     pub contract_address: AztecAddress,
     pub owner: AztecAddress,
     pub storage_slot: Field,

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

@@ -33,7 +33,7 @@ pub struct ConfirmedNote<Note> {
     /// The note hash used to prove existence.
     ///
     /// Whether this note hash is unsiloed or unique depends on the note's metadata.
-    pub(crate) proven_note_hash: Field,
+    pub proven_note_hash: Field,
 }
 
 impl<Note> ConfirmedNote<Note> {