feat: testing private events from Aztec.nr

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

@@ -1,5 +1,8 @@
 use crate::{
-    macros::utils::{compute_struct_selector, derive_serialize_if_not_implemented, get_trait_impl_method},
+    macros::utils::{
+        compute_struct_selector, derive_deserialize_if_not_implemented, derive_serialize_if_not_implemented,
+        get_trait_impl_method,
+    },
     utils::cmap::CHashMap,
 };
 use std::panic;
@@ -47,11 +50,13 @@ pub comptime fn event(s: TypeDefinition) -> Quoted {
     register_event_selector(event_selector, s.name());
 
     let serialize_impl = derive_serialize_if_not_implemented(s);
+    let deserialize_impl = derive_deserialize_if_not_implemented(s);
 
     s.add_attribute("abi(events)");
 
     quote {
         $event_interface_impl
         $serialize_impl
+        $deserialize_impl
     }
 }

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

@@ -1,4 +1,4 @@
-use crate::protocol::meta::derive_serialize;
+use crate::protocol::meta::{derive_deserialize, derive_serialize};
 use std::meta::{ctstring::AsCtString, unquote};
 
 pub(crate) comptime fn is_fn_external(f: FunctionDefinition) -> bool {
@@ -164,3 +164,13 @@ pub comptime fn derive_serialize_if_not_implemented(s: TypeDefinition) -> Quoted
         derive_serialize(s)
     }
 }
+
+/// Generates a quote that implements `Deserialize` for a given struct `s`. If the struct already implements
+/// `Deserialize`, we return an empty quote.
+pub comptime fn derive_deserialize_if_not_implemented(s: TypeDefinition) -> Quoted {
+    if s.as_type().implements(quote { crate::protocol::traits::Deserialize }.as_trait_constraint()) {
+        quote {}
+    } else {
+        derive_deserialize(s)
+    }
+}

noir-projects/aztec-nr/aztec/src/test/helpers/test_environment/test/events.nr

@@ -1,5 +1,4 @@
-use crate::event::{event_emission::emit_event_in_private, event_interface::EventInterface};
-use crate::protocol::traits::Serialize;
+use crate::event::event_emission::emit_event_in_private;
 use crate::test::{helpers::test_environment::TestEnvironment, mocks::mock_event::MockEvent};
 
 global VALUE: Field = 7;
@@ -16,14 +15,11 @@ unconstrained fn emit_and_discover_event() {
 
     env.discover_event(event_message, recipient);
 
-    let events = crate::test::helpers::txe_oracles::get_private_events(
-        MockEvent::get_event_type_id(),
-        TestEnvironment::get_default_address(),
-        recipient,
-    );
+    let events: BoundedVec<MockEvent, _> =
+        crate::test::helpers::txe_oracles::get_private_events(TestEnvironment::get_default_address(), recipient);
 
     assert_eq(events.len(), 1);
-    assert_eq(events.get(0), BoundedVec::from_array(event.serialize()));
+    assert_eq(events.get(0), event);
 }
 
 #[test]
@@ -42,15 +38,12 @@ unconstrained fn emit_and_discover_multiple_events() {
     env.discover_event(event_messages.0, recipient);
     env.discover_event(event_messages.1, recipient);
 
-    let events = crate::test::helpers::txe_oracles::get_private_events(
-        MockEvent::get_event_type_id(),
-        TestEnvironment::get_default_address(),
-        recipient,
-    );
+    let events: BoundedVec<MockEvent, _> =
+        crate::test::helpers::txe_oracles::get_private_events(TestEnvironment::get_default_address(), recipient);
 
     assert_eq(events.len(), 2);
-    assert(events.any(|ev| ev == BoundedVec::from_array(event.serialize())));
-    assert(events.any(|ev| ev == BoundedVec::from_array(other_event.serialize())));
+    assert(events.any(|ev| ev == event));
+    assert(events.any(|ev| ev == other_event));
 }
 
 #[test]
@@ -66,14 +59,11 @@ unconstrained fn emit_and_discover_same_event_multiple_times() {
     env.discover_event(event_message, recipient);
     env.discover_event(event_message, recipient);
 
-    let events = crate::test::helpers::txe_oracles::get_private_events(
-        MockEvent::get_event_type_id(),
-        TestEnvironment::get_default_address(),
-        recipient,
-    );
+    let events: BoundedVec<MockEvent, _> =
+        crate::test::helpers::txe_oracles::get_private_events(TestEnvironment::get_default_address(), recipient);
 
     assert_eq(events.len(), 1);
-    assert_eq(events.get(0), BoundedVec::from_array(event.serialize()));
+    assert_eq(events.get(0), event);
 }
 
 #[test]
