feat(aztec-nr): add call_self stubs for utility functions (#22885)

Author: nchamo

noir-projects/aztec-nr/aztec/src/contract_self/contract_self_private.nr

@@ -48,7 +48,8 @@ use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};
 /// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions
 /// - `EnqueueSelfStatic`: Macro-generated type for enqueuing calls to the contract's own view functions
 /// - `CallInternal`: Macro-generated type for calling internal functions
-pub struct ContractSelfPrivate<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {
+/// - `CallSelfUtility`: Macro-generated type for calling the contract's own utility functions
+pub struct ContractSelfPrivate<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal, CallSelfUtility> {
     /// The address of this contract
     pub address: AztecAddress,
 
@@ -110,17 +111,17 @@ pub struct ContractSelfPrivate<Storage, CallSelf, EnqueueSelf, CallSelfStatic, E
     /// ```
     pub internal: CallInternal,
 
-    /// Gateway for calling utility functions from this private context.
+    /// A struct that allows for ergonomic calling of utility functions from this private context.
     ///
     /// Example API:
     /// ```noir
     /// // Safety: result is unconstrained
     /// unsafe { self.utility.call(MyContract::at(address).my_utility_function(args)) }
     /// ```
-    pub utility: PrivateUtility,
+    pub utility: PrivateUtilityCalls<CallSelfUtility>,
 }
 
-impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> ContractSelfPrivate<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal> {
+impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal, CallSelfUtility> ContractSelfPrivate<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInternal, CallSelfUtility> {
     /// Creates a new `ContractSelfPrivate` instance for a private function.
     ///
     /// This constructor is called automatically by the macro system and should not be called directly.
@@ -132,6 +133,7 @@ impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInte
         call_self_static: CallSelfStatic,
         enqueue_self_static: EnqueueSelfStatic,
         internal: CallInternal,
+        utility: PrivateUtilityCalls<CallSelfUtility>,
     ) -> Self {
         Self {
             context,
@@ -142,7 +144,7 @@ impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInte
             call_self_static,
             enqueue_self_static,
             internal,
-            utility: PrivateUtility {},
+            utility,
         }
     }
 
@@ -407,16 +409,31 @@ impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInte
     }
 }
 
-/// Gateway for calling utility functions from a private context.
+/// A struct that allows for ergonomic calling of utility functions from a private context.
 ///
 /// Accessible via `self.utility` in private functions. Results are not part of any circuit
 /// proof; use them to inform logic, not as inputs to constrained assertions.
-// Implemented as a separate empty struct because Noir does not allow passing `&mut PrivateContext`
-// (held by `ContractSelfPrivate`) into unconstrained code. This struct holds no mutable references,
-// so it can be passed freely into `unconstrained` functions.
-pub struct PrivateUtility {}
+///
+/// ## Type Parameters
+///
+/// - `CallSelf`: Macro-generated type for calling the contract's own utility functions (same type
+/// as `CallSelf` in \[`ContractSelfUtility`\])
+// Implemented as a separate struct (rather than inlined in ContractSelfPrivate) because Noir does
+// not allow passing `&mut PrivateContext` (held by `ContractSelfPrivate`) into unconstrained code.
+// This struct holds no mutable references, so it can be passed freely into `unconstrained`
+// functions.
+pub struct PrivateUtilityCalls<CallSelf> {
+    /// Provides type-safe methods for calling this contract's own utility functions.
+    ///
+    /// Example API:
+    /// ```noir
+    /// // Safety: result is unconstrained
+    /// unsafe { self.utility.call_self.some_utility_function(args) }
+    /// ```
+    pub call_self: CallSelf,
+}
 
