Struct SyncRound 

pub struct SyncRound {
    pub task_id: String,
    pub round: u32,
    pub fragment_quorums: HashMap<u32, FragmentQuorumStatus>,
    pub state_root: Hash,
    pub syncer_signature: Signature,
    pub published_at: Timestamp,
    pub no_quorum_witnesses: Option<Vec<Signature>>,
}

Status of an in-flight or completed outer round, as published by the syncer. state_root is committed on-chain; observers can challenge it with a fraud proof.

Fields

task_id: String

round: u32

fragment_quorums: HashMap<u32, FragmentQuorumStatus>

Per-fragment status: which fragments have reached quorum.

state_root: Hash

Merkle root over (fragment_id, accepted_outer_gradient_hashes, post-aggregation parameter hash). Committed on-chain each round.

syncer_signature: Signature

Syncer signature over state_root || round || task_id.

published_at: Timestamp

When this round status was published.

no_quorum_witnesses: Option<Vec<Signature>>

No-Endorsement-Certificate carry-forward witnesses.

None for normal rounds. Some(sigs) when the witness committee could not assemble a 2f+1 quorum within grace_window_ms — each committee member publishes a signed “no-quorum” cert and the run advances to round + 1 carrying forward the prior state_root (which is set to the previous round’s state root, or Hash::zero() for round 0 NEC).

Trait Implementations

impl Clone for SyncRound

fn clone(&self) -> SyncRound

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyncRound

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SyncRound

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SyncRound

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SyncRound