feat: merge-train/fairies-v5 (#24891)

BEGIN_COMMIT_OVERRIDE
docs(aztec-nr): document partial note completion trust model (#24816)
refactor(aztec-nr): shared no-op sync handler for stateless contracts
(#24844)
fix: dont panic on note msgs on contracts with no notes (#24852)
docs(noir-contracts): document standard-contract re-pin consequences
(#24890)
fix: change init and single claim nullif to incl owner address, add
testing utilities (#24892)
END_COMMIT_OVERRIDE

Author: nchamo

CLAUDE.md

@@ -57,6 +57,10 @@ When staging files, prefer `git add -u` or name specific files rather than `git
 Never bulk-update lockfiles (`Cargo.lock`, `yarn.lock`). Use targeted updates only: `cargo update --precise <version> --package <name>` for Rust, and `yarn up <package>@<version>` in the relevant workspace for TypeScript. Bulk updates drag in unrelated transitive changes that make review impossible and frequently break reproducibility.
 </lockfile_discipline>
 
+<standard_contract_repin>
+Never run `noir-projects/noir-contracts/bootstrap.sh pin-standard-build` on your own initiative. The pin exists so ordinary source or bytecode changes do NOT move the standard contracts' canonical addresses, and CI does not fail when the bytecode drifts. A re-pin is a deliberate redeploy decision for a human to make: if a change seems to need one, leave the pin, rebuild against it, and ask. See the comment on `pin-standard-build` for why re-pinning is breaking.
+</standard_contract_repin>
+
 </git_workflow>
 
 <code_formatting>

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

@@ -9,6 +9,10 @@ Aztec is in active development. Each version may introduce breaking changes that
 
 ## TBD
 
+### [Aztec.nr] Canonical HandshakeRegistry re-pinned at a new address
+
+The canonical `HandshakeRegistry` has been re-pinned so that it includes the owner's address in its `PrivateMutable` initialization nullifiers, keeping the handshake state of accounts that share keys independent. The registry moves to a new address. Handshakes established with the previous registry instance are not visible to the new one and must be re-established. The other standard contracts keep their addresses.
+
 ### [Aztec.nr] Note property selectors are typed and use packed-layout indices
 
 The selectors in the generated `properties()` used the field's position in the note struct declaration, which pointed at the wrong packed field for any note with an earlier field packing to more than one `Field` (a `Point`, an array, a nested struct). Selector indices are now the field's offset in the note's packed representation, so `select`/`sort` criteria constrain the field they name.

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

@@ -44,10 +44,12 @@ pub(crate) comptime fn generate_contract_library_methods_compute_note_hash_and_n
 
 comptime fn generate_contract_library_method_compute_note_hash() -> Quoted {
     if NOTES.len() == 0 {
-        // Contracts with no notes still implement this function to avoid having special-casing, the implementation
-        // simply throws immediately.
+        // Contracts with no notes still implement this function to avoid having special-casing. Since the contract
+        // declares no note types there is never a note to hash, so we return `Option::none()`. This will cause any
+        // messages related to (non-existing) notes to be simply skipped, mirroring the unknown-note-type branch of the
+        // with-notes implementation.
         quote {
-            /// This contract does not use private notes, so this function should never be called as it will unconditionally fail.
+            /// This contract does not use private notes, so this function always returns `Option::none()`.
             ///
             /// This function is automatically injected by the `#[aztec]` macro.
             #[contract_library_method]
@@ -59,7 +61,7 @@ comptime fn generate_contract_library_method_compute_note_hash() -> Quoted {
                 _contract_address: aztec::protocol::address::AztecAddress,
                 _randomness: Field,
             ) -> Option<Field> {
-                panic(f"This contract does not use private notes")
+                Option::none()
             }
         }
     } else {
@@ -155,10 +157,12 @@ comptime fn generate_contract_library_method_compute_note_hash() -> Quoted {
 
 comptime fn generate_contract_library_method_compute_note_nullifier() -> Quoted {
     if NOTES.len() == 0 {
-        // Contracts with no notes still implement this function to avoid having special-casing, the implementation
-        // simply throws immediately.
+        // Contracts with no notes still implement this function to avoid having special-casing. Since the contract
+        // declares no note types there is never a note to nullify, so we return `Option::none()`. This will cause any
+        // messages related to (non-existing) notes to be simply skipped, mirroring the unknown-note-type branch of the
+        // with-notes implementation.
         quote {
-            /// This contract does not use private notes, so this function should never be called as it will unconditionally fail.
+            /// This contract does not use private notes, so this function always returns `Option::none()`.
             ///
             /// This function is automatically injected by the `#[aztec]` macro.
             #[contract_library_method]
@@ -171,7 +175,7 @@ comptime fn generate_contract_library_method_compute_note_nullifier() -> Quoted
                 _contract_address: aztec::protocol::address::AztecAddress,
                 _randomness: Field,
             ) -> Option<Field> {
-                panic(f"This contract does not use private notes")
+                Option::none()
             }
         }
     } else {

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

@@ -174,6 +174,19 @@ pub unconstrained fn do_sync_state_without_handshake_discovery(
     );
 }
 
+/// A [`CustomSyncHandler`] that skips state synchronization entirely.
+///
+/// For contracts that hold no private state and emit no messages, there is nothing to discover: syncing would only
+/// perform unnecessary RPC calls.
+pub unconstrained fn do_sync_state_no_op(
+    _contract_address: AztecAddress,
+    _compute_note_hash: ComputeNoteHash,
+    _compute_note_nullifier: ComputeNoteNullifier,
+    _process_custom_message: Option<CustomMessageHandler>,
+    _offchain_inbox_sync: Option<OffchainInboxSync>,
+    _scope: AztecAddress,
+) {}
+
 unconstrained fn sync_state_with_secrets(
     contract_address: AztecAddress,
     compute_note_hash: ComputeNoteHash,

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

@@ -14,5 +14,5 @@ pub global STANDARD_PUBLIC_CHECKS_ADDRESS: AztecAddress = AztecAddress::from_fie
 );
 
 pub global STANDARD_HANDSHAKE_REGISTRY_ADDRESS: AztecAddress = AztecAddress::from_field(
-    0x086c3c67589e1141c70ed0ed8ae324c51d3bf7c5637043fd84c424ffb625831d,
+    0x06127814dca78709650de6629637194f7381d2e05b35eb9d53a4746636c9aa9d,
 );

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

@@ -12,8 +12,10 @@ use crate::{
 };
 
 use crate::protocol::{
-    address::AztecAddress, constants::DOM_SEP__INITIALIZATION_NULLIFIER, hash::poseidon2_hash_with_separator,
-    traits::Packable,
+    address::AztecAddress,
+    constants::DOM_SEP__INITIALIZATION_NULLIFIER,
+    hash::poseidon2_hash_with_separator,
+    traits::{Packable, ToField},
 };
 
 mod test;
@@ -67,7 +69,7 @@ impl<Note, Context> PrivateImmutable<Note, Context> {
     /// Computes the initialization nullifier using the provided secret.
     fn compute_initialization_nullifier(self, secret: Field) -> Field {
         poseidon2_hash_with_separator(
-            [self.storage_slot, secret],
+            [self.storage_slot, self.owner.to_field(), secret],
             DOM_SEP__INITIALIZATION_NULLIFIER,
         )
     }

noir-projects/aztec-nr/aztec/src/state_vars/private_immutable/test.nr

@@ -1,7 +1,8 @@
 use crate::{
     context::{PrivateContext, UtilityContext},
+    keys::getters::get_public_keys,
     state_vars::{OwnedStateVariable, private_immutable::PrivateImmutable},
-    test::{helpers::test_environment::TestEnvironment, mocks::mock_note::MockNote},
+    test::{helpers::test_environment::{CreateAccountOptions, TestEnvironment}, mocks::mock_note::MockNote},
 };
 use crate::protocol::address::AztecAddress;
 
@@ -197,6 +198,22 @@ unconstrained fn initialize_twice_same_tx() {
     });
 }
 
+#[test]
+unconstrained fn shared_keys_distinct_addresses_have_distinct_initialization_nullifiers() {
+    let mut env = TestEnvironment::new();
+
+    let owner_a = env.create_light_account_opts(CreateAccountOptions::new().with_secret(42));
+    let owner_b = env.create_light_account_opts(CreateAccountOptions::new().with_secret(42));
+
+    assert(owner_a != owner_b);
+    env.utility_context(|_| { assert_eq(get_public_keys(owner_a).npk_m_hash, get_public_keys(owner_b).npk_m_hash); });
+
+    let nullifier_a = env.private_context(|context| in_private(context, owner_a).get_initialization_nullifier());
+    let nullifier_b = env.private_context(|context| in_private(context, owner_b).get_initialization_nullifier());
+
+    assert(nullifier_a != nullifier_b);
+}
+
 #[test(should_fail_with = "already present")]
 unconstrained fn initialize_twice_other_tx() {
     let mut env = TestEnvironment::new();

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

@@ -12,8 +12,10 @@ use crate::{
 };
 
 use crate::protocol::{
-    address::AztecAddress, constants::DOM_SEP__INITIALIZATION_NULLIFIER, hash::poseidon2_hash_with_separator,
-    traits::Packable,
+    address::AztecAddress,
+    constants::DOM_SEP__INITIALIZATION_NULLIFIER,
+    hash::poseidon2_hash_with_separator,
+    traits::{Packable, ToField},
 };
 
 mod test;
@@ -86,7 +88,7 @@ impl<Note, Context> PrivateMutable<Note, Context> {
     /// Computes the initialization nullifier using the provided secret.
     fn compute_initialization_nullifier(self, secret: Field) -> Field {
         poseidon2_hash_with_separator(
-            [self.storage_slot, secret],
+            [self.storage_slot, self.owner.to_field(), secret],
             DOM_SEP__INITIALIZATION_NULLIFIER,
         )
     }

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

@@ -1,7 +1,8 @@
 use crate::{
     context::{PrivateContext, UtilityContext},
+    keys::getters::get_public_keys,
     state_vars::{OwnedStateVariable, private_mutable::PrivateMutable},
-    test::{helpers::test_environment::TestEnvironment, mocks::mock_note::MockNote},
+    test::{helpers::test_environment::{CreateAccountOptions, TestEnvironment}, mocks::mock_note::MockNote},
 };
 use crate::protocol::address::AztecAddress;
 
@@ -339,6 +340,22 @@ unconstrained fn initialize_or_replace_initialized_settled() {
     });
 }
 
+#[test]
+unconstrained fn shared_keys_distinct_addresses_have_distinct_initialization_nullifiers() {
+    let mut env = TestEnvironment::new();
+
+    let owner_a = env.create_light_account_opts(CreateAccountOptions::new().with_secret(42));
+    let owner_b = env.create_light_account_opts(CreateAccountOptions::new().with_secret(42));
+
+    assert(owner_a != owner_b);
+    env.utility_context(|_| { assert_eq(get_public_keys(owner_a).npk_m_hash, get_public_keys(owner_b).npk_m_hash); });
+
+    let nullifier_a = env.private_context(|context| in_private(context, owner_a).get_initialization_nullifier());
+    let nullifier_b = env.private_context(|context| in_private(context, owner_b).get_initialization_nullifier());
+
+    assert(nullifier_a != nullifier_b);
+}
+
 #[test]
 unconstrained fn get_replacement_note_has_unique_randomness() {
     let mut env = TestEnvironment::new();

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

@@ -1,5 +1,6 @@
 use crate::protocol::{
     address::AztecAddress, constants::DOM_SEP__SINGLE_USE_CLAIM_NULLIFIER, hash::poseidon2_hash_with_separator,
+    traits::ToField,
 };
 
 use crate::{
@@ -82,7 +83,7 @@ impl<Context> SingleUseClaim<Context> {
     /// [`SingleUseClaim::assert_claimed`] and [`SingleUseClaim::has_claimed`] to coherently write and read state.
     fn compute_nullifier(self, owner_nhk_app: Field) -> Field {
         poseidon2_hash_with_separator(
-            [owner_nhk_app, self.storage_slot],
+            [owner_nhk_app, self.storage_slot, self.owner.to_field()],
             DOM_SEP__SINGLE_USE_CLAIM_NULLIFIER,
         )
     }