Struct SyncPlan 

pub struct SyncPlan<E, S, V>
where
    E: Clock + Metrics + Storage,
    S: Scheme,
    V: Variant,
{ /* private fields */ }

Startup plan that determines whether one-time peer state sync may still run.

Construction is two-phase so the caller can avoid fetching a finalized floor from peers when state sync has already completed:

1. SyncPlan::init reads the durable state sync state.
2. If SyncPlan::may_state_sync returns true, the caller fetches a finalized floor and attaches it via SyncPlan::with_floor. Otherwise the caller skips floor selection entirely.

The plan owns the opened metadata store and is later consumed by Stateful, so startup does not reopen the same metadata partition from multiple places.

Once state sync completes, this node never performs peer state sync again. Future startups must recover from the later of that synced height and marshal’s processed height instead.

Implementations

impl<E, S, V> SyncPlan<E, S, V>

where E: Clock + Metrics + Storage, S: Scheme, V: Variant,

pub async fn init(context: &E, partition_prefix: impl AsRef<str>) -> Self

Load the durable state sync metadata for this partition prefix.

Panics

Panics if the metadata store cannot be opened. A node that cannot determine whether state sync already completed cannot safely choose a startup path.

pub fn may_state_sync(&self) -> bool

Returns whether state sync can still run on this node.

When false, the caller should skip floor selection: any floor passed to SyncPlan::with_floor would be ignored. The node already has a durable completed state sync height, so future boots must recover from that height or marshal’s processed height instead of running peer state sync again.

When true, the caller can optionally attach a finalized floor via SyncPlan::with_floor. If a floor is not attached, the node will attempt to sync from genesis via marshal unless it is resuming an interrupted state sync.

pub fn sync_height(&self) -> Option<Height>

Returns the durable completed state sync height, if one has been stored.

pub const fn partition_prefix(&self) -> &str

Returns the partition prefix to use for state sync metadata storage.

pub const fn floor(&self) -> Option<&Finalization<S, V::Commitment>>

Returns a reference to the finalized floor attached to this plan, if any.

pub fn with_floor(self, floor: Finalization<S, V::Commitment>) -> Self

Attach a finalized floor to state sync from.

Has no effect if state sync has already completed.

pub fn marshal_start<B>(&self, genesis: B) -> Start<S, V::Commitment, B>

Returns marshal’s startup anchor for this plan.

If a finalized floor was attached, marshal starts from that floor. Otherwise marshal starts from genesis and relies on its own durable progress to override that anchor when available.

pub fn requires_state_sync_floor(&self) -> bool

Returns whether startup must attach a new state sync floor.

This is true after a previous process crashed while state sync was in progress. In that case Self::may_state_sync is also true, but starting from marshal/genesis is not allowed because partially synced database state must be reopened through the state-sync path.