Struct TopicSyncResult 

pub struct TopicSyncResult {

    pub peers: Vec<String>,
    pub sync_type: String,
    pub errors: Vec<String>,
    pub pruned_inputs: u64,
    pub discarded_graphs: u64,
    pub anchor_walk_held_graphs: u64,
    pub finalized_graphs: u64,
    pub deadline_dropped_graphs: u64,
    pub cursor_moves: Vec<CursorMove>,
    pub deferred_graphs: u64,
    pub resumed_graphs: u64,
    pub converged_graphs: u64,
    pub dropped_graphs: Vec<DroppedDeferral>,
    pub stalled_graphs: u64,
    pub held_back_graphs: u64,
}

Sync result for a single topic.

Fields

peers: Vec<String>

Peer URLs discovered or configured for this topic.

sync_type: String

How peers were determined: “ship” or “peers”.

errors: Vec<String>

Any errors encountered during sync (peer URL -> error message): a peer whose sync failed or ran over its budget. A single UTXO whose graph ingest failed is NOT listed here: it is warned (Error ingesting UTXO), held back by the cursor gap guard and asked for again by the next sync.

pruned_inputs: u64

Manager-named inputs pruned because a peer answered that it does not hold them (the D8 decoy rule, GASPSync::pruned_inputs). Counted per distinct outpoint PER PEER per sync and summed over this topic’s peers: one decoy seen through two peers reads 2. Not errors: the graphs completed without those branches.

discarded_graphs: u64

Graphs the anchor check REFUSED and discarded whole (bsv-low #551, GASPSync::discarded_graphs): a root whose BEEF does not verify, or one the topic manager does not admit at the end of the replay. Summed over this topic’s peers. Not errors, and nothing of them was admitted.

anchor_walk_held_graphs: u64

Graphs HELD because their anchor’s script walk could not run within the engine’s walk budget (bsv-low #592; the E592 lens fold, H1 and L3; GASPSync::anchor_walk_held), summed over this topic’s peers. Nothing of them was finalized; each UTXO stays below its cursor until the peer serves its root proven. Not errors and not discarded.

finalized_graphs: u64

Graphs that passed the anchor check and were handed to submit, summed over this topic’s peers (bsv-low #552). Under a per-peer budget a graph is counted, and submitted, the moment it finalizes, so the count includes those of a peer the deadline then dropped. A counted graph had its first transaction submitted whole (the deadline never lands inside a submit); one whose later submit did not land is still counted, and its UTXO stays below the cursor. A graph is counted as its first submit STARTS; a first submit that FAULTS still counts here, so this is not a delivered count (bsv-low #559).

deadline_dropped_graphs: u64

Graphs that were mid-walk when a peer’s sync was dropped at its budget (bsv-low #552): at most one per peer per sync. NOTHING of such a graph was admitted; the next sync walks it again. The same root counted tick after tick with no finalized_graphs and no cursor_moves is ONE graph whose walk outlasts the budget (with a per-graph budget it is also counted in deferred_graphs and resumed, bsv-low #555).

cursor_moves: Vec<CursorMove>

Every persisted cursor that moved in this sync (bsv-low #552), one entry per peer. After a completed sync to is the peer’s highest score seen (less the gap guard); after a deadline it is GASPSync::completed_cursor: past completed UTXOs only.

deferred_graphs: u64

Graphs DEFERRED in this sync, summed over peers (bsv-low #555, Engine::set_graph_budget): a new record, or a resumed graph deferred again. Their UTXOs are held below the cursor.

resumed_graphs: u64

Graphs RESUMED from a record in this sync.

converged_graphs: u64

Resumed graphs that completed and landed in this sync (their record deleted).

dropped_graphs: Vec<DroppedDeferral>

Records deleted without converging, with their reason.

stalled_graphs: u64

Walks the per-graph budget (or the per-peer deadline) cut having fetched NOTHING in their pass (bsv-low #555, the lens fold’s H1). A peer’s sync whose only outcome was these is a failed attempt for the quarantine count.

held_back_graphs: u64

Records NOT resumed in this sync: the resumes of a peer’s pass share ONE per-graph budget and had spent it (the lens fold’s M1). Held for the next sync, untouched.

Trait Implementations

impl Clone for TopicSyncResult

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 TopicSyncResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TopicSyncResult

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TopicSyncResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.