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 write(&self, filepath: impl AsRef<Path>) -> Result<(), Error>

Serializes and writes binary NoteFile to specified file

pub fn read(filepath: impl AsRef<Path>) -> Result<NoteFile, Error>

Reads from file and tries to deserialize an NoteFile

Trait Implementations

impl Clone for NoteFile

fn clone(&self) -> NoteFile

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<(), Error>

Formats the value using the given formatter.

impl Deserializable for NoteFile

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

where R: ByteReader,

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 Eq for NoteFile

impl From<Note> for NoteFile

fn from(note: Note) -> NoteFile

Converts to this type from the input type.

impl From<NoteId> for NoteFile

fn from(note_id: NoteId) -> NoteFile

Converts to this type from the input type.

impl PartialEq for NoteFile

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

Equality operator ==.

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

Inequality operator !=.

impl Serializable for NoteFile

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

where W: ByteWriter,

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 StructuralPartialEq for NoteFile