feat: enable public output note creation during NTX execution

CHANGELOG.md

@@ -42,6 +42,7 @@
 - Re-add bech32 encoding for `AccountId` ([#2018](https://github.com/0xMiden/miden-base/pull/2018)).
 - [BREAKING] Change `AccountTree` to be generic over `Smt` implementations ([#2006](https://github.com/0xMiden/miden-base/pull/2006)).
 - [BREAKING] Change `AccountTree` to be generic over `trait AccountTreeBackend` implementations ([#2006](https://github.com/0xMiden/miden-base/pull/2006)).
+- [BREAKING] Added `get_note_script()` method to `DataStore` trait to enable lazy loading of note scripts during transaction execution ([#1995](https://github.com/0xMiden/miden-base/pull/1995)).
 - [BREAKING] Separate account APIs in `miden::account` into `active_account` and `native_account` ([#2026](https://github.com/0xMiden/miden-base/pull/2026)).
 - [BREAKING] Remove `miden::account::get_native_nonce` procedure ([#2026](https://github.com/0xMiden/miden-base/pull/2026)).
 

crates/miden-lib/asm/miden/note.masm

@@ -1,8 +1,7 @@
+use.miden::account_id
 use.std::crypto::hashes::rpo
 use.std::mem
 
-use.miden::account_id
-
 # ERRORS
 # =================================================================================================
 
@@ -56,7 +55,7 @@ end
 #! - max_inputs_per_note is the max inputs per note.
 export.::miden::util::note::get_max_inputs_per_note
 
-#! Writes the assets data stored in the advice map to the memory specified by the provided 
+#! Writes the assets data stored in the advice map to the memory specified by the provided
 #! destination pointer.
 #!
 #! Inputs:
@@ -91,31 +90,70 @@ end
 #! Builds the recipient hash from note inputs, script root, and serial number.
 #!
 #! This procedure computes the commitment of the note inputs and then uses it to calculate the note
-#! recipient by hashing this commit, the provided script root, and the serial number.
+#! recipient by hashing this commitment, the provided script root, and the serial number.
 #!
-#! Inputs:  [inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
-#! Outputs: [RECIPIENT]
+#! Inputs:
+#!   Operand stack: [inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+#!   Advice map: {
+#!      INPUTS_COMMITMENT: [INPUTS],
+#!   }
+#! Outputs:
+#!   Operand stack: [RECIPIENT]
+#!   Advice map: {
+#!      INPUTS_COMMITMENT: [INPUTS],
+#!      RECIPIENT: [SERIAL_SCRIPT_HASH, INPUTS_COMMITMENT],
+#!      SERIAL_SCRIPT_HASH: [SERIAL_HASH, SCRIPT_ROOT],
+#!      SERIAL_HASH: [SERIAL_NUM, EMPTY_WORD],
+#!   }
 #!
 #! Where:
 #! - inputs_ptr is the memory address where the note inputs are stored.
 #! - num_inputs is the number of input values.
 #! - SCRIPT_ROOT is the script root of the note.
 #! - SERIAL_NUM is the serial number of the note.
-#! - RECIPIENT is the commitment to the input note's script, inputs, the serial number.
+#! - RECIPIENT is the commitment to the input note's script, inputs, and the serial number.
+#!
+#! Locals:
+#! - 0: inputs_ptr
+#! - 1: num_inputs
 #!
 #! Panics if:
 #! - inputs_ptr is not word-aligned (i.e., is not a multiple of 4).
 #! - num_inputs is greater than 128.
 #!
 #! Invocation: exec
 export.build_recipient
+    dup.1 dup.1
+    # => [inputs_ptr, num_inputs, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+
     exec.compute_inputs_commitment
-    # => [INPUTS_HASH, SERIAL_NUM, SCRIPT_ROOT]
+    # => [INPUTS_COMMITMENT, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+
+    movup.5 movup.5 dup movdn.2
+    # => [inputs_ptr, num_inputs, inputs_ptr, INPUTS_COMMITMENT, SERIAL_NUM, SCRIPT_ROOT]
+
+    add swap
+    # => [inputs_ptr, end_ptr, INPUTS_COMMITMENT, SERIAL_NUM, SCRIPT_ROOT]
+
+    movdn.5 movdn.5
+    # => [INPUTS_COMMITMENT, inputs_ptr, end_ptr, SERIAL_NUM, SCRIPT_ROOT]
+
+    adv.insert_mem
+    # => [INPUTS_COMMITMENT, inputs_ptr, end_ptr, SERIAL_NUM, SCRIPT_ROOT]
+
+    movup.4 drop movup.4 drop
+    # => [INPUTS_COMMITMENT, SERIAL_NUM, SCRIPT_ROOT]
 
     movdnw.2
-    # => [SERIAL_NUM, SCRIPT_ROOT, INPUTS_HASH]
+    # => [SERIAL_NUM, SCRIPT_ROOT, INPUTS_COMMITMENT]
+
+    padw adv.insert_hdword hmerge
+    # => [SERIAL_HASH, SCRIPT_ROOT, INPUTS_COMMITMENT]
+
+    swapw adv.insert_hdword hmerge
+    # => [SERIAL_SCRIPT_HASH, INPUTS_COMMITMENT]
 
-    exec.build_recipient_hash
+    swapw adv.insert_hdword hmerge
     # => [RECIPIENT]
 end
 
@@ -149,7 +187,7 @@ end
 #!
 #! Where:
 #! - METADATA is the metadata of some note.
-#! - sender_{prefix,suffix} are the prefix and suffix felts of the sender ID of the note which 
+#! - sender_{prefix,suffix} are the prefix and suffix felts of the sender ID of the note which
 #!   metadata was provided.
 export.extract_sender_from_metadata
     # => [aux, merged_tag_hint_payload, merged_sender_id_type_hint_tag, sender_id_prefix]

crates/miden-lib/build.rs

@@ -161,7 +161,7 @@ fn compile_tx_kernel(source_dir: &Path, target_dir: &Path) -> Result<Assembler>
     let output_file = target_dir.join("tx_kernel").with_extension(Library::LIBRARY_EXTENSION);
     kernel_lib.write_to_file(output_file).into_diagnostic()?;
 
-    let assembler = build_assembler(Some(kernel_lib))?.with_debug_mode(true);
+    let assembler = build_assembler(Some(kernel_lib))?;
 
     // assemble the kernel program and write it to the "tx_kernel.masb" file
     let mut main_assembler = assembler.clone();

crates/miden-lib/src/transaction/inputs.rs

@@ -344,10 +344,7 @@ impl TransactionAdviceInputs {
             let note_arg = tx_inputs.tx_args().get_note_args(note.id()).unwrap_or(&EMPTY_WORD);
 
             // recipient inputs / assets commitments
-            self.add_map_entry(
-                recipient.inputs().commitment(),
-                recipient.inputs().format_for_advice(),
-            );
+            self.add_map_entry(recipient.inputs().commitment(), recipient.inputs().to_elements());
             self.add_map_entry(assets.commitment(), assets.to_padded_assets());
 
             // note details / metadata

crates/miden-objects/src/note/inputs.rs

@@ -68,14 +68,13 @@ impl NoteInputs {
         &self.values
     }
 
-    /// Returns the note's input formatted to be used with the advice map.
+    /// Returns the note's input as a vector of field elements.
     ///
     /// The format is `INPUTS || PADDING`, where:
     ///
-    /// Where:
     /// - INPUTS is the variable inputs for the note
     /// - PADDING is the optional padding to align the data with a 2WORD boundary
-    pub fn format_for_advice(&self) -> Vec<Felt> {
+    pub fn to_elements(&self) -> Vec<Felt> {
         pad_inputs(&self.values)
     }
 }

crates/miden-objects/src/note/recipient.rs

@@ -1,8 +1,5 @@
-use alloc::vec::Vec;
 use core::fmt::Debug;
 
-use miden_crypto::Felt;
-
 use super::{
     ByteReader,
     ByteWriter,
@@ -63,24 +60,6 @@ impl NoteRecipient {
     pub fn digest(&self) -> Word {
         self.digest
     }
-
-    /// Returns the recipient formatted to be used with the advice map.
-    ///
-    /// The format is `inputs_length || INPUTS_COMMITMENT || SCRIPT_ROOT || SERIAL_NUMBER`
-    ///
-    /// Where:
-    /// - inputs_length is the length of the note inputs
-    /// - INPUTS_COMMITMENT is the commitment of the note inputs
-    /// - SCRIPT_ROOT is the commitment of the note script (i.e., the script's MAST root)
-    /// - SERIAL_NUMBER is the recipient's serial number
-    pub fn format_for_advice(&self) -> Vec<Felt> {
-        let mut result = Vec::with_capacity(13);
-        result.push(self.inputs.num_values().into());
-        result.extend(self.inputs.commitment());
-        result.extend(self.script.root());
-        result.extend(self.serial_num);
-        result
-    }
 }
 
 fn compute_recipient_digest(serial_num: Word, script: &NoteScript, inputs: &NoteInputs) -> Word {

crates/miden-objects/src/transaction/tx_args.rs

@@ -154,9 +154,10 @@ impl TransactionArgs {
 
     /// Populates the advice inputs with the expected recipient data for creating output notes.
     ///
-    /// The advice inputs' map is extended with the following keys:
-    ///
-    /// - recipient_digest |-> recipient details (inputs_hash, script_root, serial_num).
+    /// The advice inputs' map is extended with the following entries:
+    /// - RECIPIENT: [SERIAL_SCRIPT_HASH, INPUTS_COMMITMENT]
+    /// - SERIAL_SCRIPT_HASH: [SERIAL_HASH, SCRIPT_ROOT]
+    /// - SERIAL_HASH: [SERIAL_NUM, EMPTY_WORD]
     /// - inputs_commitment |-> inputs.
     /// - script_root |-> script.
     pub fn add_output_note_recipient<T: AsRef<NoteRecipient>>(&mut self, note_recipient: T) {
@@ -165,9 +166,15 @@ impl TransactionArgs {
         let script = note_recipient.script();
         let script_encoded: Vec<Felt> = script.into();
 
-        let new_elements = [
-            (note_recipient.digest(), note_recipient.format_for_advice()),
-            (inputs.commitment(), inputs.format_for_advice()),
+        // Build the advice map entries
+        let sn_hash = Hasher::merge(&[note_recipient.serial_num(), Word::empty()]);
+        let sn_script_hash = Hasher::merge(&[sn_hash, script.root()]);
+
+        let new_elements = vec![
+            (sn_hash, concat_words(note_recipient.serial_num(), Word::empty())),
+            (sn_script_hash, concat_words(sn_hash, script.root())),
+            (note_recipient.digest(), concat_words(sn_script_hash, inputs.commitment())),
+            (inputs.commitment(), inputs.to_elements()),
             (script.root(), script_encoded),
         ];
 
@@ -224,6 +231,14 @@ impl TransactionArgs {
     }
 }
 
+/// Concatenates two [`Word`]s into a [`Vec<Felt>`] containing 8 elements.
+fn concat_words(first: Word, second: Word) -> Vec<Felt> {
+    let mut result = Vec::with_capacity(8);
+    result.extend(first);
+    result.extend(second);
+    result
+}
+
 impl Default for TransactionArgs {
     fn default() -> Self {
         Self::new(AdviceMap::default())

crates/miden-testing/src/tx_context/builder.rs

@@ -292,9 +292,9 @@ impl TransactionContextBuilder {
             },
         };
 
-        let tx_args = TransactionArgs::default().with_note_args(self.note_args);
+        let mut tx_args = TransactionArgs::default().with_note_args(self.note_args);
 
-        let mut tx_args = if let Some(tx_script) = self.tx_script {
+        tx_args = if let Some(tx_script) = self.tx_script {
             tx_args.with_tx_script_and_args(tx_script, self.tx_script_args)
         } else {
             tx_args