chore: merge merge-train/fairies-v5 into oracle-structs branch

Author: nchamo

noir-projects/aztec-nr/aztec/src/messages/delivery/constrained_delivery.nr

@@ -9,7 +9,6 @@
 //! See [`constrain_secret`] for how a send is anchored to the registry,
 
 use crate::context::PrivateContext;
-use crate::messages::delivery::OnchainDeliveryMode;
 use crate::nullifier::utils::compute_nullifier_existence_request;
 
 use crate::protocol::{
@@ -21,7 +20,7 @@ use crate::protocol::{
 // registry's test suite compares this against its macro-generated `HandshakeRegistry::at(...).method(...).selector`
 // value so signature drift fails in tests.
 pub global VALIDATE_HANDSHAKE_SELECTOR: FunctionSelector =
-    comptime { FunctionSelector::from_signature("validate_handshake((Field),(Field),(u8),Field)") };
+    comptime { FunctionSelector::from_signature("validate_handshake((Field),(Field),Field)") };
 
 pub(crate) fn constrain_secret_and_emit_nullifier(
     context: &mut PrivateContext,
@@ -60,16 +59,14 @@ fn constrain_secret(
     index: u32,
 ) {
     let caller = context.this_address();
-    let mode = OnchainDeliveryMode::onchain_constrained();
-    let mode_field = mode.to_field();
 
     if bootstrapped {
         assert(index == 0, "freshly bootstrapped secret must start at index 0");
     } else if index == 0 {
         let _ = context.call_private_function(
             registry,
             VALIDATE_HANDSHAKE_SELECTOR,
-            [sender.to_field(), recipient.to_field(), mode_field, secret],
+            [sender.to_field(), recipient.to_field(), secret],
         );
     } else {
         let prev_nullifier = compute_constrained_msg_nullifier(sender, recipient, secret, index - 1);
@@ -96,7 +93,6 @@ pub(crate) fn compute_constrained_msg_nullifier(
 mod test {
     use crate::context::PrivateContext;
     use crate::hash::hash_args;
-    use crate::messages::delivery::OnchainDeliveryMode;
     use crate::protocol::{address::AztecAddress, hash::compute_siloed_nullifier, traits::{FromField, ToField}};
     use crate::test::helpers::test_environment::TestEnvironment;
     use super::{compute_constrained_msg_nullifier, constrain_secret_and_emit_nullifier, VALIDATE_HANDSHAKE_SELECTOR};
@@ -175,15 +171,7 @@ mod test {
             assert_eq(request.call_context.contract_address, registry);
             assert_eq(request.call_context.function_selector, VALIDATE_HANDSHAKE_SELECTOR);
             assert(!request.call_context.is_static_call);
-            assert_eq(
-                request.args_hash,
-                hash_args([
-                    sender.to_field(),
-                    recipient.to_field(),
-                    OnchainDeliveryMode::onchain_constrained().to_field(),
-                    secret,
-                ]),
-            );
+            assert_eq(request.args_hash, hash_args([sender.to_field(), recipient.to_field(), secret]));
         });
     }
 

noir-projects/aztec-nr/aztec/src/messages/delivery/handshake.nr

@@ -1,11 +1,10 @@
-use crate::messages::delivery::OnchainDeliveryMode;
 use crate::protocol::point::EmbeddedCurvePoint;
 use crate::protocol::traits::{Deserialize, Serialize};
 
 use crate::{
     context::PrivateContext,
     ephemeral::EphemeralArray,
-    messages::processing::provided_secret::ProvidedSecret,
+    messages::{delivery::OnchainDeliveryMode, processing::provided_secret::ProvidedSecret},
     oracle::{call_utility_function::call_utility_function, shared_secret::get_shared_secrets},
     protocol::{
         abis::function_selector::FunctionSelector, address::AztecAddress, hash::sha256_to_field, traits::ToField,
@@ -16,11 +15,10 @@ use crate::{
 /// Page size for handshake discovery pagination.
 pub global MAX_HANDSHAKES_PER_PAGE: u32 = 32;
 
-/// A handshake discovered during sync: the sender's ephemeral public key and the delivery mode.
+/// A handshake discovered during sync: the sender's ephemeral public key.
 #[derive(Deserialize, Eq, Serialize)]
 pub struct DiscoveredHandshake {
     pub eph_pk: EmbeddedCurvePoint,
-    pub mode: OnchainDeliveryMode,
 }
 
 /// A paginated response of discovered handshakes.
@@ -35,21 +33,19 @@ pub(crate) global PROVIDED_SECRETS_ARRAY_BASE_SLOT: Field =
 
 global HANDSHAKE_EPH_PKS_SLOT: Field = sha256_to_field("AZTEC_NR::HANDSHAKE_EPH_PKS_SLOT".as_bytes());
 
-global HANDSHAKE_MODES_SLOT: Field = sha256_to_field("AZTEC_NR::HANDSHAKE_MODES_SLOT".as_bytes());
-
 // The helper cannot import the handshake registry interface because the registry contract depends on aztec-nr. These
 // selector constants pin the registry ABI surface this library calls. The registry's test suite compares them against
 // its macro-generated `HandshakeRegistry::at(...).method(...).selector` values so signature drift fails in tests.
 pub global GET_APP_SILOED_SECRET_SELECTOR: FunctionSelector =
-    comptime { FunctionSelector::from_signature("get_app_siloed_secret((Field),(Field),(u8))") };
+    comptime { FunctionSelector::from_signature("get_app_siloed_secret((Field),(Field))") };
 pub global NON_INTERACTIVE_HANDSHAKE_SELECTOR: FunctionSelector =
-    comptime { FunctionSelector::from_signature("non_interactive_handshake((Field),(Field),(u8))") };
+    comptime { FunctionSelector::from_signature("non_interactive_handshake((Field),(Field))") };
 pub global GET_HANDSHAKES_SELECTOR: FunctionSelector =
     comptime { FunctionSelector::from_signature("get_handshakes((Field),u32)") };
 
 /// Resolves the app-siloed handshake secret, bootstrapping when none exists.
 ///
-/// Resolves the secret for `(sender, recipient, mode)`, creating it via the registry's `non_interactive_handshake`
+/// Resolves the secret for `(sender, recipient)`, creating it via the registry's `non_interactive_handshake`
 /// when no handshake exists yet.
 ///
 /// Returns `(secret, bootstrapped)`, where `bootstrapped` is true when this call created the handshake.
@@ -65,10 +61,7 @@ pub(crate) fn get_or_create_app_siloed_handshake_secret(
     registry: AztecAddress,
     sender: AztecAddress,
     recipient: AztecAddress,
-    mode: OnchainDeliveryMode,
 ) -> (Field, bool) {
-    let mode_field = mode.to_field();
-
     // Safety: the response only selects which path runs. On `None` we bootstrap via `non_interactive_handshake`,
     // whose constrained return value is the secret, so a forged empty response cannot fabricate one; it can only
     // trigger an unnecessary re-handshake that replaces the registry note. The caller must constrain the returned
@@ -77,7 +70,7 @@ pub(crate) fn get_or_create_app_siloed_handshake_secret(
         let returns = call_utility_function(
             registry,
             GET_APP_SILOED_SECRET_SELECTOR,
-            [sender.to_field(), recipient.to_field(), mode_field],
+            [sender.to_field(), recipient.to_field()],
         );
         Deserialize::deserialize(returns)
     };
@@ -92,7 +85,7 @@ pub(crate) fn get_or_create_app_siloed_handshake_secret(
             .call_private_function(
                 registry,
                 NON_INTERACTIVE_HANDSHAKE_SELECTOR,
-                [sender.to_field(), recipient.to_field(), mode_field],
+                [sender.to_field(), recipient.to_field()],
             )
             .get_preimage();
 
@@ -110,17 +103,14 @@ pub(crate) unconstrained fn get_handshake_secrets(
     let provided_secrets = EphemeralArray::<ProvidedSecret>::empty_at(PROVIDED_SECRETS_ARRAY_BASE_SLOT);
 
     let eph_pks: EphemeralArray<EmbeddedCurvePoint> = EphemeralArray::empty_at(HANDSHAKE_EPH_PKS_SLOT);
-    let modes: EphemeralArray<OnchainDeliveryMode> = EphemeralArray::empty_at(HANDSHAKE_MODES_SLOT);
 
     let mut page_offset: u32 = 0;
     let mut has_more = true;
     while has_more {
         let page = fetch_handshake_page(scope, page_offset);
 
         for j in 0..page.items.len() {
-            let handshake = page.items.get(j);
-            eph_pks.push(handshake.eph_pk);
-            modes.push(handshake.mode);
+            eph_pks.push(page.items.get(j).eph_pk);
         }
 
         page_offset += page.items.len();
@@ -130,7 +120,10 @@ pub(crate) unconstrained fn get_handshake_secrets(
     if eph_pks.len() > 0 {
         let secrets = get_shared_secrets(scope, eph_pks, contract_address);
         for j in 0..secrets.len() {
-            provided_secrets.push(ProvidedSecret { secret: secrets.get(j), mode: modes.get(j) });
+            let secret = secrets.get(j);
+            // Handshakes are mode-agnostic; emit one entry per on-chain tag domain for PXE to scan.
+            provided_secrets.push(ProvidedSecret { secret, mode: OnchainDeliveryMode::onchain_unconstrained() });
+            provided_secrets.push(ProvidedSecret { secret, mode: OnchainDeliveryMode::onchain_constrained() });
         }
     }
 
@@ -154,27 +147,24 @@ mod test {
         DiscoveredHandshake, get_handshake_secrets, HandshakePage, MAX_HANDSHAKES_PER_PAGE,
     };
     use crate::messages::delivery::OnchainDeliveryMode;
-    use crate::protocol::{address::AztecAddress, traits::Serialize};
+    use crate::protocol::{address::AztecAddress, traits::{FromField, Serialize}};
     use crate::test::helpers::test_environment::TestEnvironment;
     use crate::utils::point::point_from_x_coord;
     use std::test::OracleMock;
 
-    global UNCONSTRAINED: OnchainDeliveryMode = OnchainDeliveryMode::onchain_unconstrained();
-    global CONSTRAINED: OnchainDeliveryMode = OnchainDeliveryMode::onchain_constrained();
-
     #[test]
     unconstrained fn get_handshake_secrets_returns_secrets_from_single_page() {
-        let mut env = TestEnvironment::new();
-        let scope = env.create_light_account();
+        let env = TestEnvironment::new();
+        let scope = AztecAddress::from_field(1);
         let contract_address = AztecAddress { inner: 0xdeadbeef };
 
         env.utility_context_at(contract_address, |_| {
             let pk_a = point_from_x_coord(1).unwrap();
             let pk_b = point_from_x_coord(2).unwrap();
 
             let mut items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();
-            items.push(DiscoveredHandshake { eph_pk: pk_a, mode: UNCONSTRAINED });
-            items.push(DiscoveredHandshake { eph_pk: pk_b, mode: CONSTRAINED });
+            items.push(DiscoveredHandshake { eph_pk: pk_a });
+            items.push(DiscoveredHandshake { eph_pk: pk_b });
             let page = HandshakePage { items, total_count: 2 };
             let _ = OracleMock::mock("aztec_utl_callUtilityFunction").returns(page.serialize());
 
@@ -184,18 +174,22 @@ mod test {
 
             let secrets = get_handshake_secrets(contract_address, scope);
 
-            assert_eq(secrets.len(), 2);
+            assert_eq(secrets.len(), 4);
             assert_eq(secrets.get(0).secret, secret_a);
-            assert_eq(secrets.get(0).mode, UNCONSTRAINED);
-            assert_eq(secrets.get(1).secret, secret_b);
-            assert_eq(secrets.get(1).mode, CONSTRAINED);
+            assert(secrets.get(0).mode == OnchainDeliveryMode::onchain_unconstrained());
+            assert_eq(secrets.get(1).secret, secret_a);
+            assert(secrets.get(1).mode == OnchainDeliveryMode::onchain_constrained());
+            assert_eq(secrets.get(2).secret, secret_b);
+            assert(secrets.get(2).mode == OnchainDeliveryMode::onchain_unconstrained());
+            assert_eq(secrets.get(3).secret, secret_b);
+            assert(secrets.get(3).mode == OnchainDeliveryMode::onchain_constrained());
         });
     }
 
     #[test]
     unconstrained fn get_handshake_secrets_fetches_multiple_pages() {
-        let mut env = TestEnvironment::new();
-        let scope = env.create_light_account();
+        let env = TestEnvironment::new();
+        let scope = AztecAddress::from_field(1);
         let contract_address = AztecAddress { inner: 0xdeadbeef };
 
         env.utility_context_at(contract_address, |_| {
@@ -204,12 +198,12 @@ mod test {
             let pk_c = point_from_x_coord(8).unwrap();
 
             let mut page_1_items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();
-            page_1_items.push(DiscoveredHandshake { eph_pk: pk_a, mode: UNCONSTRAINED });
-            page_1_items.push(DiscoveredHandshake { eph_pk: pk_b, mode: CONSTRAINED });
+            page_1_items.push(DiscoveredHandshake { eph_pk: pk_a });
+            page_1_items.push(DiscoveredHandshake { eph_pk: pk_b });
             let page_1 = HandshakePage { items: page_1_items, total_count: 3 };
 
             let mut page_2_items: BoundedVec<DiscoveredHandshake, MAX_HANDSHAKES_PER_PAGE> = BoundedVec::new();
-            page_2_items.push(DiscoveredHandshake { eph_pk: pk_c, mode: UNCONSTRAINED });
+            page_2_items.push(DiscoveredHandshake { eph_pk: pk_c });
             let page_2 = HandshakePage { items: page_2_items, total_count: 3 };
 
             let _ = OracleMock::mock("aztec_utl_callUtilityFunction").returns(page_1.serialize()).times(1);
@@ -218,13 +212,19 @@ mod test {
             mock_get_shared_secrets([111, 222, 333]);
 
             let secrets = get_handshake_secrets(contract_address, scope);
-            assert_eq(secrets.len(), 3);
+            assert_eq(secrets.len(), 6);
             assert_eq(secrets.get(0).secret, 111);
-            assert_eq(secrets.get(0).mode, UNCONSTRAINED);
-            assert_eq(secrets.get(1).secret, 222);
-            assert_eq(secrets.get(1).mode, CONSTRAINED);
-            assert_eq(secrets.get(2).secret, 333);
-            assert_eq(secrets.get(2).mode, UNCONSTRAINED);
+            assert(secrets.get(0).mode == OnchainDeliveryMode::onchain_unconstrained());
+            assert_eq(secrets.get(1).secret, 111);
+            assert(secrets.get(1).mode == OnchainDeliveryMode::onchain_constrained());
+            assert_eq(secrets.get(2).secret, 222);
+            assert(secrets.get(2).mode == OnchainDeliveryMode::onchain_unconstrained());
+            assert_eq(secrets.get(3).secret, 222);
+            assert(secrets.get(3).mode == OnchainDeliveryMode::onchain_constrained());
+            assert_eq(secrets.get(4).secret, 333);
+            assert(secrets.get(4).mode == OnchainDeliveryMode::onchain_unconstrained());
+            assert_eq(secrets.get(5).secret, 333);
+            assert(secrets.get(5).mode == OnchainDeliveryMode::onchain_constrained());
         });
     }
 

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

@@ -187,6 +187,11 @@ fn resolve_tag_secret_derivation(
         // TODO(F-699): Resolve wallet-default by first reusing an existing handshake for `(sender, recipient, mode)`
         // without consulting wallet policy. If none exists, consult the wallet delivery privacy preference before
         // choosing address-secret delivery or creating a non-interactive handshake.
+        //
+        // Once the privacy preference is oracle-driven, add integration coverage that reuses one mode-agnostic
+        // handshake secret for both constrained and unconstrained onchain delivery tags. Today unconstrained
+        // handshake-derived delivery is rejected, so PXE unit tests cover provided-secret expansion across both tag
+        // domains.
         if mode == DeliveryMode::onchain_constrained() {
             TagSecretDerivation::non_interactive_handshake()
         } else {

noir-projects/aztec-nr/aztec/src/messages/delivery/tag.nr

@@ -59,7 +59,6 @@ fn derive_handshake_log_tag(
         STANDARD_HANDSHAKE_REGISTRY_ADDRESS,
         sender,
         recipient,
-        mode,
     );
 
     // Safety: the returned index is untrusted and is constrained before the tag is emitted.

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

@@ -1,5 +1,4 @@
-use crate::messages::delivery::OnchainDeliveryMode;
-use crate::protocol::traits::{Deserialize, Serialize};
+use crate::{messages::delivery::OnchainDeliveryMode, protocol::traits::{Deserialize, Serialize}};
 
 /// A tagging secret the app supplies explicitly to `get_pending_tagged_logs`.
 ///

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

@@ -19,10 +19,6 @@ use crate::macros::oracle_testing::{generate_oracle_tests, generate_oracle_tests
         // TODO: implement once we support more complex types
         quote { emit_public_log_opcode },
         quote { returndata_copy_opcode },
-        // TODO: requires fix on registry
-        quote { call_opcode },
-        quote { call_static_opcode },
-        quote { success_copy_opcode },
     ],
 )]
 pub mod avm;

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

@@ -2,17 +2,17 @@
 use protocol_types::{address::AztecAddress, traits::FromField};
 
 pub global STANDARD_AUTH_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x2df3bf0052304b37c59cfdb79eeeab7f05f8b1e197293e456dc9c7716e6fc654,
+    0x04fc897b6deff5e3c18900a6a1c8ad601772027a500b8f329083810b7bffaf26,
 );
 
 pub global STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x099e0fdbd90bed29103c75ae755dc43dc06e53c845dd25cf81ec05570a68c2fb,
+    0x1aaa6153c0d5780188c64dd4d2c28372d42e5bcee5210c4184a312db0fe709d0,
 );
 
 pub global STANDARD_PUBLIC_CHECKS_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x2da605de400a83f4c1750fdd1dba3a4b2977884a95549efd06f7a62ef6ae69c3,
+    0x1da099c6dff135d8e519a4e973f27c0e25cf0897d7cf968c7d38329f46df1056,
 );
 
 pub global STANDARD_HANDSHAKE_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x19fca351f28a726da8bd3c66c10f22314bbe6359a61440efbbc0721e019167ef,
+    0x215f91f8907b8d6406a9b209b88b3d8d01c764c81d3704af257a2de6f0cd908d,
 );

noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/standard_addresses.nr

@@ -2,17 +2,17 @@
 use protocol_types::{address::AztecAddress, traits::FromField};
 
 pub global STANDARD_AUTH_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x2df3bf0052304b37c59cfdb79eeeab7f05f8b1e197293e456dc9c7716e6fc654,
+    0x04fc897b6deff5e3c18900a6a1c8ad601772027a500b8f329083810b7bffaf26,
 );
 
 pub global STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x099e0fdbd90bed29103c75ae755dc43dc06e53c845dd25cf81ec05570a68c2fb,
+    0x1aaa6153c0d5780188c64dd4d2c28372d42e5bcee5210c4184a312db0fe709d0,
 );
 
 pub global STANDARD_PUBLIC_CHECKS_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x2da605de400a83f4c1750fdd1dba3a4b2977884a95549efd06f7a62ef6ae69c3,
+    0x1da099c6dff135d8e519a4e973f27c0e25cf0897d7cf968c7d38329f46df1056,
 );
 
 pub global STANDARD_HANDSHAKE_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x19fca351f28a726da8bd3c66c10f22314bbe6359a61440efbbc0721e019167ef,
+    0x215f91f8907b8d6406a9b209b88b3d8d01c764c81d3704af257a2de6f0cd908d,
 );