feat: 64 bit log type id, 64 bit log metadata

Author: benesjan

noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr

@@ -105,12 +105,12 @@ pub unconstrained fn do_process_log<Env>(
 /// ```
 ///
 /// The expanded metadata itself is (currently) interpreted as a u64, of which:
-///  - the upper 57 bits are the log type id
-///  - the remaining 7 bits are called the 'log metadata'
+///  - the upper 64 bits are the log type id
+///  - the remaining 64 bits are called the 'log metadata'
 ///
 /// ```
-/// log_expanded_metadata: [  log_type_id   |  log_metadata ]
-///                        <--- 57 bits --->|<--- 7 bits --->
+/// log_expanded_metadata: [  log_type_id    |  log_metadata  ]
+///                        <---  64 bits --->|<--- 64 bits --->
 /// ```
 ///
 /// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is
@@ -134,8 +134,8 @@ unconstrained fn decode_log_plaintext(
     // See the documentation of this function for a description of the log layout
     let expanded_log_metadata = log_plaintext.get(0);
 
-    let log_type_id = ((expanded_log_metadata as u64) / 128);
-    let log_metadata = ((expanded_log_metadata as u64) % 128);
+    let log_type_id = ((expanded_log_metadata as u128) >> 64) as u64;
+    let log_metadata = (expanded_log_metadata as u64);
 
     let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);
 

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

@@ -0,0 +1,3 @@
+pub global PRIVATE_NOTE_LOG_TYPE_ID: Field = 0;
+pub global PARTIAL_NOTE_LOG_TYPE_ID: Field = 1;
+pub global PRIVATE_EVENT_LOG_TYPE_ID: Field = 2;

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

@@ -1,3 +1,4 @@
 pub mod encrypt;
 pub mod log_assembly_strategies;
 pub mod log_encryption;
+pub mod log_type;

noir-projects/aztec-nr/uint-note/src/uint_note.nr

@@ -1,6 +1,6 @@
 use dep::aztec::{
     context::{PrivateContext, PublicContext},
-    encrypted_logs::log_assembly_strategies::default_aes128,
+    encrypted_logs::{log_assembly_strategies::default_aes128, log_type::PARTIAL_NOTE_LOG_TYPE_ID},
     keys::getters::{get_nsk_app, get_public_keys},
     macros::notes::custom_note,
     note::note_interface::{NoteHash, NoteType},
@@ -188,9 +188,9 @@ struct PrivateUintPartialNotePrivateLogContent {
 
 impl NoteType for PrivateUintPartialNotePrivateLogContent {
     fn get_id() -> Field {
-        // We abuse the fact that note type ids are 7 bits long to use the 8th bit indicate the log corresponds to a
-        // partial note. Ideally we'd use proper events with selectors, but those are not handled well at the moment.
-        UintNote::get_id() + 128
+        // The log type id is 1 to indicate this is a partial note log, and the log metadata is the note type id
+        // TODO: Mixing the log type id and note type id here is a hack and should be separated.
+        (PARTIAL_NOTE_LOG_TYPE_ID * 2.pow_32(64)) + UintNote::get_id()
     }
 }
 

noir-projects/noir-contracts/contracts/nft_contract/src/types/nft_note.nr

@@ -1,6 +1,6 @@
 use dep::aztec::{
     context::{PrivateContext, PublicContext},
-    encrypted_logs::log_assembly_strategies::default_aes128,
+    encrypted_logs::{log_assembly_strategies::default_aes128, log_type::PARTIAL_NOTE_LOG_TYPE_ID},
     keys::getters::{get_nsk_app, get_public_keys},
     macros::notes::custom_note,
     note::note_interface::{NoteHash, NoteType},
@@ -113,7 +113,7 @@ impl NFTNote {
     /// Each partial note should only be used once, since otherwise multiple notes would be linked together and known to
     /// belong to the same owner.
     ///
-    /// As part of the partial note cration process, a log will be sent to `recipient` from `sender` so that they can
+    /// As part of the partial note creation process, a log will be sent to `recipient` from `sender` so that they can
     /// discover the note. `recipient` will typically be the same as `owner`.
     pub fn partial(
         owner: AztecAddress,
@@ -189,15 +189,15 @@ struct PrivateNFTPartialNotePrivateLogContent {
 
 impl NoteType for PrivateNFTPartialNotePrivateLogContent {
     fn get_id() -> Field {
-        // We abuse the fact that note type ids are 7 bits long to use the 8th bit indicate the log corresponds to a
-        // partial note. Ideally we'd use proper events with selectors, but those are not handled well at the moment.
-        NFTNote::get_id() + 128
+        // The log type id is 1 to indicate this is a partial note log, and the log metadata is the note type id
+        // TODO: Mixing the log type id and note type id here is a hack and should be separated.
+        (PARTIAL_NOTE_LOG_TYPE_ID * 2.pow_32(64)) + NFTNote::get_id()
     }
 }
 
 /// A partial instance of a NFTNote. This value represents a private commitment to the owner, randomness and storage
 /// slot, but the token id field has not yet been set. A partial note can be completed in public with the `complete`
-/// function (revealing the tolken id to the public), resulting in a NFTNote that can be used like any other one (except
+/// function (revealing the token id to the public), resulting in a NFTNote that can be used like any other one (except
 /// of course that its token id is known).
 #[derive(Packable, Serialize, Deserialize)]
 pub struct PartialNFTNote {
@@ -307,7 +307,7 @@ mod test {
             partial_note.compute_note_completion_log(token_id)[0],
         );
 
-        // Then we exctract all fields except the first of both logs (i.e. the public log tag), and combine them to
+        // Then we extract all fields except the first of both logs (i.e. the public log tag), and combine them to
         // produce the note's packed representation. This requires that the members of the intermediate structs are in
         // the same order as in NFTNote.
         let private_log_without_public_tag: [_; 2] = subarray(private_log_content.pack(), 1);