@@ -89,11 +79,8 @@ unconstrained fn emit_and_fail_to_discover_event_as_other_recipient() {
 
     env.discover_event(event_message, recipient);
 
-    let events = crate::test::helpers::txe_oracles::get_private_events(
-        MockEvent::get_event_type_id(),
-        TestEnvironment::get_default_address(),
-        other_recipient,
-    );
+    let events: BoundedVec<MockEvent, _> =
+        crate::test::helpers::txe_oracles::get_private_events(TestEnvironment::get_default_address(), other_recipient);
 
     assert_eq(events.len(), 0);
 }
@@ -112,12 +99,9 @@ unconstrained fn emit_and_discover_event_multiple_recipients() {
     env.discover_event(event_message, recipient);
     env.discover_event(event_message, other_recipient);
 
-    let events = crate::test::helpers::txe_oracles::get_private_events(
-        MockEvent::get_event_type_id(),
-        TestEnvironment::get_default_address(),
-        recipient,
-    );
+    let events: BoundedVec<MockEvent, _> =
+        crate::test::helpers::txe_oracles::get_private_events(TestEnvironment::get_default_address(), recipient);
 
     assert_eq(events.len(), 1);
-    assert_eq(events.get(0), BoundedVec::from_array(event.serialize()));
+    assert_eq(events.get(0), event);
 }

noir-projects/aztec-nr/aztec/src/test/helpers/txe_oracles.nr

@@ -1,4 +1,8 @@
-use crate::{context::inputs::PrivateContextInputs, event::EventSelector, test::helpers::utils::TestAccount};
+use crate::{
+    context::inputs::PrivateContextInputs,
+    event::{event_interface::EventInterface, EventSelector},
+    test::helpers::utils::TestAccount,
+};
 
 use crate::protocol::{
     abis::function_selector::FunctionSelector,
@@ -8,6 +12,7 @@ use crate::protocol::{
     },
     contract_instance::ContractInstance,
     traits::{Deserialize, ToField},
+    utils::reader::Reader,
 };
 
 global MAX_PRIVATE_EVENTS_PER_TXE_QUERY: u32 = 5;
