Struct SyncedNote 

pub struct SyncedNote {
    pub note_id: NoteId,
    pub metadata: NoteMetadata,
    pub inclusion_proof: NoteInclusionProof,
    pub details: Option<NoteDetails>,
    pub attachments: NoteAttachments,
}

Everything resolved about a single note during a notes sync: its identity, metadata, and inclusion proof (always present, from SyncNotes), its attachments, and the public note body when it was fetched via GetNotesById.

Fields

note_id: NoteId

Note ID of the synced note, as reported by SyncNotes.

metadata: NoteMetadata

The note’s full metadata, as reported by SyncNotes.

inclusion_proof: NoteInclusionProof

Inclusion proof for the note in the block, as reported by SyncNotes.

details: Option<NoteDetails>

The public note’s body, fetched via GetNotesById. None for a private note, and for a public note whose body was not requested or not returned.

attachments: NoteAttachments

The note’s attachments, either carried in full by the sync record or fetched via GetNotesById. Empty for a note whose metadata advertises none.

Implementations

impl SyncedNote

pub fn new( committed: CommittedNote, details: Option<NoteDetails>, attachments: NoteAttachments, ) -> Result<Self, RpcError>

Pairs a sync record with the content resolved for it, checking that the content is consistent with the record:

• Only a public note can have a body. The converse is not checked, since a public note legitimately has no body whenever its body was not requested.
• The attachments must hash to the metadata’s attachments commitment. This also catches a note advertising attachments whose content never arrived, which would be unconsumable.

Both sides of that check come from the node, so it is a consistency check between its responses. The note is authenticated by a consumer recomputing its id and inclusion proof.

A rejection concerns a single note, not the response as a whole: NodeRpcClient::sync_notes_with_content skips the offending note with a warning instead of failing the sync, since content availability can be influenced by the note’s creator.

pub fn block_num(&self) -> BlockNumber

Returns the number of the block in which the note was committed.

pub fn into_committed_note(self) -> CommittedNote

Consumes the synced note and returns its sync record together with the attachment content resolved for it. The note body, which the record does not hold, is dropped.

The returned record reports its attachments as resolved, so CommittedNote::needs_attachment_fetch is always false for it. A note without attachments carries an empty set.

Trait Implementations

impl Clone for SyncedNote

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 SyncedNote

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

Formats the value using the given formatter.