feat!: aztec_macros are dead, long live aztec::macros

avm-transpiler/src/transpile_contract.rs

@@ -92,7 +92,7 @@ impl From<CompiledAcirContractArtifact> for TranspiledContractArtifact {
 
         for function in contract.functions {
             // TODO(4269): once functions are tagged for transpilation to AVM, check tag
-            if function.custom_attributes.contains(&"aztec(public)".to_string()) {
+            if function.custom_attributes.contains(&"public".to_string()) {
                 info!("Transpiling AVM function {} on contract {}", function.name, contract.name);
                 // Extract Brillig Opcodes from acir
                 let acir_program = function.bytecode;

boxes/boxes/react/src/contracts/src/main.nr

@@ -1,18 +1,22 @@
+use dep::aztec::macros::aztec;
+
+#[aztec]
 contract BoxReact {
     use dep::aztec::{
         keys::public_keys::{IvpkM, OvpkM},
         prelude::{AztecAddress, PrivateMutable, Map, NoteInterface, NoteHeader, Point},
-        encrypted_logs::encrypted_note_emission::encode_and_encrypt_note_with_keys
+        encrypted_logs::encrypted_note_emission::encode_and_encrypt_note_with_keys,
+        macros::{storage::storage, functions::{private, public, initializer}}
     };
     use dep::value_note::value_note::{ValueNote, VALUE_NOTE_LEN};
 
-    #[aztec(storage)]
+    #[storage]
     struct Storage {
         numbers: Map<AztecAddress, PrivateMutable<ValueNote>>,
     }
 
-    #[aztec(private)]
-    #[aztec(initializer)]
+    #[private]
+    #[initializer]
     fn constructor(
         number: Field,
         owner: AztecAddress,
@@ -25,7 +29,7 @@ contract BoxReact {
         numbers.at(owner).initialize(&mut new_number).emit(encode_and_encrypt_note_with_keys(&mut context, owner_ovpk_m, owner_ivpk_m, owner));
     }
 
-    #[aztec(private)]
+    #[private]
     fn setNumber(
         number: Field,
         owner: AztecAddress,

boxes/boxes/vanilla/src/contracts/src/main.nr

@@ -1,18 +1,22 @@
+use dep::aztec::macros::aztec;
+
+#[aztec]
 contract Vanilla {
     use dep::aztec::{
         keys::public_keys::{IvpkM, OvpkM},
         prelude::{AztecAddress, PrivateMutable, Map, NoteInterface, NoteHeader, Point},
-        encrypted_logs::encrypted_note_emission::encode_and_encrypt_note_with_keys
+        encrypted_logs::encrypted_note_emission::encode_and_encrypt_note_with_keys,
+        macros::{storage::storage, functions::{private, public, initializer}}
     };
     use dep::value_note::value_note::{ValueNote, VALUE_NOTE_LEN};
 
-    #[aztec(storage)]
+    #[storage]
     struct Storage {
         numbers: Map<AztecAddress, PrivateMutable<ValueNote>>,
     }
 
-    #[aztec(private)]
-    #[aztec(initializer)]
+    #[private]
+    #[initializer]
     fn constructor(
         number: Field,
         owner: AztecAddress,
@@ -25,7 +29,7 @@ contract Vanilla {
         numbers.at(owner).initialize(&mut new_number).emit(encode_and_encrypt_note_with_keys(&mut context, owner_ovpk_m, owner_ivpk_m, owner));
     }
 
-    #[aztec(private)]
+    #[private]
     fn setNumber(
         number: Field,
         owner: AztecAddress,

boxes/init/src/main.nr

@@ -1,6 +1,9 @@
 
+use dep::aztec::macros::aztec;
+
+#[aztec]
 contract Main {
-    #[aztec(private)]
-    #[aztec(initializer)]
+    #[private]
+    #[initializer]
     fn constructor() { }
 }

l1-contracts/src/core/libraries/ConstantsGen.sol

@@ -130,16 +130,18 @@ library Constants {
   uint256 internal constant L2_GAS_PER_LOG_BYTE = 4;
   uint256 internal constant L2_GAS_PER_NOTE_HASH = 32;
   uint256 internal constant L2_GAS_PER_NULLIFIER = 64;
+  uint256 internal constant CANONICAL_KEY_REGISTRY_ADDRESS =
+    10536361358275073765062614648062211780027045486672640416335829595694222800789;
   uint256 internal constant CANONICAL_AUTH_REGISTRY_ADDRESS =
-    19361441716519463065948254497947932755739298943049449145365332870925554042208;
+    3193394520848240339042174260887368015244189807412437862264526499389876805968;
   uint256 internal constant DEPLOYER_CONTRACT_ADDRESS =
-    17119407406465801909352274670277571579675739451008438338071219340964365249977;
+    2888253181140434202600946137610803790678961451820394869801342223909105696356;
   uint256 internal constant REGISTERER_CONTRACT_ADDRESS =
-    12405643717676802437578418009978929188439257864607100766293128479227092050857;
+    21748523092328826737377319989875487952297567340504996985769574672917248477115;
   uint256 internal constant FEE_JUICE_ADDRESS =
-    12096583827711775893711303288210371301779120762215263550909768879597884314839;
+    8841799412790957220630076556157089925484823620333112594242679125846566463920;
   uint256 internal constant ROUTER_ADDRESS =
-    13369993014609648298719593339393818582619449364029983937306132176549332172208;
+    949422206351581749693459491613246405703946584592224897261267487800745982005;
   uint256 internal constant AZTEC_ADDRESS_LENGTH = 1;
   uint256 internal constant GAS_FEES_LENGTH = 2;
   uint256 internal constant GAS_LENGTH = 2;

noir-projects/aztec-nr/address-note/src/address_note.nr

@@ -1,20 +1,14 @@
 use dep::aztec::{
-    protocol_types::{
-    address::AztecAddress, traits::Empty, constants::GENERATOR_INDEX__NOTE_NULLIFIER,
-    hash::poseidon2_hash_with_separator
-},
-    note::{note_header::NoteHeader, note_interface::NoteInterface, utils::compute_note_hash_for_nullify},
-    oracle::unsafe_rand::unsafe_rand, keys::getters::get_nsk_app, context::PrivateContext
+    protocol_types::{address::AztecAddress, constants::GENERATOR_INDEX__NOTE_NULLIFIER, hash::poseidon2_hash_with_separator},
+    note::{note_header::NoteHeader, note_interface::NullifiableNote, utils::compute_note_hash_for_nullify},
+    oracle::unsafe_rand::unsafe_rand, keys::getters::get_nsk_app, context::PrivateContext,
+    macros::notes::note
 };
 
-global ADDRESS_NOTE_LEN: u32 = 3;
-// ADDRESS_NOTE_LEN * 32 + 32(storage_slot as bytes) + 32(note_type_id as bytes)
-global ADDRESS_NOTE_BYTES_LEN: u32 = 3 * 32 + 64;
-
 // docs:start:address_note_def
 // docs:start:address_note_struct
 // Stores an address
-#[aztec(note)]
+#[note]
 struct AddressNote {
     address: AztecAddress,
     // The nullifying public key hash is used with the nsk_app to ensure that the note can be privately spent.
@@ -23,7 +17,7 @@ struct AddressNote {
 }
 // docs:end:address_note_struct
 
-impl NoteInterface<ADDRESS_NOTE_LEN, ADDRESS_NOTE_BYTES_LEN> for AddressNote {
+impl NullifiableNote for AddressNote {
 
     fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullify: Field) -> Field {
         let secret = context.request_nsk_app(self.npk_m_hash);

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

@@ -34,7 +34,7 @@ use dep::protocol_types::{
 };
 
 // When finished, one can call .finish() to convert back to the abi
-struct PrivateContext {
+pub struct PrivateContext {
     // docs:start:private-context
     inputs: PrivateContextInputs,
     side_effect_counter: u32,

noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypted_event_emission.nr

@@ -6,15 +6,15 @@ use crate::{
 };
 use dep::protocol_types::{address::AztecAddress, hash::sha256_to_field};
 
-unconstrained fn compute_unconstrained<Event, let NB: u32, let MB: u32, let OB: u32>(
+unconstrained fn compute_unconstrained<Event, let N: u32, let OB: u32>(
     contract_address: AztecAddress,
     randomness: Field,
     ovsk_app: Field,
     ovpk: OvpkM,
     ivpk: IvpkM,
     recipient: AztecAddress,
     event: Event
-) -> ([u8; OB], Field) where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> ([u8; OB], Field) where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     compute(
         contract_address,
         randomness,
@@ -26,15 +26,15 @@ unconstrained fn compute_unconstrained<Event, let NB: u32, let MB: u32, let OB:
     )
 }
 
-fn compute<Event, let NB: u32, let MB: u32, let OB: u32>(
+fn compute<Event, let N: u32, let OB: u32>(
     contract_address: AztecAddress,
     randomness: Field,
     ovsk_app: Field,
     ovpk: OvpkM,
     ivpk: IvpkM,
     recipient: AztecAddress,
     event: Event
-) -> ([u8; OB], Field) where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> ([u8; OB], Field) where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     let encrypted_log: [u8; OB] = compute_encrypted_event_log(
         contract_address,
         randomness,
@@ -48,26 +48,26 @@ fn compute<Event, let NB: u32, let MB: u32, let OB: u32>(
     (encrypted_log, log_hash)
 }
 
-fn emit_with_keys<Event, let NB: u32, let MB: u32, let OB: u32>(
+fn emit_with_keys<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     randomness: Field,
     event: Event,
     ovpk: OvpkM,
     ivpk: IvpkM,
     iv: AztecAddress,
     inner_compute: fn(AztecAddress, Field, Field, OvpkM, IvpkM, AztecAddress, Event) -> ([u8; OB], Field)
-) where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     let contract_address: AztecAddress = context.this_address();
     let ovsk_app: Field  = context.request_ovsk_app(ovpk.hash());
     let (encrypted_log, log_hash) = inner_compute(contract_address, randomness, ovsk_app, ovpk, ivpk, iv, event);
     context.emit_raw_event_log_with_masked_address(randomness, encrypted_log, log_hash);
 }
 
-pub fn encode_and_encrypt_event<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     ov: AztecAddress,
     iv: AztecAddress
-) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         let ovpk = get_public_keys(ov).ovpk_m;
         let ivpk = get_public_keys(iv).ivpk_m;
@@ -76,11 +76,11 @@ pub fn encode_and_encrypt_event<Event, let NB: u32, let MB: u32, let OB: u32>(
     }
 }
 
-pub fn encode_and_encrypt_event_unconstrained<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_unconstrained<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     ov: AztecAddress,
     iv: AztecAddress
-) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         let ovpk = get_public_keys(ov).ovpk_m;
         let ivpk = get_public_keys(iv).ivpk_m;
@@ -89,75 +89,75 @@ pub fn encode_and_encrypt_event_unconstrained<Event, let NB: u32, let MB: u32, l
     }
 }
 
-pub fn encode_and_encrypt_event_with_randomness<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_with_randomness<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     randomness: Field,
     ov: AztecAddress,
     iv: AztecAddress
-) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext, Field)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext, Field)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         let ovpk = get_public_keys(ov).ovpk_m;
         let ivpk = get_public_keys(iv).ivpk_m;
         emit_with_keys(context, randomness, e, ovpk, ivpk, iv, compute);
     }
 }
 
-pub fn encode_and_encrypt_event_with_randomness_unconstrained<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_with_randomness_unconstrained<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     randomness: Field,
     ov: AztecAddress,
     iv: AztecAddress
-) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext, Field)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(AztecAddress, AztecAddress, &mut PrivateContext, Field)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         let ovpk = get_public_keys(ov).ovpk_m;
         let ivpk = get_public_keys(iv).ivpk_m;
         emit_with_keys(context, randomness, e, ovpk, ivpk, iv, compute_unconstrained);
     }
 }
 
-pub fn encode_and_encrypt_event_with_keys<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_with_keys<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     ovpk: OvpkM,
     ivpk: IvpkM,
     recipient: AztecAddress
-) -> fn[(&mut PrivateContext, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(&mut PrivateContext, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         let randomness = unsafe_rand();
         emit_with_keys(context, randomness, e, ovpk, ivpk, recipient, compute);
     }
 }
 
-pub fn encode_and_encrypt_event_with_keys_unconstrained<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_with_keys_unconstrained<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     ovpk: OvpkM,
     ivpk: IvpkM,
     recipient: AztecAddress
-) -> fn[(&mut PrivateContext, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(&mut PrivateContext, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         let randomness = unsafe_rand();
         emit_with_keys(context, randomness, e, ovpk, ivpk, recipient, compute_unconstrained);
     }
 }
 
-pub fn encode_and_encrypt_event_with_keys_with_randomness<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_with_keys_with_randomness<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     randomness: Field,
     ovpk: OvpkM,
     ivpk: IvpkM,
     recipient: AztecAddress
-) -> fn[(&mut PrivateContext, Field, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(&mut PrivateContext, Field, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         emit_with_keys(context, randomness, e, ovpk, ivpk, recipient, compute);
     }
 }
 
-pub fn encode_and_encrypt_event_with_keys_with_randomness_unconstrained<Event, let NB: u32, let MB: u32, let OB: u32>(
+pub fn encode_and_encrypt_event_with_keys_with_randomness_unconstrained<Event, let N: u32, let OB: u32>(
     context: &mut PrivateContext,
     randomness: Field,
     ovpk: OvpkM,
     ivpk: IvpkM,
     recipient: AztecAddress
-) -> fn[(&mut PrivateContext, Field, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<NB, MB>, [u8; NB]: LensForEncryptedEvent<NB, OB> {
+) -> fn[(&mut PrivateContext, Field, OvpkM, IvpkM, AztecAddress)](Event) -> () where Event: EventInterface<N>, [u8; N * 32 + 64]: LensForEncryptedEvent<N * 32 + 64, OB> {
     | e: Event | {
         emit_with_keys(context, randomness, e, ovpk, ivpk, recipient, compute_unconstrained);
     }