fix: incorrect detection of note inputs length during note creation (#2066)

Author: PhilippGackstatter

CHANGELOG.md

@@ -1,12 +1,13 @@
 # Changelog
 
-## 0.12.1 (11-05-2025)
+## 0.12.1 (2025-11-06)
 
+- Fixed incorrect detection of note inputs length during note creation ([#2066](https://github.com/0xMiden/miden-base/pull/2066)).
 - Made `InitStorageData::map_entries()` public ([#2055](https://github.com/0xMiden/miden-base/pull/2055)).
 - Enabled handling of empty maps in account component templates ([#2056](https://github.com/0xMiden/miden-base/pull/2056)).
 - Changed auth components to increment nonce if it is zero ([#2060](https://github.com/0xMiden/miden-base/pull/2060)).
 
-## 0.12.0 (11-05-2025)
+## 0.12.0 (2025-11-05)
 
 ### Features
 

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

@@ -122,13 +122,34 @@ end
 #! - num_inputs is greater than 128.
 #!
 #! Invocation: exec
-export.build_recipient
+export.build_recipient.1
     dup.1 dup.1
     # => [inputs_ptr, num_inputs, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
 
     exec.compute_inputs_commitment
     # => [INPUTS_COMMITMENT, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
 
+    # store num_inputs into local memory
+    dup.5 loc_store.0
+    # => [INPUTS_COMMITMENT, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+
+    locaddr.0 add.1
+    locaddr.0
+    # => [num_inputs_start_ptr, num_inputs_end_ptr, INPUTS_COMMITMENT, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+
+    dup.5 dup.5 dup.5 dup.5
+    # => [INPUTS_COMMITMENT, num_inputs_start_ptr, num_inputs_end_ptr,
+    #     INPUTS_COMMITMENT, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+
+    # compute the advice map key for num_inputs by hashing the inputs commitment
+    hash
+    # => [hash(INPUTS_COMMITMENT), num_inputs_start_ptr, num_inputs_end_ptr,
+    #     INPUTS_COMMITMENT, inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+
+    adv.insert_mem
+    dropw drop drop
+    # => [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]
 

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

@@ -175,6 +175,10 @@ impl TransactionArgs {
             (sn_script_hash, concat_words(sn_hash, script.root())),
             (note_recipient.digest(), concat_words(sn_script_hash, inputs.commitment())),
             (inputs.commitment(), inputs.to_elements()),
+            (
+                Hasher::hash_elements(inputs.commitment().as_elements()),
+                vec![Felt::from(inputs.num_values())],
+            ),
             (script.root(), script_encoded),
         ];
 

crates/miden-testing/tests/scripts/faucet.rs

@@ -333,16 +333,16 @@ async fn test_public_note_creation_with_script_from_datastore() -> anyhow::Resul
     let target_account_suffix = recipient_account_id.suffix();
     let target_account_prefix = recipient_account_id.prefix().as_felt();
 
-    // Adding extra 0 values to inputs to test trial unhashing in extract_note_inputs fn
+    // Use a length that is not a multiple of 8 (double word size) to make sure note inputs padding
+    // is correctly handled
     let note_inputs = NoteInputs::new(vec![
         target_account_suffix,
         target_account_prefix,
         Felt::new(0),
         Felt::new(0),
         Felt::new(0),
-        Felt::new(0),
-        Felt::new(0),
         Felt::new(1),
+        Felt::new(0),
     ])?;
 
     let note_recipient =
@@ -362,23 +362,21 @@ async fn test_public_note_creation_with_script_from_datastore() -> anyhow::Resul
                 # Build recipient hash from SERIAL_NUM, SCRIPT_ROOT, and INPUTS_COMMITMENT
                 push.{script_root}
                 # => [SCRIPT_ROOT]
-                
+
                 push.{serial_num}
                 # => [SERIAL_NUM, SCRIPT_ROOT]
 
-                # Store note inputs in memory at address 0
-                # First word: inputs[0..4]
-                push.{input0}.{input1}.{input2}.{input3}
-                mem_storew_be.0 dropw
-                # Memory[0] = [input0, input1, input2, input3]
+                # Store note inputs in memory
+                push.{input0} mem_store.0
+                push.{input1} mem_store.1
+                push.{input2} mem_store.2
+                push.{input3} mem_store.3
+                push.{input4} mem_store.4
+                push.{input5} mem_store.5
+                push.{input6} mem_store.6
 
-                # Second word: inputs[4..8]
-                push.{input4}.{input5}.{input6}.{input7}
-                mem_storew_be.4 dropw
-                # Memory[1] = [input4, input5, input6, input7]
-
-                push.8 push.0
-                # => [inputs_ptr, num_inputs, SERIAL_NUM, SCRIPT_ROOT]
+                push.7 push.0
+                # => [inputs_ptr, num_inputs = 7, SERIAL_NUM, SCRIPT_ROOT]
 
                 exec.note::build_recipient
                 # => [RECIPIENT]
@@ -406,7 +404,6 @@ async fn test_public_note_creation_with_script_from_datastore() -> anyhow::Resul
         input4 = note_inputs.values()[4],
         input5 = note_inputs.values()[5],
         input6 = note_inputs.values()[6],
-        input7 = note_inputs.values()[7],
         script_root = output_script_root,
         serial_num = serial_num,
         aux = aux,
@@ -467,6 +464,11 @@ async fn test_public_note_creation_with_script_from_datastore() -> anyhow::Resul
         note_inputs.commitment(),
         "Output note inputs commitment should match expected inputs commitment"
     );
+    assert_eq!(
+        full_note.recipient().inputs().num_values(),
+        note_inputs.num_values(),
+        "Output note inputs length should match expected inputs length"
+    );
 
     // Verify the output note ID matches the expected note ID
     assert_eq!(full_note.id(), expected_note.id());

crates/miden-tx/src/host/kernel_process.rs

@@ -5,7 +5,7 @@ use miden_lib::transaction::memory::{
 };
 use miden_objects::account::AccountId;
 use miden_objects::note::{NoteId, NoteInputs};
-use miden_objects::{Word, ZERO};
+use miden_objects::{Hasher, Word};
 use miden_processor::{EventError, ExecutionError, Felt, ProcessState};
 
 use crate::errors::TransactionKernelError;
@@ -149,55 +149,45 @@ impl<'a> TransactionKernelProcess for ProcessState<'a> {
         Ok((inputs, script_root, serial_num))
     }
 
-    /// Extracts and validates note inputs from the advice provider using trial unhashing.
-    ///
-    /// This function tries to determine the correct number of inputs by:
-    /// 1. Finding the last non-zero element as a starting point
-    /// 2. Building NoteInputs and checking if the hash matches inputs_commitment
-    /// 3. If not, incrementing num_inputs and trying again (up to 6 more times)
-    /// 4. If num_inputs grows to the size of inputs_data and there's still no match, returning an
-    ///    error
+    /// Extracts and validates note inputs from the advice provider.
     fn read_note_inputs_from_adv_map(
         &self,
         inputs_commitment: &Word,
     ) -> Result<NoteInputs, TransactionKernelError> {
         let inputs_data = self.advice_provider().get_mapped_values(inputs_commitment);
 
-        let inputs = match inputs_data {
-            None => NoteInputs::default(),
+        match inputs_data {
+            None => Ok(NoteInputs::default()),
             Some(inputs) => {
-                // Start with the last non-zero element as a hint
-                let initial_num_inputs =
-                    inputs.iter().rposition(|&x| x != ZERO).map(|pos| pos + 1).unwrap_or(0);
-
-                // Try different input counts using trial unhashing
-                let mut num_inputs = initial_num_inputs;
-
-                loop {
-                    let candidate_inputs = NoteInputs::new(inputs[0..num_inputs].to_vec())
-                        .map_err(TransactionKernelError::MalformedNoteInputs)?;
-
-                    if candidate_inputs.commitment() == *inputs_commitment {
-                        return Ok(candidate_inputs);
-                    }
-
-                    num_inputs += 1;
-                    if num_inputs > inputs.len() {
-                        break;
-                    }
+                let inputs_commitment_hash = Hasher::hash_elements(inputs_commitment.as_elements());
+                let num_inputs = self
+                    .advice_provider()
+                    .get_mapped_values(&inputs_commitment_hash)
+                    .ok_or_else(|| {
+                        TransactionKernelError::other(
+                            "expected num_inputs to be present in advice provider",
+                        )
+                    })?;
+                if num_inputs.len() != 1 {
+                    return Err(TransactionKernelError::other(
+                        "expected num_inputs advice entry to contain exactly one element",
+                    ));
+                }
+                let num_inputs = num_inputs[0].as_int() as usize;
+
+                let note_inputs = NoteInputs::new(inputs[0..num_inputs].to_vec())
+                    .map_err(TransactionKernelError::MalformedNoteInputs)?;
+
+                if &note_inputs.commitment() == inputs_commitment {
+                    Ok(note_inputs)
+                } else {
+                    Err(TransactionKernelError::InvalidNoteInputs {
+                        expected: *inputs_commitment,
+                        actual: note_inputs.commitment(),
+                    })
                 }
-
-                // If we've exhausted all attempts, return an error
-                return Err(TransactionKernelError::InvalidNoteInputs {
-                    expected: *inputs_commitment,
-                    actual: NoteInputs::new(inputs[0..num_inputs.min(inputs.len())].to_vec())
-                        .map(|i| i.commitment())
-                        .unwrap_or_default(),
-                });
             },
-        };
-
-        Ok(inputs)
+        }
     }
 
     fn has_advice_map_entry(&self, key: Word) -> bool {