docs: add backticks to links (#20045)

This will make them render more nicely in the docsite.

Author: benesjan

noir-projects/aztec-nr/aztec/src/context/note_existence_request.nr

@@ -2,7 +2,7 @@ use crate::protocol::address::aztec_address::AztecAddress;
 
 /// A request to assert the existence of a note.
 ///
-/// Used by [crate::context::PrivateContext::assert_note_exists].
+/// Used by [`crate::context::PrivateContext::assert_note_exists`].
 pub struct NoteExistenceRequest {
     note_hash: Field,
     maybe_contract_address: Option<AztecAddress>,
@@ -13,7 +13,8 @@ impl NoteExistenceRequest {
     ///
     /// Pending notes have not been yet assigned a nonce, and they therefore have no unique note hash. Instead, these
     /// requests are created using the unsiloed note hash (i.e. from
-    /// [crate::note::note_interface::NoteHash::compute_note_hash]) and address of the contract that created the note.
+    /// [`crate::note::note_interface::NoteHash::compute_note_hash`]) and address of the contract that created the
+    /// note.
     pub fn for_pending(unsiloed_note_hash: Field, contract_address: AztecAddress) -> Self {
         // The kernel doesn't take options; it takes a note_hash and an address, and infers whether the request is
         // siloed based on whether the address is zero or non-zero. When passing the value to the kernel, we use

noir-projects/aztec-nr/aztec/src/context/nullifier_existence_request.nr

@@ -2,7 +2,7 @@ use crate::protocol::address::aztec_address::AztecAddress;
 
 /// A request to assert the existence of a nullifier.
 ///
-/// Used by [crate::context::private_context::PrivateContext::assert_nullifier_exists].
+/// Used by [`crate::context::private_context::PrivateContext::assert_nullifier_exists`].
 pub struct NullifierExistenceRequest {
     nullifier: Field,
     maybe_contract_address: Option<AztecAddress>,

noir-projects/aztec-nr/aztec/src/context/private_context.nr

@@ -637,7 +637,7 @@ impl PrivateContext {
     /// ## Historical Notes
     ///
     /// If you need to assert that a note existed _by some specific block in the past_, instead of simply proving that
-    /// it exists by the current anchor block, use [crate::history::note::assert_note_existed_by] instead.
+    /// it exists by the current anchor block, use [`crate::history::note::assert_note_existed_by`] instead.
     ///
     /// ## Cost
     ///
@@ -673,7 +673,7 @@ impl PrivateContext {
     /// ## Historical Nullifiers
     ///
     /// If you need to assert that a nullifier existed _by some specific block in the past_, instead of simply proving
-    /// that it exists by the current anchor block, use [crate::history::nullifier::assert_nullifier_existed_by]
+    /// that it exists by the current anchor block, use [`crate::history::nullifier::assert_nullifier_existed_by`]
     /// instead.
     ///
     /// ## Public vs Private
@@ -685,7 +685,7 @@ impl PrivateContext {
     ///
     /// This is not the case in public functions, which do have access to the tip of the blockchain and so can reliably
     /// prove whether a nullifier exists or not via
-    /// [crate::context::public_context::PublicContext::nullifier_exists_unsafe].
+    /// [`crate::context::public_context::PublicContext::nullifier_exists_unsafe`].
     ///
     /// ## Cost
     ///

noir-projects/aztec-nr/aztec/src/context/public_context.nr

@@ -145,7 +145,7 @@ impl PublicContext {
     /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.
     ///
     /// Note that unsiloed nullifiers are not the actual values stored in the nullifier tree: they are first siloed via
-    /// [crate::hash::compute_siloed_nullifier] with the emitting contract's address.
+    /// [`crate::hash::compute_siloed_nullifier`] with the emitting contract's address.
     ///
     /// ## Use Cases
     ///
@@ -160,7 +160,8 @@ impl PublicContext {
     ///
     /// In general, it is unsafe to check for nullifier non-existence in private, as that will not consider the
     /// possibility of the nullifier having been emitted in any transaction between the anchor block and the inclusion
-    /// block. Private functions instead prove existence via [crate::context::PrivateContext::assert_nullifier_exists]
+    /// block. Private functions instead prove existence via
+    /// [`crate::context::PrivateContext::assert_nullifier_exists`]
     /// and 'prove' non-existence by _emitting_ the nullifer, which would cause the transaction to fail if the
     /// nullifier existed.
     ///

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

@@ -17,8 +17,8 @@ use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};
 
 /// Core interface for interacting with aztec-nr contract features.
 ///
-/// This struct is automatically injected into every [external](crate::macros::functions::external) and
-/// [internal](crate::macros::functions::internal) contract function by the Aztec macro system and is accessible
+/// This struct is automatically injected into every [`external`](crate::macros::functions::external) and
+/// [`internal`](crate::macros::functions::internal) contract function by the Aztec macro system and is accessible
 /// through the `self` variable.
 ///
 /// ## Usage in Contract Functions
@@ -50,8 +50,8 @@ use crate::protocol::{address::AztecAddress, traits::{Deserialize, Serialize}};
 /// ## Type Parameters
 ///
 /// - `Context`: The execution context type - either `&mut PrivateContext`, `PublicContext`, or `UtilityContext`
-/// - `Storage`: The contract's storage struct (defined with [storage](crate::macros::storage::storage), or `()` if the
-/// contract has no storage
+/// - `Storage`: The contract's storage struct (defined with [`storage`](crate::macros::storage::storage), or `()` if
+/// the contract has no storage
 /// - `CallSelf`: Macro-generated type for calling contract's own non-view functions
 /// - `EnqueueSelf`: Macro-generated type for enqueuing calls to the contract's own non-view functions
 /// - `CallSelfStatic`: Macro-generated type for calling contract's own view functions
@@ -61,8 +61,8 @@ pub struct ContractSelf<Context, Storage, CallSelf, EnqueueSelf, CallSelfStatic,
     pub address: AztecAddress,
 
     /// The contract's storage instance, representing the struct to which the
-    /// [storage](crate::macros::storage::storage) macro was applied in your contract. If the contract has no storage,
-    /// the type of this will be `()`.
+    /// [`storage`](crate::macros::storage::storage) macro was applied in your contract. If the contract has no
+    /// storage, the type of this will be `()`.
     ///
     /// This storage instance is specialized for the current execution context (private, public, or utility) and
     /// provides access to the contract's state variables. Each state variable accepts the context as a generic
@@ -73,13 +73,13 @@ pub struct ContractSelf<Context, Storage, CallSelf, EnqueueSelf, CallSelfStatic,
     ///
     /// If you've arrived here while trying to access your contract's storage while the `Storage` generic type is set
     /// to unit type `()`, it means you haven't yet defined a Storage struct using the
-    /// [storage](crate::macros::storage::storage) macro in your contract. For guidance on setting this up, please
+    /// [`storage`](crate::macros::storage::storage) macro in your contract. For guidance on setting this up, please
     /// refer to our docs: https://docs.aztec.network/developers/docs/guides/smart_contracts/storage
 
     pub storage: Storage,
 
-    /// The execution context whose type is determined by the [external](crate::macros::functions::external) attribute
-    /// of the contract function based on the external function type (private, public, or utility).
+    /// The execution context whose type is determined by the [`external`](crate::macros::functions::external)
+    /// attribute of the contract function based on the external function type (private, public, or utility).
     pub context: Context,
 
     /// Provides type-safe methods for calling this contract's own non-view functions.
@@ -176,16 +176,16 @@ impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInte
     /// executed in a transaction (i.e. transaction entrypoint) does **not** have a caller. This function panics when
     /// executed in such a context.
     ///
-    /// If you need to handle these cases, use [PrivateContext::maybe_msg_sender].
+    /// If you need to handle these cases, use [`PrivateContext::maybe_msg_sender`].
     pub fn msg_sender(self) -> AztecAddress {
         self.context.maybe_msg_sender().unwrap()
     }
 
     /// Emits an event privately.
     ///
     /// Unlike public events, private events do not reveal their contents publicly. They instead create an
-    /// [EventMessage] containing the private event information, which **MUST** be delivered to a recipient via
-    /// [EventMessage::deliver_to] in order for them to learn about the event. Multiple recipients can have the same
+    /// [`EventMessage`] containing the private event information, which **MUST** be delivered to a recipient via
+    /// [`EventMessage::deliver_to`] in order for them to learn about the event. Multiple recipients can have the same
     /// message be delivered to them.
     ///
     /// # Example
@@ -206,7 +206,7 @@ impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInte
     /// # Cost
     ///
     /// Private event emission always results in the creation of a nullifer, which acts as a commitment to the event
-    /// and is used by third parties to verify its authenticity. See [EventMessage::deliver_to] for the costs
+    /// and is used by third parties to verify its authenticity. See [`EventMessage::deliver_to`] for the costs
     /// associated to delivery.
     ///
     /// # Privacy
@@ -335,8 +335,8 @@ impl<Storage, CallSelf, EnqueueSelf, CallSelfStatic, EnqueueSelfStatic, CallInte
 
     /// Enqueues a privacy-preserving public contract call function.
     ///
-    /// This is the same as [ContractSelf::enqueue], except it hides this calling contract's address from the target
-    /// public function (i.e. [ContractSelf::msg_sender] will panic).
+    /// This is the same as [`ContractSelf::enqueue`], except it hides this calling contract's address from the target
+    /// public function (i.e. [`ContractSelf::msg_sender`] will panic).
     ///
     /// This means the origin of the call (msg_sender) will not be publicly visible to any blockchain observers, nor to
     /// the target public function. If the target public function reads `self.msg_sender()` the call will revert.
@@ -460,9 +460,9 @@ impl<Storage, CallSelf, CallSelfStatic, CallInternal> ContractSelf<PublicContext
     /// ## Incognito Calls
     ///
     /// Contracts can call public functions from private ones hiding their identity (see
-    /// [enqueue_incognito](ContractSelf::enqueue_incognito)). This function reverts when executed in such a context.
+    /// [`enqueue_incognito`](ContractSelf::enqueue_incognito)). This function reverts when executed in such a context.
     ///
-    /// If you need to handle these cases, use [PublicContext::maybe_msg_sender].
+    /// If you need to handle these cases, use [`PublicContext::maybe_msg_sender`].
     pub fn msg_sender(self: Self) -> AztecAddress {
         self.context.maybe_msg_sender().unwrap()
     }

noir-projects/aztec-nr/aztec/src/event/event_emission.nr

@@ -11,7 +11,7 @@ pub struct NewEvent<Event> {
     pub(crate) randomness: Field,
 }
 
-/// Equivalent to `self.emit(event)`: see [crate::contract_self::ContractSelf::emit].
+/// Equivalent to `self.emit(event)`: see [`crate::contract_self::ContractSelf::emit`].
 pub fn emit_event_in_private<Event>(context: &mut PrivateContext, event: Event) -> EventMessage<Event>
 where
     Event: EventInterface + Serialize,
@@ -34,7 +34,7 @@ where
     EventMessage::new(NewEvent { event, randomness }, context)
 }
 
-/// Equivalent to `self.emit(event)`: see [crate::contract_self::ContractSelf::emit].
+/// Equivalent to `self.emit(event)`: see [`crate::contract_self::ContractSelf::emit`].
 pub fn emit_event_in_public<Event>(context: PublicContext, event: Event)
 where
     Event: EventInterface + Serialize,

noir-projects/aztec-nr/aztec/src/event/event_interface.nr

@@ -25,7 +25,7 @@ where
     )
 }
 
-/// Unconstrained variant of [compute_private_event_commitment] which takes the event in serialized form.
+/// Unconstrained variant of [`compute_private_event_commitment`] which takes the event in serialized form.
 ///
 /// This function is unconstrained as the mechanism it uses to compute the commitment would be very inefficient in a
 /// constrained environment (due to the hashing of a dynamically sized array). This is not an issue as it is typically

noir-projects/aztec-nr/aztec/src/event/event_message.nr

@@ -8,7 +8,7 @@ use crate::protocol::{address::AztecAddress, traits::Serialize};
 /// A message with information about an event that was emitted in the current contract call. This message **MUST** be
 /// delivered to a recipient in order to not lose the private event information.
 ///
-/// Use [EventMessage::deliver_to] to select a delivery mechanism.
+/// Use [`EventMessage::deliver_to`] to select a delivery mechanism.
 #[must_use = "Unused EventMessage result - use the `deliver_to` function to prevent the event information from being lost forever"]
 pub struct EventMessage<Event> {
     pub(crate) new_event: NewEvent<Event>,
@@ -35,7 +35,7 @@ where
     ///
     /// The message is first encrypted to the recipient's public key, ensuring no other actor can read it.
     ///
-    /// The `delivery_mode` must be one of [crate::messages::message_delivery::MessageDeliveryEnum], and will inform
+    /// The `delivery_mode` must be one of [`crate::messages::message_delivery::MessageDeliveryEnum`], and will inform
     /// costs (both proving time and TX fees) as well as delivery guarantees. This value must be a compile-time
     /// constant.
     ///

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

@@ -313,7 +313,7 @@ comptime fn generate_process_message() -> Quoted {
 /// Checks that all functions in the module have a context macro applied.
 ///
 /// Non-macroified functions are not allowed in contracts. They must all be one of
-/// [external](crate::macros::functions::external), [internal](crate::macros::functions::internal) or `test`.
+/// [`external`](crate::macros::functions::external), [`internal`](crate::macros::functions::internal) or `test`.
 comptime fn check_each_fn_macroified(m: Module) {
     for f in m.functions() {
         let name = f.name();