@@ -79,19 +84,21 @@ pub unconstrained fn get_last_tx_effects() -> (Field, BoundedVec<Field, MAX_NOTE
 pub unconstrained fn get_default_address() -> AztecAddress {}
 
 // experimental
-pub(crate) unconstrained fn get_private_events(
-    selector: EventSelector,
+pub unconstrained fn get_private_events<Event>(
     contract_address: AztecAddress,
     scope: AztecAddress,
-) -> BoundedVec<BoundedVec<Field, MAX_EVENT_SERIALIZATION_LENGTH>, MAX_PRIVATE_EVENTS_PER_TXE_QUERY> {
-    // This is a workaround as Noir does not currently let us return nested structs with arrays. We instead return a
-    // raw multidimensional array in get_private_events_oracle and create the BoundedVecs here.
-
-    let (raw_array_storage, event_lengths, query_length) = get_private_events_oracle(selector, contract_address, scope);
+) -> BoundedVec<Event, MAX_PRIVATE_EVENTS_PER_TXE_QUERY>
+where
+    Event: EventInterface + Deserialize,
+{
+    let selector = Event::get_event_type_id();
+    let (raw_array_storage, _event_lengths, query_length) =
+        get_private_events_oracle(selector, contract_address, scope);
 
     let mut events = BoundedVec::new();
     for i in 0..query_length {
-        events.push(BoundedVec::from_parts(raw_array_storage[i], event_lengths[i]));
+        let mut reader = Reader::new(raw_array_storage[i]);
+        events.push(Deserialize::stream_deserialize(&mut reader));
     }
 
     events

noir-projects/aztec-nr/aztec/src/test/mocks/mock_event.nr

@@ -2,9 +2,9 @@
 
 use crate::{event::{event_emission::NewEvent, event_interface::EventInterface, EventSelector}, oracle::random::random};
 
-use crate::protocol::traits::{FromField, Serialize};
+use crate::protocol::traits::{Deserialize, FromField, Serialize};
 
-#[derive(Eq, Serialize)]
+#[derive(Eq, Serialize, Deserialize)]
 pub(crate) struct MockEvent {
     pub(crate) value: Field,
 }

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

@@ -45,10 +45,10 @@ pub contract Token {
     global RECURSIVE_TRANSFER_CALL_MAX_NOTES: u32 = 8;
 
     #[event]
-    struct Transfer {
-        from: AztecAddress,
-        to: AztecAddress,
-        amount: u128,
+    pub struct Transfer {
+        pub from: AztecAddress,
+        pub to: AztecAddress,
+        pub amount: u128,
     }
 
     // docs:start:storage_struct
@@ -243,7 +243,7 @@ pub contract Token {
         self.storage.balances.at(from).add(change).deliver(MessageDelivery.ONCHAIN_UNCONSTRAINED);
         self.storage.balances.at(to).add(amount).deliver(MessageDelivery.ONCHAIN_UNCONSTRAINED);
 
-        // We don't constrain encryption of the note log in `transfer` (unlike in `transfer_in_private`) because the transfer
+        // We don't constrain encryption of the event log here (unlike in `transfer_in_private`) because the transfer
         // function is only designed to be used in situations where the event is not strictly necessary (e.g. payment to
         // another person where the payment is considered to be successful when the other party successfully decrypts a
         // note).

noir-projects/noir-contracts/contracts/app/token_contract/src/test/transfer.nr

@@ -18,6 +18,8 @@ unconstrained fn transfer_private() {
         mint_amount - transfer_amount,
     );
     utils::check_private_balance(env, token_contract_address, recipient, transfer_amount);
+
+    utils::check_private_transfer_event(token_contract_address, owner, recipient, transfer_amount);
 }
 
 #[test]
@@ -32,6 +34,8 @@ unconstrained fn transfer_private_to_self() {
 
     // Check balances
     utils::check_private_balance(env, token_contract_address, owner, mint_amount);
+
+    utils::check_private_transfer_event(token_contract_address, owner, owner, transfer_amount);
 }
 
 #[test]
@@ -56,6 +60,13 @@ unconstrained fn transfer_private_to_non_deployed_account() {
         mint_amount - transfer_amount,
     );
     utils::check_private_balance(env, token_contract_address, not_deployed, transfer_amount);
+
+    utils::check_private_transfer_event(
+        token_contract_address,
+        owner,
+        not_deployed,
+        transfer_amount,
+    );
 }
 
 #[test(should_fail_with = "Balance too low")]

noir-projects/noir-contracts/contracts/app/token_contract/src/test/utils.nr

@@ -86,6 +86,26 @@ pub unconstrained fn check_private_balance(
     );
 }
 
+pub unconstrained fn check_private_transfer_event(
+    token_contract_address: AztecAddress,
+    from: AztecAddress,
+    to: AztecAddress,
+    amount: u128,
+) {
+    let events = aztec::test::helpers::txe_oracles::get_private_events::<Token::Transfer>(
+        token_contract_address,
+        to,
+    );
+
+    assert_eq(events.len(), 1);
+
+    let event = events.get(0);
+
+    assert_eq(event.from, from);
+    assert_eq(event.to, to);
+    assert_eq(event.amount, amount);
+}
+
 // While authwits authorize a contract to perform an action, spending private notes still requires
 // knowledge of the note secrets. For private tokens, the note owner must be involved in the
 // transaction -- they cannot simply give another user an authwit and have that user spend the notes

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

@@ -6,7 +6,7 @@ pub contract TestLog {
         macros::{events::event, functions::external, storage::storage},
         messages::message_delivery::MessageDelivery,
         oracle::random::random,
-        protocol::{address::AztecAddress, traits::{FromField, Serialize}},
+        protocol::{address::AztecAddress, traits::{Deserialize, FromField, Serialize}},
         state_vars::{Owned, PrivateSet},
     };
     use field_note::FieldNote;
@@ -23,7 +23,7 @@ pub contract TestLog {
         value3: u8,
     }
 
-    #[derive(Serialize)]
+    #[derive(Deserialize, Serialize)]
     struct NestedStruct {
         a: Field,
         b: Field,

noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr

@@ -240,7 +240,7 @@ pub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {
         let deserialization_of_struct_members = params
             .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {
                 quote {
-                    let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);
+                    let $param_name = <$param_type as $crate::serialization::Deserialize>::stream_deserialize(reader);
                 }
             })
             .join(quote {});
@@ -275,7 +275,7 @@ pub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {
 
             fn deserialize(fields: [Field; Self::N]) -> Self {
                 let mut reader = $crate::reader::Reader::new(fields);
-                let result = Self::stream_deserialize(&mut reader);
+                let result = <Self as $crate::serialization::Deserialize>::stream_deserialize(&mut reader);
                 reader.finish();
                 result
             }