Enum MessagePayload 

pub enum MessagePayload<'a> {
    BlobShare {
        chunk: Cow<'a, [u8]>,
    },
    KeyShare {
        sender_key: PrivateKey,
    },
    DeltaResponse {
        delta: Cow<'a, [u8]>,
    },
    DeltaNotFound,
    DagHeadsResponse {
        dag_heads: Vec<[u8; 32]>,
        root_hash: Hash,
    },
    Challenge {
        challenge: [u8; 32],
    },
    ChallengeResponse {
        signature: [u8; 64],
    },
    SnapshotBoundaryResponse {
        boundary_timestamp: u64,
        boundary_root_hash: Hash,
        dag_heads: Vec<[u8; 32]>,
    },
    SnapshotPage {
        payload: Cow<'a, [u8]>,
        uncompressed_len: u32,
        cursor: Option<Vec<u8>>,
        page_count: u64,
        sent_count: u64,
    },
    SnapshotError {
        error: SnapshotError,
    },
    TreeNodeResponse {
        nodes: Vec<TreeNode>,
        not_found: bool,
    },
    LevelWiseResponse {
        level: u32,
        nodes: Vec<LevelNode>,
        has_more_levels: bool,
    },
}

Response and follow-up message payloads.

Each variant represents a different type of response or continuation message in a sync protocol exchange.

Variants

BlobShare

Blob data chunk.

Fields

chunk: Cow<'a, [u8]>

Chunk of blob data.

KeyShare

Encryption key share.

Fields

sender_key: PrivateKey

The sender’s private key for the context.

DeltaResponse

Response to DeltaRequest containing the requested delta.

Fields

delta: Cow<'a, [u8]>

The serialized delta data.

DeltaNotFound

Delta not found response.

DagHeadsResponse

Response to DagHeadsRequest containing peer’s current heads and root hash.

Fields

dag_heads: Vec<[u8; 32]>

Current DAG head hashes.

root_hash: Hash

Current root hash.

Challenge

Challenge to prove ownership of claimed identity.

Fields

challenge: [u8; 32]

Random challenge bytes.

ChallengeResponse

Response to challenge with signature (Ed25519 signature is 64 bytes).

Fields

signature: [u8; 64]

Signature proving identity ownership.

SnapshotBoundaryResponse

Response to SnapshotBoundaryRequest.

Fields

boundary_timestamp: u64

Authoritative boundary timestamp (nanoseconds since epoch).

boundary_root_hash: Hash

Root hash for the boundary state.

dag_heads: Vec<[u8; 32]>

Peer’s DAG heads at the boundary.

SnapshotPage

A page of snapshot data.

Fields

payload: Cow<'a, [u8]>

Compressed payload data.

uncompressed_len: u32

Uncompressed length for validation.

cursor: Option<Vec<u8>>

Cursor for resuming (None if complete).

page_count: u64

Total page count.

sent_count: u64

Pages sent so far.

SnapshotError

Snapshot sync error.

Fields

error: SnapshotError

The error that occurred.

TreeNodeResponse

Response to TreeNodeRequest for HashComparison sync (CIP §4).

Contains tree nodes from the requested subtree for Merkle comparison.

Fields

nodes: Vec<TreeNode>

Tree nodes in the requested subtree.

For a request with max_depth=0: contains just the requested node. For max_depth=1: contains the node and its immediate children.

not_found: bool

True if the requested node was not found.

LevelWiseResponse

Response to LevelWiseRequest for LevelWise sync (CIP Appendix B).

Contains all nodes at the requested level for breadth-first comparison.

Fields

level: u32

Level these nodes are at.

nodes: Vec<LevelNode>

Nodes at this level.

Each node includes:

• id and hash for comparison
• parent_id for tree structure
• leaf_data if this is a leaf (includes full entity data for CRDT merge)

has_more_levels: bool

Whether there are more levels below this one.

Trait Implementations

impl<'a> BorshDeserialize for MessagePayload<'a>

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<'a> BorshSerialize for MessagePayload<'a>

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<'a> Debug for MessagePayload<'a>

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

Formats the value using the given formatter.

impl<'a> EnumExt for MessagePayload<'a>

fn deserialize_variant<__R: Read>( reader: &mut __R, variant_tag: u8, ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.