Enum NoteTag

pub enum NoteTag {
    NetworkAccount(u32),
    NetworkUseCase(u16, u16),
    LocalPublicAny(u32),
    LocalAny(u32),
}

NoteTag`s are best effort filters for notes registered with the network.

Tags are light-weight values used to speed up queries. The 2 most significant bits of the tags have the following interpretation:

Prefix	Name	NoteExecutionMode	Target	Allowed NoteType
0b00	NetworkAccount	Network	Network Account	NoteType::Public
0b01	NetworkUseCase	Network	Use case	NoteType::Public
0b10	LocalPublicAny	Local	Any	NoteType::Public
0b11	LocalAny	Local	Any	Any

Where:

• NoteExecutionMode is set to NoteExecutionMode::Network to hint a Note should be consumed by the network. These notes will be further validated and if possible consumed by it.
• Target describes how to further interpret the bits in the tag.
  • For tags with a specific target, the rest of the tag is interpreted as a partial AccountId. For network accounts these are the first 30 bits of the ID while for local account targets, the first 14 bits are used - a trade-off between privacy and uniqueness.
  • For use case values, the meaning of the rest of the tag is not specified by the protocol and can be used by applications built on top of the rollup.

The note type is the only value enforced by the protocol. The rationale is that any note intended to be consumed by the network must be public to have all the details available. The public note for local execution is intended to allow users to search for notes that can be consumed right away, without requiring an off-band communication channel.

Note on Type Safety

Each enum variant contains the raw encoding of the note tag, where the first two bits should correspond to the variant’s prefix (as defined in the table above). However, because enum variants are always public, it is possible to instantiate this enum where this invariant does not hold, e.g. NoteTag::NetworkAccount(0b11...). For that reason, the enum variants should take precedence in case of such a mismatch and the inner value should not be accessed directly. Instead, only rely on NoteTag::as_u32 to access the encoded value, which will always return the correct value.

Variants

NetworkAccount(u32)

Represents a tag for a note intended for network execution, targeted at a network account. The note must be public.

NetworkUseCase(u16, u16)

Represents a tag for a note intended for network execution for a public use case. The note must be public.

LocalPublicAny(u32)

Represents a tag for a note intended for local execution.

This is used for two purposes:

• A public use case.
• A note targeted at any type of account.

In all cases, the note must be public.

LocalAny(u32)

Represents a tag for a note intended for local execution.

This is used for two purposes:

• A private use case.
• A note targeted at any type of account.

In all cases, the note can be of any type.

Implementations

impl NoteTag

pub fn from_account_id(account_id: AccountId) -> Self

Returns a new NoteTag::NetworkAccount or NoteTag::LocalAny instantiated from the specified account ID.

The tag is constructed as follows:

• For local execution (AccountStorageMode::Private or AccountStorageMode::Public), the two most significant bits are set to 0b11, which allows for any note type to be used. 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 for_public_use_case( use_case_id: u16, payload: u16, execution: NoteExecutionMode, ) -> Result<Self, NoteError>

Returns a new NoteTag::NetworkUseCase or NoteTag::LocalPublicAny instantiated for a custom use case which requires a public note.

The public use_case tag requires a NoteType::Public note.

The two high bits are set to the b10 or b01 depending on the execution hint, the next 14 bits are set to the use_case_id, and the low 16 bits are set to payload.

Errors

• If use_case_id is larger than or equal to $2^{14}$.

pub fn for_local_use_case( use_case_id: u16, payload: u16, ) -> Result<Self, NoteError>

Returns a new NoteTag::LocalAny instantiated for a custom local use case.

The local use_case tag is the only tag type that allows for NoteType::Private notes.

The two high bits are set to the b11, the next 14 bits are set to the use_case_id, and the low 16 bits are set to payload.

Errors

• If use_case_id is larger than or equal to 2^14.

pub fn is_single_target(&self) -> bool

Returns true if the note is intended for execution by a specific account, i.e. NoteTag::NetworkAccount

pub fn execution_mode(&self) -> NoteExecutionMode

Returns note execution mode defined by this tag.

If the most significant bit of the tag is 0 the note is intended for local execution; otherwise, the note is intended for network execution.

pub fn as_u32(&self) -> u32

Returns the inner u32 value of this tag.

pub fn validate(&self, note_type: NoteType) -> Result<Self, NoteError>

Returns an error if this tag is not consistent with the specified note type, and self otherwise.

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 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(value: NoteTag) -> Self

Converts to this type from the input type.

impl From<NoteTag> for u32

fn from(value: NoteTag) -> Self

Converts to this type from the input type.

impl From<u32> for NoteTag

fn from(value: 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