Enum NoteFile 

pub enum NoteFile {
    NoteId(NoteId),
    ExpectedNote {
        details: NoteDetails,
        sync_hint: NoteSyncHint,
    },
    Committed {
        note: Note,
        proof: NoteInclusionProof,
    },
}

A serialized representation of a note.

A NoteFile can be used to communicate details of a note across network clients. Each variant covers a specific subset of use-cases and commit to specific trade-offs.

Variants

NoteId(NoteId)

The note’s details aren’t known, only its ID is. A client can import all the note details from the network. As such, the note that the ID commits to should be public.

ExpectedNote

The note’s details are known, but its metadata and attachments must be recovered from the chain.

This is useful for importing an expected note while avoiding an exact NoteId lookup. Looking a note up by its exact ID would reveal to the node which note the importer is interested in, leaking the receiver’s privacy. Instead, the importer can use the sync hint to search for matching notes by tag, then, for each returned note, recompute the note ID as NoteId::new(details_commitment, returned_metadata) using this variant’s details commitment; the returned note whose recomputed ID matches is the expected one. This recovers its metadata without revealing the note ID to the node.

Only the note’s details are carried here, as they may be private. Metadata and attachments are always public, so they are recovered from the chain rather than carried: once the note is found via the tag-based sync, its attachments can be fetched for the whole returned set (e.g. via get_notes_by_id) without revealing which note is the expected one.

Fields

details: NoteDetails

sync_hint: NoteSyncHint

Committed

The note has been committed to the chain and its inclusion proof is known.

Fields

note: Note

proof: NoteInclusionProof

Implementations

impl NoteFile

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

Returns the encoded file as a Protobuf message.

pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, NoteFileError>

Decodes a NoteFile from the provided bytes.

The encoded note carries its script, whose size is unbounded. A caller that decodes untrusted bytes must cap their length first.

Errors

Returns an error if the bytes are not a valid note file.

pub fn write(&self, path: impl AsRef<Path>) -> Result<(), NoteFileError>

Writes the encoded file to the provided path.

pub fn read(path: impl AsRef<Path>) -> Result<Self, NoteFileError>

Reads a NoteFile from the provided path.

Errors

Returns an error if the file cannot be read, or if Self::try_from_bytes rejects its contents.

Trait Implementations

impl Clone for NoteFile

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NoteFile

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

Formats the value using the given formatter.

impl Eq for NoteFile

impl From<&NoteFile> for NoteFile

fn from(file: &NoteFile) -> Self

Converts to this type from the input type.

impl From<&NoteFile> for NoteFileV1

fn from(file: &NoteFile) -> Self

Converts to this type from the input type.

impl From<Note> for NoteFile

fn from(note: Note) -> Self

Converts to this type from the input type.

impl From<NoteFile> for NoteFile

fn from(file: NoteFile) -> Self

Converts to this type from the input type.

impl From<NoteId> for NoteFile

fn from(note_id: NoteId) -> Self

Converts to this type from the input type.

impl PartialEq for NoteFile

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for NoteFile