Struct NoteMetadata 

pub struct NoteMetadata { /* private fields */ }

Protocol-level note metadata that combines PartialNoteMetadata with attachment information.

This type wraps PartialNoteMetadata together with attachment headers and an attachment commitment, and knows how to encode them into a Word and compute commitments.

The metadata word is encoded as a single Word (4 felts) with the following layout:

0th felt: [sender_id_suffix (56 bits) | reserved (3 bits) | note_type (1 bit) | version (4 bits)]
1st felt: [sender_id_prefix (64 bits)]
2nd felt: [reserved (32 bits) | note_tag (32 bits)]
3rd felt: [attachment_3_scheme (16 bits) | attachment_2_scheme (16 bits) |
           attachment_1_scheme (16 bits) | attachment_0_scheme (16 bits)]

Felt validity is guaranteed:

• 0th felt: The lower 8 bits of the account ID suffix are 0 by construction, so they can be overwritten. The suffix’s MSB is zero so the felt stays valid when lower bits are set.
• 1st felt: Equivalent to the account ID prefix, so it inherits its validity.
• 2nd felt: The tag is a u32 and the reserved bits are currently set to zero, however users shouldn’t assume these are zero.
• 3rd felt: Max value is 0xFFFEFFFE_FFFEFFFE (schemes capped at 65534), which is less than p.

The version is hardcoded to 0 and is reserved for forward compatibility.

Implementations

impl NoteMetadata

pub fn new( partial_metadata: PartialNoteMetadata, attachments: &NoteAttachments, ) -> Self

Returns a new NoteMetadata derived from the given partial metadata and attachments.

The attachment headers and commitment are derived from the provided attachments.

pub fn from_parts( partial_metadata: PartialNoteMetadata, attachment_headers: [NoteAttachmentHeader; 4], attachments_commitment: Word, ) -> Self

Creates a NoteMetadata from its raw parts.

Prefer Self::new whenever possible.

pub fn partial_metadata(&self) -> &PartialNoteMetadata

Returns the inner PartialNoteMetadata.

pub fn sender(&self) -> AccountId

Returns the account which created the note.

pub fn note_type(&self) -> NoteType

Returns the note’s type.

pub fn tag(&self) -> NoteTag

Returns the tag associated with the note.

pub fn attachment_headers(&self) -> &[NoteAttachmentHeader; 4]

Returns the attachment headers.

pub fn attachments_commitment(&self) -> Word

Returns the attachments commitment.

pub fn is_private(&self) -> bool

Returns true if the note is private, false otherwise.

pub fn is_public(&self) -> bool

Returns true if the note is public, false otherwise.

pub fn to_metadata_word(&self) -> Word

Returns the metadata encoded as a Word.

See NoteMetadata docs for the layout.

pub fn to_commitment(&self) -> Word

Returns the commitment to the note metadata, which is defined as:

hash(NOTE_METADATA_WORD || ATTACHMENTS_COMMITMENT)

pub fn into_partial_metadata(self) -> PartialNoteMetadata

Consumes self and returns the inner PartialNoteMetadata.

Trait Implementations

impl Clone for NoteMetadata

fn clone(&self) -> NoteMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NoteMetadata

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

Formats the value using the given formatter.

impl Deserializable for NoteMetadata

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 min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

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

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

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

Deserializes Self from bytes with a byte budget limit.

impl PartialEq for NoteMetadata

fn eq(&self, other: &NoteMetadata) -> 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 Serializable for NoteMetadata

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

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

fn get_size_hint(&self) -> usize

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

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

Serializes self into a vector of bytes.

impl Copy for NoteMetadata

impl Eq for NoteMetadata

impl StructuralPartialEq for NoteMetadata