feat!: auto-enqueue public init nullifier for contracts with public functions

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

@@ -1,8 +1,15 @@
 use crate::macros::internals_functions_generation::external_functions_registry::get_public_functions;
 use crate::protocol::meta::utils::get_params_len_quote;
 use crate::utils::cmap::CHashMap;
-use super::utils::compute_fn_selector;
-use std::panic;
+use super::utils::{compute_fn_selector, module_has_initializer};
+use std::meta::unquote;
+
+pub(crate) comptime fn compute_emit_public_init_nullifier_selector() -> Field {
+    let computation_quote = quote {
+        crate::protocol::traits::ToField::to_field(crate::protocol::abis::function_selector::FunctionSelector::from_signature("__emit_public_init_nullifier()"))
+    };
+    unquote!(computation_quote)
+}
 
 /// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.
 pub comptime fn generate_public_dispatch(m: Module) -> Quoted {
@@ -100,13 +107,35 @@ pub comptime fn generate_public_dispatch(m: Module) -> Quoted {
         // No dispatch function if there are no public functions
         quote {}
     } else {
+        // If the module has an initializer, add a dispatch case for the auto-generated
+        // __emit_public_init_nullifier function. This function is called by private initializers to emit
+        // the public init nullifier, ensuring public functions see the contract as initialized.
+        let emit_init_nullifier_case = if module_has_initializer(m) {
+            let emit_selector: Field = compute_emit_public_init_nullifier_selector();
+            quote {
+                if selector == $emit_selector {
+                    // This function takes no args, so the args_hash closure is unused (returns zero).
+                    let context = aztec::context::PublicContext::new(|| { 0 });
+                    assert(
+                        context.maybe_msg_sender().unwrap() == context.this_address(),
+                        "Function __emit_public_init_nullifier can only be called by the same contract",
+                    );
+                    aztec::macros::functions::initialization_utils::mark_as_initialized_public(context);
+                    aztec::oracle::avm::avm_return([]);
+                }
+            }
+        } else {
+            quote {}
+        };
+
         let ifs = ifs.push_back(quote { panic(f"Unknown selector {selector}") });
         let dispatch = ifs.join(quote {  });
 
         let body = quote {
             // We mark this as public because our whole system depends on public functions having this attribute.
             #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]
             pub unconstrained fn public_dispatch(selector: Field) {
+                $emit_init_nullifier_case
                 $dispatch
             }
         };

noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr

@@ -1,6 +1,9 @@
 use crate::protocol::{
-    abis::function_selector::FunctionSelector, address::AztecAddress, constants::DOM_SEP__INITIALIZER,
-    hash::poseidon2_hash_with_separator, traits::ToField,
+    abis::function_selector::FunctionSelector,
+    address::AztecAddress,
+    constants::{DOM_SEP__INITIALIZER, DOM_SEP__PUBLIC_INITIALIZER},
+    hash::poseidon2_hash_with_separator,
+    traits::ToField,
 };
 
 use crate::{
@@ -11,37 +14,67 @@ use crate::{
     },
 };
 
-// Used by `create_mark_as_initialized` (you won't find it through searching)
+// Two separate init nullifiers exist because private nullifiers are committed before public execution
+// begins. If a private initializer emitted a single nullifier, public functions in the same tx would
+// see it via the pending nullifier set and incorrectly consider the contract initialized before the
+// public phase runs.
+//
+// - Private init nullifier: checked by `assert_is_initialized_private`, emitted by private initializers.
+// - Public init nullifier: checked by `assert_is_initialized_public`, emitted during the public phase.
+//
+// Private initializers emit only the private nullifier, then enqueue `__emit_public_init_nullifier`
+// (an auto-generated dispatch case) so the public nullifier is emitted during the public phase.
+// Public initializers emit both nullifiers directly via `mark_as_initialized_from_public_initializer`.
+
+/// Emits the public init nullifier only. Called by the auto-generated `__emit_public_init_nullifier`
+/// dispatch case, which is enqueued by private initializers.
 pub fn mark_as_initialized_public(context: PublicContext) {
-    let init_nullifier = compute_unsiloed_contract_initialization_nullifier((context).this_address());
+    let init_nullifier = compute_public_init_nullifier(context.this_address());
     context.push_nullifier(init_nullifier);
 }
 
-// Used by `create_mark_as_initialized` (you won't find it through searching)
+/// Enqueues a public call to `__emit_public_init_nullifier` so the public init nullifier is emitted
+/// during the public phase. Called by private initializer macros for contracts that have public functions.
+pub fn enqueue_emit_public_init_nullifier(context: &mut PrivateContext) {
+    let selector = FunctionSelector::from_signature("__emit_public_init_nullifier()");
+    context.call_public_function(context.this_address(), selector, [], false);
+}
+
+/// Emits the private init nullifier only. Called by private initializer macros.
 pub fn mark_as_initialized_private(context: &mut PrivateContext) {
-    let init_nullifier = compute_unsiloed_contract_initialization_nullifier((*context).this_address());
+    let init_nullifier = compute_private_init_nullifier((*context).this_address());
     context.push_nullifier(init_nullifier);
 }
 
-// Used by `create_init_check` (you won't find it through searching)
+/// Emits both init nullifiers. Called by public initializer macros, since public initializers must
+/// set both so that both private and public functions see the contract as initialized.
+pub fn mark_as_initialized_from_public_initializer(context: PublicContext) {
+    let private_nullifier = compute_private_init_nullifier(context.this_address());
+    context.push_nullifier(private_nullifier);
+    mark_as_initialized_public(context);
+}
+
+/// Checks that the public init nullifier exists (i.e. the contract has been initialized from public's perspective).
 pub fn assert_is_initialized_public(context: PublicContext) {
-    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());
-    // Safety: TODO(F-239) - this is currently unsafe, we cannot rely on the nullifier existing to determine that any
-    // public component of contract initialization has been complete.
+    let init_nullifier = compute_public_init_nullifier(context.this_address());
     assert(context.nullifier_exists_unsafe(init_nullifier, context.this_address()), "Not initialized");
 }
 
-// Used by `create_init_check` (you won't find it through searching)
+/// Checks that the private init nullifier exists (i.e. the contract has been initialized from private's perspective).
 pub fn assert_is_initialized_private(context: &mut PrivateContext) {
-    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());
+    let init_nullifier = compute_private_init_nullifier(context.this_address());
     let nullifier_existence_request = compute_nullifier_existence_request(init_nullifier, context.this_address());
     context.assert_nullifier_exists(nullifier_existence_request);
 }
 
