Struct TopicSyncResult 

pub struct TopicSyncResult {

    pub peer_results: HashMap<String, PeerSyncResult>,
    pub dead_graphs: u64,
    pub expired_swept: u64,
    pub cost: SyncCost,
    pub root_bounds: Vec<RootBound>,
    pub peers_skipped: Vec<SkippedPeer>,
    pub peers_filtered: Vec<String>,
    pub roots_proven: u64,
    pub roots_unproven: u64,
    pub cursor_held_by: Vec<String>,
    pub expired_refused: u64,
    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,
    pub backed_off_graphs: u64,
    pub waiting_graphs: u64,
    pub idle_counted: u64,
    pub unanchorable_graphs: u64,
    pub unanchorable_cleared: u64,
    pub strikes_refused: u64,
    pub faulted_roots: Vec<FaultedRoot>,
}

Sync result for a single topic.

Fields

peer_results: HashMap<String, PeerSyncResult>

dead_graphs: u64

expired_swept: u64

cost: SyncCost

root_bounds: Vec<RootBound>

peers_skipped: Vec<SkippedPeer>

peers_filtered: Vec<String>

roots_proven: u64

Root proof status after successful anchor validation and finalization.

roots_unproven: u64

cursor_held_by: Vec<String>

Outstanding outpoints on peers whose cursor did not advance.

expired_refused: u64

Distinct expired advert roots skipped before any proof request.

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.

backed_off_graphs: u64

Held records this sync sent to the long backoff (engine 0.1.10, gasp::IDLE_RESUMES_BEFORE_BACKOFF): resumed that many passes in a row with no node appended, not resumed again for gasp::IDLE_RESUME_RETRY_SECS.

waiting_graphs: u64

Held records this sync did not resume because they wait out that backoff: no request, the cursor passes them (engine 0.1.10).

idle_counted: u64

Held records whose resumed pass this sync counted one idle resume on (engine 0.1.11, gasp::DeferralStats::idle_counted): the pass asked the peer and appended nothing it kept, whether it ended in a save, a drop or an error. A captain reads the idle rule firing here.

unanchorable_graphs: u64

Roots recorded UNANCHORABLE in this sync (engine 0.1.9, GASPSync::unanchorable_recorded): their walk faulted in gasp::UNANCHORABLE_AFTER_FAULTED_RUNS consecutive runs; the cursor passes them, and each is walked again after gasp::UNANCHORABLE_RETRY_SECS. Nothing of them is admitted.

unanchorable_cleared: u64

Roots with a fault record that this sync walked again and admitted, or refused on a verdict: their record cleared (engine 0.1.9).

strikes_refused: u64

Strikes this sync could not write (engine 0.1.10, GASPSync::strikes_refused): past gasp::FAULT_RECORDS_PER_PEER_TOPIC, at the storage’s ceiling or on its fault. Each root is named in faulted_roots with its refused reason.

faulted_roots: Vec<FaultedRoot>

Every root a peer’s sync dropped in this run, once per (peer, root), named with its fault class, its faulted runs and whether it is now unanchorable (engine 0.1.9, GASPSync::faulted_roots). With cursor_held_by (what is neither finished nor held) the captain reads why the cursor stopped or moved.

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 Default for TopicSyncResult

fn default() -> Self

Returns the “default value” for a type.

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.