Skip to main content
Version: 0.17 (unstable)

Reading Notes

Miden provides two modules for reading note data, each for a different execution context:

  • active_note — used inside note scripts. Reads data from the note currently being executed (the note whose #[note_script] is running).
  • input_note — used inside transaction scripts and account code. Reads data from any input note by index, useful when a transaction consumes multiple notes and needs to inspect them.

active_note — the executing note​

When a note script runs, active_note provides access to the current note's storage, creation-time assets, and metadata:

use miden::active_note;

Storage​

Note storage is a sequence of Felt values set by the note creator (e.g., a target account ID, an expiration block height). The recommended way to access it is through the #[note] struct — fields are automatically deserialized from the note's storage:

#[note]
struct MyNote {
    target_account_id: AccountId,  // Deserialized from note storage automatically
}

See Note Scripts for the full #[note] pattern. The low-level active_note::get_storage() function is also available for advanced use cases:

let storage: Vec<Felt> = active_note::get_storage();

Assets​

let assets: Vec<Asset> = active_note::get_initial_assets();

The name makes the semantics explicit: these are the assets the note carried when it was created, before any in-transaction movement. This is an inspection API; iterating over this vector does not remove assets from the note's current state.

active_note::remove_asset(asset) -> Word removes the specified asset and returns its remaining value in the note, not the removed asset. The returned word is empty when the asset is fully removed. Remove the asset first, then pass the original asset to the account's receiving procedure. get_asset(index) reads the current asset state; get_initial_assets() always returns the creation-time list. The remove_all_assets helper remains MASM-only.

Identity and metadata​

let sender: AccountId = active_note::get_sender();
let recipient: Recipient = active_note::get_recipient();
let script_root: Word = active_note::get_script_root();
let serial_num: Word = active_note::get_serial_number();

Note metadata​

get_metadata() returns the encoded metadata header:

let metadata: NoteMetadata = active_note::get_metadata();

In the onchain Rust SDK, NoteMetadata contains a single header: Word; attachments and their commitment are queried separately.

In miden-protocol, the user-facing metadata used to construct a note is PartialNoteMetadata:

pub struct PartialNoteMetadata {
    sender: AccountId,
    note_type: NoteType,
    tag: NoteTag,
}

The protocol's full NoteMetadata wraps that partial metadata together with attachment headers and an attachments commitment. Its to_metadata_word() method produces the same four-felt header returned by the onchain SDK: sender suffix plus type/version, sender prefix, tag, and attachment schemes.

input_note — querying notes by index​

Inside transaction scripts or account code, use input_note to read data from any input note being consumed in the current transaction. Each function takes a NoteIdx identifying which note to query:

use miden::input_note;

Assets​

let info: input_note::InputNoteAssetsInfo = input_note::get_initial_assets_info(note_idx);
let assets: Vec<Asset> = input_note::get_initial_assets(note_idx);

InputNoteAssetsInfo contains commitment: Word and num_assets: u32.

Identity and metadata​

let sender: AccountId = input_note::get_sender(note_idx);
let recipient: Recipient = input_note::get_recipient(note_idx);
let script_root: Word = input_note::get_script_root(note_idx);
let serial_num: Word = input_note::get_serial_number(note_idx);

Storage​

let storage_info: input_note::InputNoteStorageInfo = input_note::get_storage_info(note_idx);

Unlike active_note::get_storage(), the input_note API only exposes the storage commitment and item count. To read the storage values, use active_note::get_storage() while that note is executing.

InputNoteStorageInfo contains commitment: Word and num_storage_items: u32.

Note metadata​

Returns the same metadata shape as active_note:

let metadata: NoteMetadata = input_note::get_metadata(note_idx);

Examples​

Reading storage and inspecting initial assets​

A note script that reads the target account ID from storage, verifies the consumer, and inspects the creation-time asset list:

use miden::{AccountId, Word, active_note, native_account, note};

#[note]
struct InspectionNote {
    target_account_id: AccountId,
}

#[note]
impl InspectionNote {
    #[note_script]
    pub fn run(self, _arg: Word) {
        assert_eq!(native_account::get_id(), self.target_account_id);

        // Inspection only: this does not remove assets from the active note.
        let _initial_assets = active_note::get_initial_assets();
    }
}

Reading input notes in a transaction script​

A transaction script that reads data from a consumed input note:

use miden::*;

#[tx_script]
pub fn run(_arg: Word) {
    // Query the first input note (index 0)
    let idx = NoteIdx { inner: felt!(0) };
    let _assets = input_note::get_initial_assets(idx);
    let _sender = input_note::get_sender(idx);
}

The underlying MASM APIs in protocol v0.17.0: active_note, input_note.