-fn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {
+fn compute_private_init_nullifier(address: AztecAddress) -> Field {
     address.to_field()
 }
 
+fn compute_public_init_nullifier(address: AztecAddress) -> Field {
+    poseidon2_hash_with_separator([address.to_field()], DOM_SEP__PUBLIC_INITIALIZER)
+}
+
 // Used by `create_assert_correct_initializer_args` (you won't find it through searching)
 pub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {
     let address = context.this_address();

noir-projects/aztec-nr/aztec/src/macros/functions/mod.nr

@@ -379,6 +379,12 @@ comptime fn assert_valid_public(f: FunctionDefinition) {
             f"The #[allow_phase_change] attribute cannot be applied to #[external(\"public\")] functions - {name}",
         );
     }
+
+    if f.name() == quote { __emit_public_init_nullifier } {
+        panic(
+            f"Function name '__emit_public_init_nullifier' is reserved for internal use",
+        );
+    }
 }
 
 comptime fn assert_valid_utility(f: FunctionDefinition) {

noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/private.nr

@@ -1,5 +1,8 @@
 use crate::macros::{
-    internals_functions_generation::external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},
+    internals_functions_generation::{
+        external::helpers::{create_authorize_once_check, get_abi_relevant_attributes},
+        external_functions_registry::get_public_functions,
+    },
     utils::{
         fn_has_allow_phase_change, fn_has_authorize_once, fn_has_noinitcheck, is_fn_initializer, is_fn_only_self,
         is_fn_view, module_has_initializer, module_has_storage,
@@ -76,17 +79,27 @@ pub(crate) comptime fn generate_private_external(f: FunctionDefinition) -> Quote
         quote {}
     };
 
-    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {
+    let (assert_initializer, mark_as_initialized, enqueue_public_init_nullifier) = if is_fn_initializer(f) {
+        // Enqueue a public call to emit the public init nullifier, so public functions in this tx
+        // see the contract as initialized. Only needed if the contract has public functions.
+        let enqueue_public_init_nullifier = if get_public_functions(f.module()).len() > 0 {
+            quote { aztec::macros::functions::initialization_utils::enqueue_emit_public_init_nullifier(self.context); }
+        } else {
+            quote {}
+        };
         (
             quote { aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_private(*self.context); },
             quote { aztec::macros::functions::initialization_utils::mark_as_initialized_private(self.context); },
+            enqueue_public_init_nullifier,
         )
     } else {
-        (quote {}, quote {})
+        (quote {}, quote {}, quote {})
     };
 
     // Initialization checks are not included in contracts that don't have initializers.
-    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {
+    // `only_self` functions skip the check so constructors can call them via `call_self`.
+    // The msg_sender == this_address assertion already restricts them to internal calls.
+    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) & !is_fn_only_self(f) {
         quote { aztec::macros::functions::initialization_utils::assert_is_initialized_private(self.context); }
     } else {
         quote {}
@@ -180,6 +193,7 @@ pub(crate) comptime fn generate_private_external(f: FunctionDefinition) -> Quote
     let to_append = quote {
         $return_value
         $mark_as_initialized
+        $enqueue_public_init_nullifier
         $no_phase_change_check
         $context_finish
     };

noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/external/public.nr

@@ -79,14 +79,16 @@ pub(crate) comptime fn generate_public_external(f: FunctionDefinition) -> Quoted
     let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {
         (
             quote { aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_public(self.context); },
-            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_public(self.context); },
+            quote { aztec::macros::functions::initialization_utils::mark_as_initialized_from_public_initializer(self.context); },
         )
     } else {
         (quote {}, quote {})
     };
 
     // Initialization checks are not included in contracts that don't have initializers.
-    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {
+    // `only_self` functions skip the check so constructors can call them via `call_self`.
+    // The msg_sender == this_address assertion already restricts them to internal calls.
+    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) & !is_fn_only_self(f) {
         quote { aztec::macros::functions::initialization_utils::assert_is_initialized_public(self.context); }
     } else {
         quote {}

noir-projects/aztec-nr/macro_compilation_failure_tests/failure_contracts/reserved_emit_public_init_nullifier/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "reserved_emit_public_init_nullifier"
+type = "contract"
+authors = [""]
+
+[dependencies]
+aztec = { path = "../../../aztec" }

noir-projects/aztec-nr/macro_compilation_failure_tests/failure_contracts/reserved_emit_public_init_nullifier/src/main.nr

@@ -0,0 +1,11 @@
+/// Public functions cannot use the reserved name __emit_public_init_nullifier.
+///
+use aztec::macros::aztec;
+
+#[aztec]
+contract ReservedEmitPublicInitNullifier {
+    use aztec::macros::functions::external;
+
+    #[external("public")]
+    fn __emit_public_init_nullifier() {}
+}

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

@@ -6,7 +6,7 @@ pub contract StatefulTest {
     use aztec::macros::{
         functions::{
             external, initialization_utils::assert_is_initialized_private, initializer, noinitcheck,
-            view,
+            only_self, view,
         },
         storage::storage,
     };
@@ -43,6 +43,39 @@ pub contract StatefulTest {
         self.call_self.increment_public_value_no_init_check(owner, value);
     }
 
+    #[external("private")]
+    #[initializer]
+    fn constructor_self_calling_init_checked(owner: AztecAddress, value: Field) {
+        self.call_self.create_note(owner, value);
+    }
+
+    #[external("private")]
+    #[initializer]
+    fn constructor_enqueuing_public_self_call(owner: AztecAddress, value: Field) {
+        self.enqueue_self.increment_public_value(owner, value);
+    }
+
+    #[external("public")]
+    #[initializer]
+    fn public_constructor_self_calling_init_checked(owner: AztecAddress, value: Field) {
+        self.call_self.increment_public_value(owner, value);
+    }
+
+    #[external("private")]
+    #[only_self]
+    fn only_self_create_note(owner: AztecAddress, value: Field) {
+        if (value != 0) {
+            let note = FieldNote { value };
+            self.storage.notes.at(owner).insert(note).deliver(MessageDelivery.ONCHAIN_CONSTRAINED);
+        }
+    }
+
+    #[external("private")]
+    #[initializer]
+    fn constructor_calling_only_self(owner: AztecAddress, value: Field) {
+        self.call_self.only_self_create_note(owner, value);
+    }
+
     #[external("private")]
     fn create_note(owner: AztecAddress, value: Field) {
         if (value != 0) {

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

@@ -4,7 +4,7 @@ use aztec::macros::aztec;
 #[aztec]
 contract Updatable {
     use aztec::{
-        macros::{functions::{external, initializer}, storage::storage},
+        macros::{functions::{external, initializer, internal, only_self}, storage::storage},
         messages::message_delivery::MessageDelivery,
         protocol::{
             address::AztecAddress, constants::CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
@@ -29,12 +29,18 @@ contract Updatable {
         self.storage.private_value.at(owner).initialize(note).deliver(
             MessageDelivery.ONCHAIN_CONSTRAINED,
         );
-        self.enqueue_self.set_public_value(initial_value);
+        self.enqueue_self._initialize_public_value(initial_value);
     }
 
     #[external("public")]
     fn set_public_value(new_value: Field) {
-        self.storage.public_value.write(new_value);
+        self.internal.write_public_value(new_value);
+    }
+
+    #[external("public")]
+    #[only_self]
+    fn _initialize_public_value(new_value: Field) {
+        self.internal.write_public_value(new_value);
     }
 
     #[external("private")]
@@ -55,6 +61,11 @@ contract Updatable {
             .get_update_delay())
     }
 
+    #[internal("public")]
+    fn write_public_value(new_value: Field) {
+        self.storage.public_value.write(new_value);
+    }
+
     #[external("utility")]
     unconstrained fn get_private_value(owner: AztecAddress) -> Field {
         self.storage.private_value.at(owner).view_note().value

noir-projects/noir-protocol-circuits/crates/types/src/constants.nr

@@ -712,6 +712,7 @@ pub global DOM_SEP__PARTIAL_NOTE_VALIDITY_COMMITMENT: u32 = 623934423;
 // TODO: consider moving these to aztec-nr
 
 pub global DOM_SEP__INITIALIZATION_NULLIFIER: u32 = 1653084894;
+pub global DOM_SEP__PUBLIC_INITIALIZER: u32 = 1247443103;
 pub global DOM_SEP__SECRET_HASH: u32 = 4199652938;
 pub global DOM_SEP__TX_NULLIFIER: u32 = 1025801951;
 pub global DOM_SEP__SIGNATURE_PAYLOAD: u32 = 463525807;

noir-projects/noir-protocol-circuits/crates/types/src/constants_tests.nr

@@ -14,12 +14,12 @@ use crate::{
         DOM_SEP__PARTIAL_ADDRESS, DOM_SEP__PARTIAL_NOTE_VALIDITY_COMMITMENT,
         DOM_SEP__PRIVATE_FUNCTION_LEAF, DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__PRIVATE_TX_HASH,
         DOM_SEP__PROTOCOL_CONTRACTS, DOM_SEP__PUBLIC_BYTECODE, DOM_SEP__PUBLIC_CALLDATA,
-        DOM_SEP__PUBLIC_KEYS_HASH, DOM_SEP__PUBLIC_LEAF_SLOT, DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,
-        DOM_SEP__PUBLIC_TX_HASH, DOM_SEP__SECRET_HASH, DOM_SEP__SIGNATURE_PAYLOAD,
-        DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER, DOM_SEP__SYMMETRIC_KEY,
-        DOM_SEP__SYMMETRIC_KEY_2, DOM_SEP__TSK_M, DOM_SEP__TX_NULLIFIER, DOM_SEP__TX_REQUEST,
-        DOM_SEP__UNIQUE_NOTE_HASH, NULL_MSG_SENDER_CONTRACT_ADDRESS, SIDE_EFFECT_MASKING_ADDRESS,
-        TX_START_PREFIX,
+        DOM_SEP__PUBLIC_INITIALIZER, DOM_SEP__PUBLIC_KEYS_HASH, DOM_SEP__PUBLIC_LEAF_SLOT,
+        DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, DOM_SEP__PUBLIC_TX_HASH, DOM_SEP__SECRET_HASH,
+        DOM_SEP__SIGNATURE_PAYLOAD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,
+        DOM_SEP__SYMMETRIC_KEY, DOM_SEP__SYMMETRIC_KEY_2, DOM_SEP__TSK_M, DOM_SEP__TX_NULLIFIER,
+        DOM_SEP__TX_REQUEST, DOM_SEP__UNIQUE_NOTE_HASH, NULL_MSG_SENDER_CONTRACT_ADDRESS,
+        SIDE_EFFECT_MASKING_ADDRESS, TX_START_PREFIX,
     },
     hash::poseidon2_hash_bytes,
     traits::{FromField, ToField},
@@ -129,7 +129,7 @@ impl<let NUM_VALUES: u32, let NUM_U32_VALUES: u32> HashedValueTester<NUM_VALUES,
 
 #[test]
 fn hashed_values_match_derived() {
-    let mut tester = HashedValueTester::<49, 42>::new();
+    let mut tester = HashedValueTester::<50, 43>::new();
 
     // -----------------
     // Domain separators
@@ -182,6 +182,7 @@ fn hashed_values_match_derived() {
         DOM_SEP__INITIALIZATION_NULLIFIER,
         "initialization_nullifier",
     );
+    tester.assert_dom_sep_matches_derived(DOM_SEP__PUBLIC_INITIALIZER, "public_initializer");
     tester.assert_dom_sep_matches_derived(DOM_SEP__SECRET_HASH, "secret_hash");
     tester.assert_dom_sep_matches_derived(DOM_SEP__TX_NULLIFIER, "tx_nullifier");
     tester.assert_dom_sep_matches_derived(DOM_SEP__SIGNATURE_PAYLOAD, "signature_payload");

yarn-project/constants/src/constants.gen.ts

@@ -540,6 +540,7 @@ export enum DomainSeparator {
   SYMMETRIC_KEY_2 = 4129434989,
   PARTIAL_NOTE_VALIDITY_COMMITMENT = 623934423,
   INITIALIZATION_NULLIFIER = 1653084894,
+  PUBLIC_INITIALIZER = 1247443103,
   SECRET_HASH = 4199652938,
   TX_NULLIFIER = 1025801951,
   SIGNATURE_PAYLOAD = 463525807,

yarn-project/end-to-end/src/composed/ha/e2e_ha_full.test.ts

@@ -324,8 +324,6 @@ describe('HA Full Setup', () => {
     const receipt = await deployer.deploy(ownerAddress, sender, 1).send({
       from: ownerAddress,
       contractAddressSalt: new Fr(BigInt(1)),
-      skipClassPublication: true,
-      skipInstancePublication: true,
       wait: { returnReceipt: true },
     });