refactor: split input output note register structs

src/cli/input_notes.rs

@@ -10,7 +10,10 @@ use miden_client::{
     client::rpc::NodeRpcClient,
     store::{InputNoteRecord, NoteFilter as ClientNoteFilter, Store},
 };
-use miden_objects::{notes::NoteId, Digest};
+use miden_objects::{
+    notes::{NoteId, NoteInputs, NoteScript},
+    Digest,
+};
 use miden_tx::utils::{Deserializable, Serializable};
 
 use super::{Client, Parser};
@@ -119,7 +122,7 @@ fn list_input_notes<N: NodeRpcClient, S: Store>(
     filter: ClientNoteFilter,
 ) -> Result<(), String> {
     let notes = client.get_input_notes(filter)?;
-    print_notes_summary(&notes);
+    print_notes_summary(&notes)?;
     Ok(())
 }
 
@@ -164,7 +167,7 @@ pub fn import_note<N: NodeRpcClient, S: Store>(
     let input_note_record =
         InputNoteRecord::read_from_bytes(&contents).map_err(|err| err.to_string())?;
 
-    let note_id = input_note_record.note().id();
+    let note_id = input_note_record.id();
     client.import_input_note(input_note_record)?;
 
     Ok(note_id)
@@ -183,7 +186,7 @@ fn show_input_note<N: NodeRpcClient, S: Store>(
         get_note_with_id_prefix(&client, &note_id).map_err(|err| err.to_string())?;
 
     // print note summary
-    print_notes_summary(core::iter::once(&input_note_record));
+    print_notes_summary(core::iter::once(&input_note_record))?;
 
     let mut table = Table::new();
     table
@@ -192,14 +195,17 @@ fn show_input_note<N: NodeRpcClient, S: Store>(
 
     // print note script
     if show_script {
+        let script = NoteScript::read_from_bytes(input_note_record.details().script())
+            .map_err(|err| format!("Failed to parse the note record's program AST: {}", err))?;
+
         table
             .add_row(vec![
                 Cell::new("Note Script hash").add_attribute(Attribute::Bold),
-                Cell::new(input_note_record.note().script().hash()),
+                Cell::new(script.hash()),
             ])
             .add_row(vec![
                 Cell::new("Note Script code").add_attribute(Attribute::Bold),
-                Cell::new(input_note_record.note().script().code()),
+                Cell::new(script.code()),
             ]);
     };
 
@@ -208,32 +214,29 @@ fn show_input_note<N: NodeRpcClient, S: Store>(
         table
             .add_row(vec![
                 Cell::new("Note Vault hash").add_attribute(Attribute::Bold),
-                Cell::new(input_note_record.note().assets().commitment()),
+                Cell::new(input_note_record.assets().commitment()),
             ])
             .add_row(vec![Cell::new("Note Vault").add_attribute(Attribute::Bold)]);
 
-        input_note_record.note().assets().iter().for_each(|asset| {
+        input_note_record.assets().iter().for_each(|asset| {
             table.add_row(vec![Cell::new(format!("{:?}", asset))]);
         })
     };
 
     if show_inputs {
+        let inputs = NoteInputs::read_from_bytes(input_note_record.details().inputs())
+            .map_err(|err| format!("Failed to parse the note record's inputs: {}", err))?;
+
         table
             .add_row(vec![
                 Cell::new("Note Inputs hash").add_attribute(Attribute::Bold),
-                Cell::new(input_note_record.note().inputs().commitment()),
+                Cell::new(inputs.commitment()),
             ])
             .add_row(vec![Cell::new("Note Inputs").add_attribute(Attribute::Bold)]);
-        input_note_record
-            .note()
-            .inputs()
-            .values()
-            .iter()
-            .enumerate()
-            .for_each(|(idx, input)| {
-                table
-                    .add_row(vec![Cell::new(idx).add_attribute(Attribute::Bold), Cell::new(input)]);
-            });
+
+        inputs.values().iter().enumerate().for_each(|(idx, input)| {
+            table.add_row(vec![Cell::new(idx).add_attribute(Attribute::Bold), Cell::new(input)]);
+        });
     };
 
     println!("{table}");
@@ -242,7 +245,7 @@ fn show_input_note<N: NodeRpcClient, S: Store>(
 
 // HELPERS
 // ================================================================================================
-fn print_notes_summary<'a, I>(notes: I)
+fn print_notes_summary<'a, I>(notes: I) -> Result<(), String>
 where
     I: IntoIterator<Item = &'a InputNoteRecord>,
 {
@@ -255,22 +258,31 @@ where
         "Commit Height",
     ]);
 
-    notes.into_iter().for_each(|input_note_record| {
+    for input_note_record in notes {
         let commit_height = input_note_record
             .inclusion_proof()
             .map(|proof| proof.origin().block_num.to_string())
             .unwrap_or("-".to_string());
+
+        let script = NoteScript::read_from_bytes(input_note_record.details().script())
+            .map_err(|err| format!("Failed to parse the note record's program AST: {}", err))?;
+
+        let inputs = NoteInputs::read_from_bytes(input_note_record.details().inputs())
+            .map_err(|err| format!("Failed to parse the note record's inputs: {}", err))?;
+
         table.add_row(vec![
-            input_note_record.note().id().inner().to_string(),
-            input_note_record.note().script().hash().to_string(),
-            input_note_record.note().assets().commitment().to_string(),
-            input_note_record.note().inputs().commitment().to_string(),
-            Digest::new(input_note_record.note().serial_num()).to_string(),
+            input_note_record.id().inner().to_string(),
+            script.hash().to_string(),
+            input_note_record.assets().commitment().to_string(),
+            inputs.commitment().to_string(),
+            Digest::new(input_note_record.details().serial_num()).to_string(),
             commit_height,
         ]);
-    });
+    }
 
     println!("{table}");
+
+    Ok(())
 }
 
 // TESTS
@@ -319,7 +331,7 @@ mod tests {
         let (_, commited_notes, _, _) = mock_full_chain_mmr_and_notes(consumed_notes);
 
         let committed_note: InputNoteRecord = commited_notes.first().unwrap().clone().into();
-        let pending_note = InputNoteRecord::new(created_notes.first().unwrap().clone(), None);
+        let pending_note = InputNoteRecord::from(created_notes.first().unwrap().clone());
 
         client.import_input_note(committed_note.clone()).unwrap();
         client.import_input_note(pending_note.clone()).unwrap();
@@ -332,18 +344,14 @@ mod tests {
         let mut filename_path_pending = temp_dir();
         filename_path_pending.push("test_import_pending");
 
-        export_note(
-            &client,
-            &committed_note.note_id().inner().to_string(),
-            Some(filename_path.clone()),
-        )
-        .unwrap();
+        export_note(&client, &committed_note.id().inner().to_string(), Some(filename_path.clone()))
+            .unwrap();
 
         assert!(filename_path.exists());
 
         export_note(
             &client,
-            &pending_note.note_id().inner().to_string(),
+            &pending_note.id().inner().to_string(),
             Some(filename_path_pending.clone()),
         )
         .unwrap();
@@ -368,14 +376,14 @@ mod tests {
 
         import_note(&mut client, filename_path).unwrap();
         let imported_note_record: InputNoteRecord =
-            client.get_input_note(committed_note.note().id()).unwrap();
+            client.get_input_note(committed_note.id()).unwrap();
 
-        assert_eq!(committed_note.note().id(), imported_note_record.note().id());
+        assert_eq!(committed_note.id(), imported_note_record.id());
 
         import_note(&mut client, filename_path_pending).unwrap();
-        let imported_pending_note_record = client.get_input_note(pending_note.note().id()).unwrap();
+        let imported_pending_note_record = client.get_input_note(pending_note.id()).unwrap();
 
-        assert_eq!(imported_pending_note_record.note().id(), pending_note.note().id());
+        assert_eq!(imported_pending_note_record.id(), pending_note.id());
     }
 
     #[tokio::test]
@@ -410,19 +418,19 @@ mod tests {
         let (_, notes, _, _) = mock_full_chain_mmr_and_notes(consumed_notes);
 
         let committed_note: InputNoteRecord = notes.first().unwrap().clone().into();
-        let pending_note = InputNoteRecord::new(created_notes.first().unwrap().clone(), None);
+        let pending_note = InputNoteRecord::from(created_notes.first().unwrap().clone());
 
         client.import_input_note(committed_note.clone()).unwrap();
         client.import_input_note(pending_note.clone()).unwrap();
         assert!(pending_note.inclusion_proof().is_none());
         assert!(committed_note.inclusion_proof().is_some());
 
         // Check that we can fetch Both notes
-        let note = get_note_with_id_prefix(&client, &committed_note.note_id().to_hex()).unwrap();
-        assert_eq!(note.note_id(), committed_note.note_id());
+        let note = get_note_with_id_prefix(&client, &committed_note.id().to_hex()).unwrap();
+        assert_eq!(note.id(), committed_note.id());
 
-        let note = get_note_with_id_prefix(&client, &pending_note.note_id().to_hex()).unwrap();
-        assert_eq!(note.note_id(), pending_note.note_id());
+        let note = get_note_with_id_prefix(&client, &pending_note.id().to_hex()).unwrap();
+        assert_eq!(note.id(), pending_note.id());
 
         // Check that we get an error if many match
         let note_id_with_many_matches = "0x";

src/cli/mod.rs

@@ -151,7 +151,7 @@ pub(crate) fn get_note_with_id_prefix<N: NodeRpcClient, S: Store>(
             NoteIdPrefixFetchError::NoMatch(note_id_prefix.to_string())
         })?
         .into_iter()
-        .filter(|note_record| note_record.note_id().to_hex().starts_with(note_id_prefix))
+        .filter(|note_record| note_record.id().to_hex().starts_with(note_id_prefix))
         .collect::<Vec<_>>();
 
     if input_note_records.is_empty() {
@@ -160,7 +160,7 @@ pub(crate) fn get_note_with_id_prefix<N: NodeRpcClient, S: Store>(
     if input_note_records.len() > 1 {
         let input_note_record_ids = input_note_records
             .iter()
-            .map(|input_note_record| input_note_record.note_id())
+            .map(|input_note_record| input_note_record.id())
             .collect::<Vec<_>>();
         tracing::error!(
             "Multiple notes found for the prefix {}: {:?}",

src/cli/transactions.rs

@@ -142,7 +142,7 @@ fn build_transaction_template<N: NodeRpcClient, S: Store>(
                 .iter()
                 .map(|note_id| {
                     get_note_with_id_prefix(client, note_id)
-                        .map(|note_record| note_record.note_id())
+                        .map(|note_record| note_record.id())
                         .map_err(|err| err.to_string())
                 })
                 .collect::<Result<Vec<NoteId>, _>>()?;

src/client/sync.rs

@@ -206,14 +206,14 @@ impl<N: NodeRpcClient, S: Store> Client<N, S> {
             .store
             .get_input_notes(NoteFilter::Pending)?
             .iter()
-            .map(|n| n.note().id())
+            .map(|n| n.id())
             .collect();
 
         let pending_output_notes: Vec<NoteId> = self
             .store
             .get_output_notes(NoteFilter::Pending)?
             .iter()
-            .map(|n| n.note().id())
+            .map(|n| n.id())
             .collect();
 
         let mut pending_notes = [pending_input_notes, pending_output_notes].concat();

src/store/data_store.rs

@@ -38,7 +38,7 @@ impl<S: Store> DataStore for ClientDataStore<S> {
             .store
             .get_input_notes(NoteFilter::Committed)?
             .iter()
-            .map(|note_record| note_record.note_id())
+            .map(|note_record| note_record.id())
             .collect::<Vec<_>>();
 
         for note_id in notes {