feat: add `.is_network_note()` helper method for `Note` by partylikeits1983 · Pull Request #2365 · 0xMiden/protocol

partylikeits1983 · 2026-01-29T00:12:31Z

This PR adds a new NetworkNote type which makes it easy to determine if a Note is a network note or not.

Resolves: #2362

crates/miden-standards/src/note/network_note.rs

Copilot

Pull request overview

This PR introduces a new AccountTargetNetworkNote type and NetworkNoteExt trait to make it easier to determine if a Note is a network note and to access network-specific properties. This addresses issue #2362 by providing a cleaner, more discoverable API compared to the previous approach of using NetworkAccountTarget::try_from(note.metadata().attachment()).

Changes:

Added AccountTargetNetworkNote<'a> struct providing a view over notes with NetworkAccountTarget attachments
Added NetworkNoteExt trait with is_network_note() and as_account_target_network_note() convenience methods
Added integration test test_network_note_unwrap() verifying the new API works correctly

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 4 comments.

File	Description
crates/miden-standards/src/note/network_note.rs	New module defining `AccountTargetNetworkNote` struct and `NetworkNoteExt` trait for working with network notes
crates/miden-standards/src/note/mod.rs	Exports the new `AccountTargetNetworkNote` and `NetworkNoteExt` types
crates/miden-testing/src/kernel_tests/tx/test_output_note.rs	Adds integration test verifying the new network note API
CHANGELOG.md	Documents the addition of the NetworkNote type in release 0.14.0

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-02-20T16:50:06Z

crates/miden-standards/src/note/network_note.rs

+    /// Returns the target network [`AccountId`].
+    pub fn target_account_id(&self) -> AccountId {
+        self.target().target_id()
+    }
+
+    /// Returns the decoded [`NetworkAccountTarget`] attachment.
+    pub fn target(&self) -> NetworkAccountTarget {
+        NetworkAccountTarget::try_from(self.note.metadata().attachment())
+            .expect("AccountTargetNetworkNote guarantees valid NetworkAccountTarget attachment")
+    }
+
+    /// Returns the raw [`NoteAttachment`] from the note metadata.
+    pub fn attachment(&self) -> &NoteAttachment {
+        self.metadata().attachment()
+    }
+
+    /// Returns the [`NoteType`] of the underlying note.
+    pub fn note_type(&self) -> NoteType {
+        self.metadata().note_type()
+    }


Consider adding an execution_hint() accessor method to AccountTargetNetworkNote for consistency and convenience. While users can access it via network_note.target().execution_hint(), having a direct accessor like network_note.execution_hint() would match the pattern established with target_account_id() and provide a more convenient API. The NetworkAccountTarget already has an execution_hint() method that could be exposed here.

Agree with copilot.

Copilot · 2026-02-20T16:50:07Z

crates/miden-testing/src/kernel_tests/tx/test_output_note.rs

+
+    Ok(())
+}
+


The test test_network_note_unwrap only verifies the positive case where a note has a valid NetworkAccountTarget attachment. Consider also testing the negative cases where:

A note without a NetworkAccountTarget attachment (e.g., a regular P2ID note) returns false for is_network_note()

as_account_target_network_note() returns an appropriate error for non-network notes

This would provide more comprehensive coverage of the new API and ensure it correctly distinguishes between network and non-network notes.

Suggested change

#[tokio::test]

async fn test_non_network_note_is_not_marked_as_network() -> anyhow::Result<()> {

let sender = Account::mock(ACCOUNT_ID_PRIVATE_FUNGIBLE_FAUCET, Auth::IncrNonce);

let mut rng = RpoRandomCoin::new(Word::from([4, 3, 2, 1u32]));

// Build a regular note without a NetworkAccountTarget attachment.

let note = NoteBuilder::new(sender.id(), &mut rng)

.note_type(NoteType::Public)

.build()?;

assert!(!note.is_network_note());

Ok(())

}

#[tokio::test]

