Struct NoteTag 

pub struct NoteTag(/* private fields */);

NoteTags are 32-bits of data that serve as best-effort filters for notes.

Tags enable quick lookups for notes related to particular use cases, scripts, or account prefixes.

Account Targets

A note targeted at an account is a note that is intended or even enforced to be consumed by a specific account. One example is a P2ID note that can only be consumed by a specific account ID. The tag for such a note should make it easy for the receiver to find the note. Therefore, the tag encodes a certain number of bits of the receiver account’s ID, by convention. Notably, it may not encode the full 32 bits of the target account’s ID to preserve the receiver’s privacy. See also the section on privacy below.

Because this convention is widely used, the note tag provides a dedicated constructor for this: NoteTag::with_account_target.

Use Case Tags

Use case notes are notes that are not intended to be consumed by a specific account, but by anyone willing to fulfill the note’s contract. One example is a SWAP note that trades one asset against another. Such a use case note can define the structure of their note tags. A sensible structure for a SWAP note could be:

• encoding the 2 bits of the note’s type.
• encoding the note script root, i.e. making it identifiable as a SWAP note, for example by using 16 bits of the SWAP script root.
• encoding the SWAP pair, for example by using 8 bits of the offered asset faucet ID and 8 bits of the requested asset faucet ID.

This allows clients to search for a public SWAP note that trades USDC against ETH only through the note tag. Since tags are not validated in any way and only act as best-effort filters, further local filtering is almost always necessary. For example, there could easily be a collision on the 8 bits used in SWAP tag’s faucet IDs.

Privacy vs Efficiency

Using note tags strikes a balance between privacy and efficiency. Without tags, querying a specific note ID reveals a user’s interest to the node. Conversely, downloading and filtering all registered notes locally is highly inefficient. Tags allow users to adjust their level of privacy by choosing how broadly or narrowly they define their search criteria, letting them find the right balance between revealing too much information and incurring excessive computational overhead.

Implementations

impl NoteTag

pub const DEFAULT_LOCAL_ACCOUNT_TARGET_TAG_LENGTH: u8 = 14

The default note tag length for an account ID with local execution.

pub const DEFAULT_NETWORK_ACCOUNT_TARGET_TAG_LENGTH: u8 = 30

The default note tag length for an account ID with network execution.

pub const MAX_ACCOUNT_TARGET_TAG_LENGTH: u8 = 30

The maximum number of bits that can be encoded into the tag for local accounts.

pub const fn new(tag: u32) -> Self

Creates a new NoteTag from an arbitrary u32.

pub fn with_account_target(account_id: AccountId) -> Self

Constructs a note tag that targets the given account_id.

The tag is constructed as follows:

• For local execution (AccountStorageMode::Private or AccountStorageMode::Public), the two most significant bits are set to 0b00. The following 14 bits are set to the most significant bits of the account ID, and the remaining 16 bits are set to 0.
• For network execution (AccountStorageMode::Network), the most significant bits are set to 0b00 and the remaining bits are set to the 30 most significant bits of the account ID.

pub fn with_custom_account_target( account_id: AccountId, tag_len: u8, ) -> Result<Self, NoteError>

Constructs a note tag that targets the given account_id with a custom tag_len.

The tag is constructed by:

• Setting the two most significant bits to zero.
• The next tag_len bits are set to the most significant bits of the account ID prefix.
• The remaining bits are set to zero.

Errors

Returns an error if tag_len is larger than NoteTag::MAX_ACCOUNT_TARGET_TAG_LENGTH.

pub fn as_u32(&self) -> u32

Returns the inner u32 value of this tag.

Trait Implementations

impl Clone for NoteTag

fn clone(&self) -> NoteTag

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NoteTag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NoteTag

fn default() -> NoteTag

Returns the “default value” for a type.

impl Deserializable for NoteTag

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl Display for NoteTag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<NoteTag> for Felt

fn from(tag: NoteTag) -> Self

Converts to this type from the input type.

impl From<NoteTag> for u32

fn from(tag: NoteTag) -> Self

Converts to this type from the input type.

impl From<u32> for NoteTag

fn from(tag: u32) -> Self

Converts to this type from the input type.

impl Hash for NoteTag

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for NoteTag

fn cmp(&self, other: &NoteTag) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for NoteTag

fn eq(&self, other: &NoteTag) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for NoteTag

fn partial_cmp(&self, other: &NoteTag) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serializable for NoteTag

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Copy for NoteTag

impl Eq for NoteTag

impl StructuralPartialEq for NoteTag