Enum SyncFrame 

pub enum SyncFrame {
    Hello {
        nonce: [u8; 32],
        max_frame: u32,
        min_protocol: u16,
        max_protocol: u16,
    },
    DomainRequest {
        domain_id: DomainId,
        epoch: u64,
        proof: [u8; 32],
        capability_chain: Vec<Vec<u8>>,
    },
    AuthorityState {
        epoch: u64,
        sequence: u64,
        head: Option<[u8; 32]>,
    },
    ControlGrant {
        transition: Vec<u8>,
        epoch_key: [u8; 32],
        capability_chain: Vec<Vec<u8>>,
    },
    ControlEvidence {
        transition: Vec<u8>,
    },
    Frontier {
        commits: Vec<CommitId>,
    },
    Need {
        commits: Vec<CommitId>,
    },
    Refs {
        commits: Vec<CommitId>,
    },
    Ack {
        commit: CommitId,
    },
    Done,
    Error {
        code: u16,
    },
    InvitationRequest,
    Invitation {
        payload: Vec<u8>,
    },
}

One canonical /iroh-db/sync/1 control-plane message.

Variants

Hello

Negotiates the protocol and binds a fresh session nonce.

Fields

nonce: [u8; 32]

Random session nonce.

max_frame: u32

Largest control frame accepted by the sender.

min_protocol: u16

Oldest object protocol the sender can safely accept.

max_protocol: u16

Newest object protocol the sender can safely accept.

DomainRequest

Proves possession of authorization material for exactly one domain.

Fields

domain_id: DomainId

Requested security domain.

epoch: u64

Historical epoch selected for the nonce-bound proof.

proof: [u8; 32]

Nonce-bound capability/key proof.

capability_chain: Vec<Vec<u8>>

Root-to-leaf capability evidence for the authenticated endpoint.

AuthorityState

Advertises the durable authority position before data reconciliation.

Fields

epoch: u64

Active domain epoch.

sequence: u64

Accepted control sequence, equal to the epoch for control format v3.

head: Option<[u8; 32]>

Canonical control-head ID, absent at genesis.

ControlGrant

Delivers one signed successor and digest-bound key over authenticated QUIC.

Fields

transition: Vec<u8>

Canonical signed iroh_db_security::ControlTransition bytes.

epoch_key: [u8; 32]

Symmetric key for the transition’s new epoch.

capability_chain: Vec<Vec<u8>>

Capability evidence required to validate transition authority.

ControlEvidence

Exchanges a signed control head as equivocation evidence without key material.

Fields

transition: Vec<u8>

Canonical signed iroh_db_security::ControlTransition bytes.

Frontier

Advertises the bounded causal frontier used as dependency-discovery roots.

Fields

commits: Vec<CommitId>

Canonically sorted unique commit IDs.

Need

Requests missing immutable commit objects.

Fields

commits: Vec<CommitId>

Canonically sorted unique commit IDs.

Refs

Announces immutable hashes available through iroh-blobs.

Fields

commits: Vec<CommitId>

Canonically sorted unique commit IDs.

Ack

Acknowledges durable acceptance of one commit.

Fields

commit: CommitId

Accepted commit ID.

Done

Completes a successful reconciliation round.

Error

Reports a bounded protocol error without sensitive context.

Fields

code: u16

Stable protocol error code.

InvitationRequest

Requests an endpoint-targeted invitation before domain membership exists.

Invitation

Delivers signed invitation bytes inside the authenticated QUIC session.

Fields

payload: Vec<u8>

Canonical signed invitation payload.

Implementations

impl SyncFrame

pub fn encode_canonical(&self) -> Result<Vec<u8>, SyncFrameError>

Encodes a strict, deterministic control frame.

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

Strictly decodes one bounded canonical control frame.

Trait Implementations

impl Clone for SyncFrame

fn clone(&self) -> SyncFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyncFrame

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

Formats the value using the given formatter.

impl PartialEq for SyncFrame

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

impl StructuralPartialEq for SyncFrame