async fn test_non_network_note_unwrap_returns_error() -> anyhow::Result<()> {

let sender = Account::mock(ACCOUNT_ID_PRIVATE_FUNGIBLE_FAUCET, Auth::IncrNonce);

let mut rng = RpoRandomCoin::new(Word::from([5, 6, 7, 8u32]));

// Build a regular note without a NetworkAccountTarget attachment.

let note = NoteBuilder::new(sender.id(), &mut rng)

.note_type(NoteType::Public)

.build()?;

let result = note.as_account_target_network_note();

assert!(result.is_err());

Ok(())

}

CHANGELOG.md

Copilot · 2026-02-20T16:50:07Z

crates/miden-standards/src/note/network_note.rs

+use miden_protocol::account::AccountId;
+use miden_protocol::note::{Note, NoteAttachment, NoteMetadata, NoteType};
+
+use crate::note::{NetworkAccountTarget, NetworkAccountTargetError};
+
+/// A view over a [`Note`] that is guaranteed to target a network account via a
+/// [`NetworkAccountTarget`] attachment.
+///
+/// This represents a note that is specifically targeted at a single network account. In the future,
+/// other types of network notes may exist (e.g., SWAP notes that can be consumed by network
+/// accounts but are not targeted at a specific one).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AccountTargetNetworkNote<'a> {
+    note: &'a Note,
+}
+
+impl<'a> AccountTargetNetworkNote<'a> {
+    /// Attempts to construct an [`AccountTargetNetworkNote`] view over `note`.
+    ///
+    /// Returns an error if the note's attachment cannot be decoded as a [`NetworkAccountTarget`].
+    pub fn new(note: &'a Note) -> Result<Self, NetworkAccountTargetError> {
+        // Validate that the attachment is a valid NetworkAccountTarget
+        NetworkAccountTarget::try_from(note.metadata().attachment())?;
+        Ok(Self { note })
+    }
+
+    /// Returns the underlying [`Note`].
+    pub fn as_note(&self) -> &'a Note {
+        self.note
+    }
+
+    /// Returns the [`NoteMetadata`] of the underlying note.
+    pub fn metadata(&self) -> &NoteMetadata {
+        self.note.metadata()
+    }
+
+    /// Returns the target network [`AccountId`].
+    pub fn target_account_id(&self) -> AccountId {
+        self.target().target_id()
+    }
+
+    /// Returns the decoded [`NetworkAccountTarget`] attachment.
+    pub fn target(&self) -> NetworkAccountTarget {
+        NetworkAccountTarget::try_from(self.note.metadata().attachment())
+            .expect("AccountTargetNetworkNote guarantees valid NetworkAccountTarget attachment")
+    }
+
+    /// Returns the raw [`NoteAttachment`] from the note metadata.
+    pub fn attachment(&self) -> &NoteAttachment {
+        self.metadata().attachment()
+    }
+
+    /// Returns the [`NoteType`] of the underlying note.
+    pub fn note_type(&self) -> NoteType {
+        self.metadata().note_type()
+    }
+}
+
+/// Convenience helpers for [`Note`]s that may target a network account.
+pub trait NetworkNoteExt {
+    /// Returns `true` if this note's attachment decodes as a [`NetworkAccountTarget`].
+    fn is_network_note(&self) -> bool;
+
+    /// Returns an [`AccountTargetNetworkNote`] view, or an error if the attachment is not a valid
+    /// target.
+    fn as_account_target_network_note(
+        &self,
+    ) -> Result<AccountTargetNetworkNote<'_>, NetworkAccountTargetError>;
+}
+
+impl NetworkNoteExt for Note {
+    fn is_network_note(&self) -> bool {
+        NetworkAccountTarget::try_from(self.metadata().attachment()).is_ok()
+    }
+
+    fn as_account_target_network_note(
+        &self,
+    ) -> Result<AccountTargetNetworkNote<'_>, NetworkAccountTargetError> {
+        AccountTargetNetworkNote::new(self)
+    }
+}
+
+impl<'a> TryFrom<&'a Note> for AccountTargetNetworkNote<'a> {
+    type Error = NetworkAccountTargetError;
+
+    fn try_from(note: &'a Note) -> Result<Self, Self::Error> {
+        Self::new(note)
+    }
+}


