Trait sc_consensus_slots::SimpleSlotWorker[−][src]

pub trait SimpleSlotWorker<B: BlockT> {
    type BlockImport: BlockImport<B, Transaction = <Self::Proposer as Proposer<B>>::Transaction> + Send + 'static;
    type SyncOracle: SyncOracle;
    type JustificationSyncLink: JustificationSyncLink<B>;
    type CreateProposer: Future<Output = Result<Self::Proposer, Error>> + Send + Unpin + 'static;
    type Proposer: Proposer<B> + Send;
    type Claim: Send + 'static;
    type EpochData: Send + 'static;

Show methods    fn logging_target(&self) -> &'static str;

    fn block_import(&mut self) -> &mut Self::BlockImport;

    fn epoch_data(
        &self, 
        header: &B::Header, 
        slot: Slot
    ) -> Result<Self::EpochData, Error>;

    fn authorities_len(&self, epoch_data: &Self::EpochData) -> Option<usize>;

    fn claim_slot(
        &self, 
        header: &B::Header, 
        slot: Slot, 
        epoch_data: &Self::EpochData
    ) -> Option<Self::Claim>;

    fn pre_digest_data(
        &self, 
        slot: Slot, 
        claim: &Self::Claim
    ) -> Vec<DigestItem<B::Hash>>;

    fn block_import_params(
        &self
    ) -> Box<dyn Fn(B::Header, &B::Hash, Vec<B::Extrinsic>, StorageChanges<<Self::BlockImport as BlockImport<B>>::Transaction, B>, Self::Claim, Self::EpochData) -> Result<BlockImportParams<B, <Self::BlockImport as BlockImport<B>>::Transaction>, Error> + Send + 'static>;

    fn force_authoring(&self) -> bool;

    fn sync_oracle(&mut self) -> &mut Self::SyncOracle;

    fn justification_sync_link(&mut self) -> &mut Self::JustificationSyncLink;

    fn proposer(&mut self, block: &B::Header) -> Self::CreateProposer;

    fn telemetry(&self) -> Option<TelemetryHandle>;

    fn proposing_remaining_duration(&self, slot_info: &SlotInfo<B>) -> Duration;

    fn notify_slot(
        &self, 
        _header: &B::Header, 
        _slot: Slot, 
        _epoch_data: &Self::EpochData
    ) { ... }

    fn should_backoff(&self, _slot: Slot, _chain_head: &B::Header) -> bool { ... }

    fn on_slot<'life0, 'async_trait>(
        &'life0 mut self, 
        slot_info: SlotInfo<B>
    ) -> Pin<Box<dyn Future<Output = Option<SlotResult<B, <Self::Proposer as Proposer<B>>::Proof>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Send + 'async_trait,
    { ... }

}
Expand description

A skeleton implementation for SlotWorker which tries to claim a slot at its beginning and tries to produce a block if successfully claimed, timing out if block production takes too long.

Associated Types

A handle to a BlockImport.

A handle to a SyncOracle.

A handle to a JustificationSyncLink, allows hooking into the sync module to control the justification sync process.

The type of future resolving to the proposer.

The type of proposer to use to build blocks.

Data associated with a slot claim.

Epoch data necessary for authoring.

Required methods

The logging target to use when logging messages.

A handle to a BlockImport.

Returns the epoch data necessary for authoring. For time-dependent epochs, use the provided slot number as a canonical source of time.

Returns the number of authorities given the epoch data. None indicate that the authorities information is incomplete.

Tries to claim the given slot, returning an object with claim data if successful.

Return the pre digest data to include in a block authored with the given claim.

Returns a function which produces a BlockImportParams.

Whether to force authoring if offline.

Returns a handle to a SyncOracle.

Returns a handle to a JustificationSyncLink.

Returns a Proposer to author on top of the given block.

Returns a TelemetryHandle if any.

Remaining duration for proposing.

Provided methods

Notifies the given slot. Similar to claim_slot, but will be called no matter whether we need to author blocks or not.

Returns whether the block production should back off.

By default this function always returns false.

An example strategy that back offs if the finalized head is lagging too much behind the tip is implemented by BackoffAuthoringOnFinalizedHeadLagging.

Implements SlotWorker::on_slot.

Implementors