feat(aztec-nr)!: embed BoundedVec max length in validation requests (#23622)

## Problem

`NoteValidationRequest` and `EventValidationRequest` contain a
`BoundedVec` whose `maxLen` is needed for deserialization, but it was
passed as a separate oracle parameter (`maxNotePackedLen` /
`maxEventSerializedLen`). This meant that we can't build a
self-contained `TypeMapping` for it, and we wouldn't be able to build
auto generated mappings in the future

## Fix

Each struct now includes its own max length field (`max_note_packed_len`
/ `max_event_serialized_len`) that is populated automatically via a
`new` constructor from the compile-time constant. The TypeScript
`fromFields` methods read the length from the field stream instead of
taking it as a parameter, making them self-contained.

Author: nchamo

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

@@ -6,16 +6,39 @@ use crate::protocol::{address::AztecAddress, traits::Serialize};
 /// `EphemeralArray` at the given `base_slot`.
 #[derive(Serialize)]
 pub(crate) struct EventValidationRequest {
-    pub contract_address: AztecAddress,
-    pub event_type_id: EventSelector,
-    pub randomness: Field,
-    pub serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,
-    pub event_commitment: Field,
-    pub tx_hash: Field,
+    contract_address: AztecAddress,
+    event_type_id: EventSelector,
+    randomness: Field,
+    max_event_serialized_len: Field,
+    serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,
+    event_commitment: Field,
+    tx_hash: Field,
+}
+
+impl EventValidationRequest {
+    pub(crate) fn new(
+        contract_address: AztecAddress,
+        event_type_id: EventSelector,
+        randomness: Field,
+        serialized_event: BoundedVec<Field, MAX_EVENT_SERIALIZED_LEN>,
+        event_commitment: Field,
+        tx_hash: Field,
+    ) -> Self {
+        Self {
+            contract_address,
+            event_type_id,
+            randomness,
+            max_event_serialized_len: MAX_EVENT_SERIALIZED_LEN as Field,
+            serialized_event,
+            event_commitment,
+            tx_hash,
+        }
+    }
 }
 
 mod test {
     use crate::event::EventSelector;
+    use crate::messages::logs::event::MAX_EVENT_SERIALIZED_LEN;
     use crate::protocol::{address::AztecAddress, traits::{FromField, Serialize}};
     use super::EventValidationRequest;
 
@@ -25,6 +48,7 @@ mod test {
             contract_address: AztecAddress::from_field(1),
             event_type_id: EventSelector::from_field(2),
             randomness: 3,
+            max_event_serialized_len: MAX_EVENT_SERIALIZED_LEN as Field,
             serialized_event: BoundedVec::from_array([4, 5]),
             event_commitment: 6,
             tx_hash: 7,
@@ -38,9 +62,17 @@ mod test {
             1, // contract_address
             2, // event_type_id
             3, // randomness
+            MAX_EVENT_SERIALIZED_LEN as Field,
             4, // serialized_event[0]
             5, // serialized_event[1]
-            0, 0, 0, 0, 0, 0, 0, 0, // serialized_event padding
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0, // serialized_event padding
             2, // bounded_vec_len
             6, // event_commitment
             7, // tx_hash

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

@@ -83,19 +83,17 @@ pub unconstrained fn enqueue_note_for_validation(
     nullifier: Field,
     tx_hash: Field,
 ) {
-    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(
-        NoteValidationRequest {
-            contract_address,
-            owner,
-            storage_slot,
-            randomness,
-            note_nonce,
-            packed_note,
-            note_hash,
-            nullifier,
-            tx_hash,
-        },
-    )
+    EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(NoteValidationRequest::new(
+        contract_address,
+        owner,
+        storage_slot,
+        randomness,
+        note_nonce,
+        packed_note,
+        note_hash,
+        nullifier,
+        tx_hash,
+    ))
 }
 
 /// Enqueues an event for validation and storage by PXE.
@@ -118,16 +116,14 @@ pub unconstrained fn enqueue_event_for_validation(
     event_commitment: Field,
     tx_hash: Field,
 ) {
-    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(
-        EventValidationRequest {
-            contract_address,
-            event_type_id,
-            randomness,
-            serialized_event,
-            event_commitment,
-            tx_hash,
-        },
-    )
+    EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT).push(EventValidationRequest::new(
+        contract_address,
+        event_type_id,
+        randomness,
+        serialized_event,
+        event_commitment,
+        tx_hash,
+    ))
 }
 
 /// Validates and stores all enqueued notes and events.
@@ -139,8 +135,6 @@ pub unconstrained fn validate_and_store_enqueued_notes_and_events(scope: AztecAd
     message_processing::validate_and_store_enqueued_notes_and_events(
         EphemeralArray::at(NOTE_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),
         EphemeralArray::at(EVENT_VALIDATION_REQUESTS_ARRAY_BASE_SLOT),
-        MAX_NOTE_PACKED_LEN as Field,
-        MAX_EVENT_SERIALIZED_LEN as Field,
         scope,
     );
 

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

@@ -6,18 +6,47 @@ use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};
 /// `EphemeralArray`.
 #[derive(Serialize, Deserialize)]
 pub struct NoteValidationRequest {
-    pub contract_address: AztecAddress,
-    pub owner: AztecAddress,
-    pub storage_slot: Field,
-    pub randomness: Field,
-    pub note_nonce: Field,
-    pub packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,
-    pub note_hash: Field,
-    pub nullifier: Field,
-    pub tx_hash: Field,
+    contract_address: AztecAddress,
+    owner: AztecAddress,
+    storage_slot: Field,
+    randomness: Field,
+    note_nonce: Field,
+    max_note_packed_len: Field,
+    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,
+    note_hash: Field,
+    nullifier: Field,
+    tx_hash: Field,
+}
+
+impl NoteValidationRequest {
+    pub fn new(
+        contract_address: AztecAddress,
+        owner: AztecAddress,
+        storage_slot: Field,
+        randomness: Field,
+        note_nonce: Field,
+        packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,
+        note_hash: Field,
+        nullifier: Field,
+        tx_hash: Field,
+    ) -> Self {
+        Self {
+            contract_address,
+            owner,
+            storage_slot,
+            randomness,
+            note_nonce,
+            max_note_packed_len: MAX_NOTE_PACKED_LEN as Field,
+            packed_note,
+            note_hash,
+            nullifier,
+            tx_hash,
+        }
+    }
 }
 
 mod test {
+    use crate::messages::logs::note::MAX_NOTE_PACKED_LEN;
     use crate::protocol::{address::AztecAddress, traits::{FromField, Serialize}};
     use super::NoteValidationRequest;
 
@@ -29,6 +58,7 @@ mod test {
             storage_slot: 2,
             randomness: 42,
             note_nonce: 3,
+            max_note_packed_len: MAX_NOTE_PACKED_LEN as Field,
             packed_note: BoundedVec::from_array([4, 5]),
             note_hash: 6,
             nullifier: 7,
@@ -45,6 +75,7 @@ mod test {
             0x0000000000000000000000000000000000000000000000000000000000000002,
             0x000000000000000000000000000000000000000000000000000000000000002a,
             0x0000000000000000000000000000000000000000000000000000000000000003,
+            MAX_NOTE_PACKED_LEN as Field,
             0x0000000000000000000000000000000000000000000000000000000000000004,
             0x0000000000000000000000000000000000000000000000000000000000000005,
             0x0000000000000000000000000000000000000000000000000000000000000000,

noir-projects/aztec-nr/aztec/src/oracle/message_processing.nr

@@ -20,25 +20,15 @@ unconstrained fn get_pending_tagged_logs_oracle(scope: AztecAddress) -> Ephemera
 pub(crate) unconstrained fn validate_and_store_enqueued_notes_and_events(
     note_validation_requests: EphemeralArray<NoteValidationRequest>,
     event_validation_requests: EphemeralArray<EventValidationRequest>,
-    max_note_packed_len: Field,
-    max_event_serialized_len: Field,
     scope: AztecAddress,
 ) {
-    validate_and_store_enqueued_notes_and_events_oracle(
-        note_validation_requests,
-        event_validation_requests,
-        max_note_packed_len,
-        max_event_serialized_len,
-        scope,
-    );
+    validate_and_store_enqueued_notes_and_events_oracle(note_validation_requests, event_validation_requests, scope);
 }
 
 #[oracle(aztec_utl_validateAndStoreEnqueuedNotesAndEvents)]
 unconstrained fn validate_and_store_enqueued_notes_and_events_oracle(
     note_validation_requests: EphemeralArray<NoteValidationRequest>,
     event_validation_requests: EphemeralArray<EventValidationRequest>,
-    max_note_packed_len: Field,
-    max_event_serialized_len: Field,
     scope: AztecAddress,
 ) {}
 

noir-projects/aztec-nr/aztec/src/oracle/version.nr

@@ -10,7 +10,7 @@
 /// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw
 /// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency
 /// without actually using any of the new oracles then there is no reason to throw.
-pub global ORACLE_VERSION_MAJOR: Field = 25;
+pub global ORACLE_VERSION_MAJOR: Field = 26;
 pub global ORACLE_VERSION_MINOR: Field = 1;
 
 /// Asserts that the version of the oracle is compatible with the version expected by the contract.

noir-projects/noir-contracts/contracts/app/private_token_contract/src/main.nr

@@ -33,7 +33,9 @@ pub contract PrivateToken {
         // Admin itself is the owner of the underlying note because we want admin to be able to transfer the admin
         // privileges to someone else which requires being able to nullify the note. We use constrained onchain message
         // delivery because we don't know if the party deploying this contract is incentivized to deliver the note.
-        self.storage.admin.initialize(AddressNote { address: admin }, admin).deliver(MessageDelivery::onchain_constrained());
+        self.storage.admin.initialize(AddressNote { address: admin }, admin).deliver(
+            MessageDelivery::onchain_constrained(),
+        );
 
         // Mint the initial admin balance to the admin.
         self.storage.balances.at(admin).add(initial_admin_balance).deliver(MessageDelivery::onchain_constrained());

noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr

@@ -10,7 +10,7 @@
 /// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw
 /// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency
 /// without actually using any of the new oracles then there is no reason to throw.
-pub global ORACLE_VERSION_MAJOR: Field = 25;
+pub global ORACLE_VERSION_MAJOR: Field = 26;
 pub global ORACLE_VERSION_MINOR: Field = 0;
 
 /// Asserts that the version of the oracle is compatible with the version expected by the contract.

noir-projects/noir-contracts/contracts/test/custom_sync_state_contract/src/main.nr

@@ -31,9 +31,7 @@ contract CustomSyncState {
     #[initializer]
     fn constructor(owner: AztecAddress, value: Field) {
         let note = FieldNote { value };
-        self.storage.value.at(owner).initialize(note).deliver(
-            MessageDelivery::onchain_unconstrained(),
-        );
+        self.storage.value.at(owner).initialize(note).deliver(MessageDelivery::onchain_unconstrained());
     }
 
     #[external("utility")]

noir-projects/noir-contracts/contracts/test/state_vars_contract/src/main.nr

@@ -106,7 +106,9 @@ pub contract StateVars {
         let owner = self.msg_sender();
         let private_mutable = FieldNote { value };
 
-        self.storage.private_mutable.at(owner).initialize(private_mutable).deliver(MessageDelivery::onchain_constrained());
+        self.storage.private_mutable.at(owner).initialize(private_mutable).deliver(
+            MessageDelivery::onchain_constrained(),
+        );
     }
 
     #[external("private")]

yarn-project/pxe/src/contract_function_simulator/noir-structs/event_validation_request.test.ts

@@ -11,6 +11,7 @@ describe('EventValidationRequest', () => {
       1, // contract_address
       2, // event_type_id
       3, // randomness
+      10, // max_event_serialized_len
       4, // serialized_event[0]
       5, // serialized_event[1]
       0, // serialized_event padding start
@@ -26,7 +27,7 @@ describe('EventValidationRequest', () => {
       7, // tx_hash
     ].map(n => new Fr(n));
 
-    const request = EventValidationRequest.fromFields(serialized, 10);
+    const request = EventValidationRequest.fromFields(serialized);
 
     expect(request.contractAddress).toEqual(AztecAddress.fromBigInt(1n));
     expect(request.eventTypeId).toEqual(new EventSelector(2));
@@ -41,9 +42,10 @@ describe('EventValidationRequest', () => {
       1, // contract_address
       2, // event_type_id
       3, // randomness
+      10, // max_event_serialized_len (10)
       4, // serialized_event[0]
       5, // serialized_event[1]
-      0, // serialized_event padding (11 storage fields total, but maxEventSerializedLen=10)
+      0, // serialized_event padding (11 storage fields total, but max_event_serialized_len=10)
       0,
       0,
       0,
@@ -57,8 +59,8 @@ describe('EventValidationRequest', () => {
       7, // tx_hash
     ].map(n => new Fr(n));
 
-    expect(() => EventValidationRequest.fromFields(serialized, 10)).toThrow(
-      'Error converting array of fields to EventValidationRequest: expected 16 fields but received 17 (maxEventSerializedLen=10).',
+    expect(() => EventValidationRequest.fromFields(serialized)).toThrow(
+      'Error converting array of fields to EventValidationRequest: expected 17 fields but received 18 (maxEventSerializedLen=10).',
     );
   });
 });