The network_note.rs module lacks unit tests. Similar modules in this crate (such as network_account_target.rs, p2id.rs, p2ide.rs, and swap.rs) all include unit tests under a #[cfg(test)] section to validate their functionality. Consider adding unit tests that verify:

AccountTargetNetworkNote::new() succeeds when given a note with a valid NetworkAccountTarget attachment

AccountTargetNetworkNote::new() fails when given a note with an invalid attachment

is_network_note() returns true for notes with valid NetworkAccountTarget attachments and false otherwise

as_account_target_network_note() returns the correct result for both valid and invalid notes

The TryFrom implementation works correctly

These tests would complement the integration test in test_output_note.rs and ensure the module behaves correctly in isolation.

PhilippGackstatter

Looks good to me! Sorry for the delay!

Left a small comment re usability of this type in the node. I think copilot makes some good points as well.

PhilippGackstatter · 2026-02-25T13:09:35Z

crates/miden-standards/src/note/network_note.rs

+pub struct AccountTargetNetworkNote<'a> {
+    note: &'a Note,


I'd probably make this own the underlying note and provide unwrap functionality like AccountTargetNetworkNote::into_note(self) -> Note and AccountTargetNetworkNote::as_note(&self) -> &Note. NetworkNoteExt::as_account_target_network_note would become into_*.
I think without this the node would probably not be able to use the wrapper (and maybe that's fine?) cc @Mirko-von-Leipzig @sergerad .

Agreed - I think wrapping a full note (rather than just a reference) would make this more flexible. AFAIK, it most relevant contexts, we'd be converting a Note into AccountTargetNetworkNote. But also, if that's not the case, cloning here wouldn't be too bad either (and if we do want to avoid cloning, using Arc could be a better option).

PhilippGackstatter · 2026-02-25T13:10:21Z

crates/miden-standards/src/note/network_note.rs

+    /// Returns the target network [`AccountId`].
+    pub fn target_account_id(&self) -> AccountId {
+        self.target().target_id()
+    }
+
+    /// Returns the decoded [`NetworkAccountTarget`] attachment.
+    pub fn target(&self) -> NetworkAccountTarget {
+        NetworkAccountTarget::try_from(self.note.metadata().attachment())
+            .expect("AccountTargetNetworkNote guarantees valid NetworkAccountTarget attachment")
+    }
+
+    /// Returns the raw [`NoteAttachment`] from the note metadata.
+    pub fn attachment(&self) -> &NoteAttachment {
+        self.metadata().attachment()
+    }
+
+    /// Returns the [`NoteType`] of the underlying note.
+    pub fn note_type(&self) -> NoteType {
+        self.metadata().note_type()
+    }


Agree with copilot.

bobbinth

Looks good! Thank you! I left a couple of comments inline.

bobbinth · 2026-02-25T20:02:12Z

crates/miden-standards/src/note/network_note.rs

+pub struct AccountTargetNetworkNote<'a> {
+    note: &'a Note,


Agreed - I think wrapping a full note (rather than just a reference) would make this more flexible. AFAIK, it most relevant contexts, we'd be converting a Note into AccountTargetNetworkNote. But also, if that's not the case, cloning here wouldn't be too bad either (and if we do want to avoid cloning, using Arc could be a better option).

bobbinth · 2026-02-25T20:03:52Z

crates/miden-standards/src/note/network_note.rs

+/// other types of network notes may exist (e.g., SWAP notes that can be consumed by network
+/// accounts but are not targeted at a specific one).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AccountTargetNetworkNote<'a> {


I don't love the name AccountTargetNetworkNote, but also don't have much better suggestions. Maybe something like AccountBoundNetworkNote?

feat: implement NetworkNote type

c1aea73

partylikeits1983 force-pushed the ajl-network-note-newtype branch from 3b1b042 to c1aea73 Compare January 29, 2026 01:03

chore: add changelog

25a1c08

partylikeits1983 requested a review from PhilippGackstatter January 29, 2026 01:05

partylikeits1983 marked this pull request as ready for review January 29, 2026 01:05

PhilippGackstatter reviewed Jan 29, 2026

View reviewed changes

crates/miden-standards/src/note/network_note.rs Outdated Show resolved Hide resolved

crates/miden-standards/src/note/network_note.rs Show resolved Hide resolved

igamigo reviewed Jan 29, 2026

View reviewed changes

crates/miden-standards/src/note/network_note.rs Outdated Show resolved Hide resolved

crates/miden-standards/src/note/network_note.rs Outdated Show resolved Hide resolved

partylikeits1983 marked this pull request as draft January 29, 2026 15:07

mmagician added the pr-from-maintainers PRs that come from internal contributors or integration partners. They should be given priority label Feb 9, 2026

partylikeits1983 added 2 commits February 19, 2026 00:20

chore: merge next

3ab11bf

refactor: simplify NetworkNote error handling and optimize

edf5d44

partylikeits1983 marked this pull request as ready for review February 18, 2026 21:46

partylikeits1983 requested a review from PhilippGackstatter February 18, 2026 21:46

partylikeits1983 added 2 commits February 20, 2026 19:39

refactor: rename NetworkNote to AccountTargetNetworkNote

440ff7c

Merge branch 'next' into ajl-network-note-newtype

abdb131

partylikeits1983 requested a review from Copilot February 20, 2026 16:44

Copilot started reviewing on behalf of partylikeits1983 February 20, 2026 16:44 View session

chore: update changelog entry

f6c9255

Copilot AI reviewed Feb 20, 2026

View reviewed changes

partylikeits1983 changed the title ~~feat: implement NetworkNote newtype~~ feat: add .is_network_note() helper method for Note Feb 20, 2026

Merge branch 'next' into ajl-network-note-newtype

6f35372

PhilippGackstatter approved these changes Feb 25, 2026

View reviewed changes

Merge branch 'next' into ajl-network-note-newtype

9de7096

bobbinth approved these changes Feb 25, 2026

View reviewed changes

+#[tokio::test]
+async fn test_non_network_note_is_not_marked_as_network() -> anyhow::Result<()> {
+    let sender = Account::mock(ACCOUNT_ID_PRIVATE_FUNGIBLE_FAUCET, Auth::IncrNonce);
+    let mut rng = RpoRandomCoin::new(Word::from([4, 3, 2, 1u32]));
+    // Build a regular note without a NetworkAccountTarget attachment.
+    let note = NoteBuilder::new(sender.id(), &mut rng)
+        .note_type(NoteType::Public)
+        .build()?;
+    assert!(!note.is_network_note());
+    Ok(())
+}
+#[tokio::test]
+async fn test_non_network_note_unwrap_returns_error() -> anyhow::Result<()> {
+    let sender = Account::mock(ACCOUNT_ID_PRIVATE_FUNGIBLE_FAUCET, Auth::IncrNonce);
+    let mut rng = RpoRandomCoin::new(Word::from([5, 6, 7, 8u32]));
+    // Build a regular note without a NetworkAccountTarget attachment.
+    let note = NoteBuilder::new(sender.id(), &mut rng)
+        .note_type(NoteType::Public)
+        .build()?;
+    let result = note.as_account_target_network_note();
+    assert!(result.is_err());
+    Ok(())
+}

Conversation

partylikeits1983 commented Jan 29, 2026

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Feb 20, 2026

Choose a reason for hiding this comment

Uh oh!

PhilippGackstatter Feb 25, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 20, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Copilot AI Feb 20, 2026

Choose a reason for hiding this comment

Uh oh!

PhilippGackstatter left a comment

Choose a reason for hiding this comment

Uh oh!

PhilippGackstatter Feb 25, 2026

Choose a reason for hiding this comment

Uh oh!

bobbinth Feb 25, 2026

Choose a reason for hiding this comment

Uh oh!

PhilippGackstatter Feb 25, 2026

Choose a reason for hiding this comment

Uh oh!

bobbinth left a comment

Choose a reason for hiding this comment

Uh oh!

bobbinth Feb 25, 2026

Choose a reason for hiding this comment

Uh oh!

bobbinth Feb 25, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

6 participants