Struct Config 

pub struct Config<DB, R>
where
    DB: Database,
    R: Resolver<Op = DB::Op, Digest = DB::Digest>,
    DB::Op: Encode,
{
    pub context: DB::Context,
    pub resolver: R,
    pub target: Target<DB::Digest>,
    pub max_outstanding_requests: usize,
    pub fetch_batch_size: NonZeroU64,
    pub apply_batch_size: usize,
    pub db_config: DB::Config,
    pub update_rx: Option<Receiver<Target<DB::Digest>>>,
    pub finish_rx: Option<Receiver<()>>,
    pub reached_target_tx: Option<Sender<Target<DB::Digest>>>,
    pub max_retained_roots: usize,
}

Configuration for creating a new Engine

Fields

context: DB::Context

Runtime context for creating database components

resolver: R

Network resolver for fetching operations and proofs

target: Target<DB::Digest>

Sync target (root digest and operation bounds)

max_outstanding_requests: usize

Maximum number of outstanding requests for operation batches

fetch_batch_size: NonZeroU64

Maximum operations to fetch per batch

apply_batch_size: usize

Number of operations to apply in a single batch

db_config: DB::Config

Database-specific configuration

update_rx: Option<Receiver<Target<DB::Digest>>>

Channel for receiving sync target updates

finish_rx: Option<Receiver<()>>

Channel that requests sync completion once the current target is reached.

When None, sync completes as soon as the target is reached.

reached_target_tx: Option<Sender<Target<DB::Digest>>>

Channel used to notify an observer once the current target is reached. The engine sends at most one notification for each target.

When reached_target_tx is Some(...), this receiver must be actively drained by the observer. The engine awaits send capacity on this channel before proceeding, so backpressure can pause progress at target.

max_retained_roots: usize

Maximum number of previous roots to retain for verifying in-flight requests after target updates. Set to 0 to disable (all retained requests will be re-fetched).