-impl PrivateUtility {
+impl<CallSelf> PrivateUtilityCalls<CallSelf> {
     /// Makes a utility contract call from a private function.
     ///
     /// Note: only same-contract utility calls are currently supported. See TODO(F-29).

noir-projects/aztec-nr/aztec/src/contract_self/contract_self_utility.nr

@@ -13,7 +13,9 @@ use crate::protocol::{address::AztecAddress, traits::Deserialize};
 ///
 /// - `Storage`: The contract's storage struct (defined with [`storage`](crate::macros::storage::storage), or `()` if
 /// the contract has no storage
-pub struct ContractSelfUtility<Storage> {
+/// - `CallSelf`: Macro-generated type for calling the contract's own utility functions (same type
+/// as `CallSelf` in \[`PrivateUtilityCalls`\])
+pub struct ContractSelfUtility<Storage, CallSelf> {
     /// The address of this contract
     pub address: AztecAddress,
 
@@ -34,14 +36,22 @@ pub struct ContractSelfUtility<Storage> {
 
     /// The utility execution context.
     pub context: UtilityContext,
+
+    /// Provides type-safe methods for calling this contract's own utility functions.
+    ///
+    /// Example API:
+    /// ```noir
+    /// self.call_self.some_utility_function(args)
+    /// ```
+    pub call_self: CallSelf,
 }
 
-impl<Storage> ContractSelfUtility<Storage> {
+impl<Storage, CallSelf> ContractSelfUtility<Storage, CallSelf> {
     /// Creates a new `ContractSelfUtility` instance for a utility function.
     ///
     /// This constructor is called automatically by the macro system and should not be called directly.
-    pub fn new(context: UtilityContext, storage: Storage) -> Self {
-        Self { context, storage, address: context.this_address() }
+    pub fn new(context: UtilityContext, storage: Storage, call_self: CallSelf) -> Self {
+        Self { context, storage, address: context.this_address(), call_self }
     }
 
     /// Makes a utility contract call from another utility function.

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

@@ -2,6 +2,7 @@ pub mod contract_self_private;
 pub mod contract_self_public;
 pub mod contract_self_utility;
 
+pub use contract_self_private::PrivateUtilityCalls;
 pub use contract_self_private::ContractSelfPrivate;
 pub use contract_self_public::ContractSelfPublic;
 pub use contract_self_utility::ContractSelfUtility;

noir-projects/aztec-nr/aztec/src/macros/calls_generation/external_functions.nr

@@ -2,8 +2,8 @@ use crate::macros::{
     calls_generation::external_functions_stubs::{
         create_private_self_call_stub, create_private_static_stub, create_private_stub,
         create_public_self_call_static_stub, create_public_self_call_stub, create_public_self_enqueue_static_stub,
-        create_public_self_enqueue_stub, create_public_static_stub, create_public_stub, create_utility_stub,
-        create_utility_stub_from_parts,
+        create_public_self_enqueue_stub, create_public_static_stub, create_public_stub, create_utility_self_call_stub,
+        create_utility_stub, create_utility_stub_from_parts,
     },
     internals_functions_generation::external_functions_registry,
     offchain_receive::{
@@ -77,6 +77,7 @@ comptime fn create_offchain_receive_stub() -> Quoted {
 pub(crate) comptime fn generate_external_function_self_calls_structs(m: Module) -> Quoted {
     let private_functions = external_functions_registry::get_private_functions(m);
     let public_functions = external_functions_registry::get_public_functions(m);
+    let utility_functions = external_functions_registry::get_utility_functions(m);
 
     let call_self_private_methods = private_functions
         .map(|function| {
@@ -138,6 +139,9 @@ pub(crate) comptime fn generate_external_function_self_calls_structs(m: Module)
         })
         .join(quote {});
 
+    let call_self_utility_methods =
+        utility_functions.map(|function| create_utility_self_call_stub(function)).join(quote {});
+
     quote {
         pub struct CallSelf<Context> {
             pub address: aztec::protocol::address::AztecAddress,
@@ -182,5 +186,13 @@ pub(crate) comptime fn generate_external_function_self_calls_structs(m: Module)
         impl EnqueueSelfStatic<&mut aztec::context::PrivateContext> {
             $enqueue_self_static_methods
         }
+
+        pub struct CallSelfUtility {
+            pub address: aztec::protocol::address::AztecAddress,
+        }
+
+        impl CallSelfUtility {
+            $call_self_utility_methods
+        }
     }
 }

noir-projects/aztec-nr/aztec/src/macros/calls_generation/external_functions_stubs.nr

@@ -259,6 +259,24 @@ pub comptime fn create_public_self_enqueue_static_stub(f: FunctionDefinition) ->
     }
 }
 
+/// Creates a stub for calling a utility function on the same contract (for CallSelfUtility).
+pub comptime fn create_utility_self_call_stub(f: FunctionDefinition) -> Quoted {
+    let (fn_name, fn_parameters_list, serialized_args_array_construction, serialized_args_array_name, _, _, _, fn_selector) =
+        create_stub_base(f);
+    let fn_return_type = f.return_type();
+
+    quote {
+        pub unconstrained fn $fn_name(self, $fn_parameters_list) -> $fn_return_type {
+            $serialized_args_array_construction
+            let selector = $FROM_FIELD($fn_selector);
+            let returns = aztec::oracle::call_utility_function::call_utility_function(
+                self.address, selector, $serialized_args_array_name,
+            );
+            aztec::protocol::traits::Deserialize::deserialize(returns)
+        }
+    }
+}
+
 /// Creates a stub for enqueuing a public function from private context (for EnqueueSelf<&mut PrivateContext>)
 pub comptime fn create_public_self_enqueue_stub(f: FunctionDefinition) -> Quoted {
     let (fn_name, fn_parameters_list, serialized_args_array_construction, serialized_args_array_name, _serialized_args_array_len, _fn_name_str, _fn_name_len, fn_selector) =

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

@@ -56,7 +56,9 @@ pub(crate) comptime fn generate_private_external(f: FunctionDefinition) -> Quote
             let call_self_static: CallSelfStatic<&mut aztec::context::PrivateContext> = CallSelfStatic { address: self_address, context: &mut context };
             let enqueue_self_static: EnqueueSelfStatic<&mut aztec::context::PrivateContext> = EnqueueSelfStatic { address: self_address, context: &mut context };
             let internal: CallInternal<&mut aztec::context::PrivateContext> = CallInternal { context: &mut context };
-            aztec::contract_self::ContractSelfPrivate::new(&mut context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal)
+            let call_self_utility = CallSelfUtility { address: self_address };
+            let utility: aztec::contract_self::PrivateUtilityCalls<CallSelfUtility> = aztec::contract_self::PrivateUtilityCalls { call_self: call_self_utility };
+            aztec::contract_self::ContractSelfPrivate::new(&mut context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal, utility)
         };
     };
 

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

@@ -24,7 +24,9 @@ pub(crate) comptime fn generate_utility_external(f: FunctionDefinition) -> Quote
         let mut self = {
             let context = aztec::context::UtilityContext::new();
             $storage_init
-            aztec::contract_self::ContractSelfUtility::new(context, storage)
+            let self_address = context.this_address();
+            let call_self = CallSelfUtility { address: self_address };
+            aztec::contract_self::ContractSelfUtility::new(context, storage, call_self)
         };
     };
 

noir-projects/aztec-nr/aztec/src/macros/internals_functions_generation/internal.nr

@@ -42,7 +42,9 @@ pub(crate) comptime fn generate_private_internal(f: FunctionDefinition) -> Quote
                 let call_self_static: CallSelfStatic<&mut aztec::context::PrivateContext> = CallSelfStatic { address: self_address, context };
                 let enqueue_self_static: EnqueueSelfStatic<&mut aztec::context::PrivateContext> = EnqueueSelfStatic { address: self_address, context };
                 let internal: CallInternal<&mut aztec::context::PrivateContext> = CallInternal { context };
-                aztec::contract_self::ContractSelfPrivate::new(context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal)
+                let call_self_utility = CallSelfUtility { address: self_address };
+                let utility: aztec::contract_self::PrivateUtilityCalls<CallSelfUtility> = aztec::contract_self::PrivateUtilityCalls { call_self: call_self_utility };
+                aztec::contract_self::ContractSelfPrivate::new(context, storage, call_self, enqueue_self, call_self_static, enqueue_self_static, internal, utility)
             };
 
             $body

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

@@ -12,7 +12,7 @@ pub contract NestedUtility {
         if n == 0 {
             1
         } else {
-            x * self.call(NestedUtility::at(self.address).pow_utility(x, n - 1))
+            x * self.call_self.pow_utility(x, n - 1)
         }
     }
 
@@ -21,7 +21,7 @@ pub contract NestedUtility {
         // Safety: this is a test contract; the unconstrained result is returned directly
         // and never used as input to a constrained assertion
         unsafe {
-            self.utility.call(NestedUtility::at(self.address).pow_utility(x, n))
+            self.utility.call_self.pow_utility(x, n)
         }
     }
 }