Trait tc_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 CreateProposer: Future<Output = Result<Self::Proposer, Error>> + Send + Unpin + 'static;
    type Proposer: Proposer<B>;
    type Claim: Send + 'static;
    type EpochData: Send + 'static;
    fn logging_target(&self) -> &'static str;

    fn block_import(&self) -> Arc<Mutex<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 proposer(&mut self, block: &B::Header) -> Self::CreateProposer;

    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 slot_remaining_duration(&self, slot_info: &SlotInfo) -> Duration { ... }

    fn proposing_remaining_duration(
        &self, 
        _head: &B::Header, 
        slot_info: &SlotInfo
    ) -> Option<Duration> { ... }

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

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

type BlockImport: BlockImport<B, Transaction = <Self::Proposer as Proposer<B>>::Transaction> + Send + 'static[src]

A handle to a BlockImport.

type SyncOracle: SyncOracle[src]

A handle to a SyncOracle.

type CreateProposer: Future<Output = Result<Self::Proposer, Error>> + Send + Unpin + 'static[src]

The type of future resolving to the proposer.

type Proposer: Proposer<B>[src]

The type of proposer to use to build blocks.

type Claim: Send + 'static[src]

Data associated with a slot claim.

type EpochData: Send + 'static[src]

Epoch data necessary for authoring.

Loading content...

Required methods

fn logging_target(&self) -> &'static str[src]

The logging target to use when logging messages.

fn block_import(&self) -> Arc<Mutex<Self::BlockImport>>[src]

A handle to a BlockImport.

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

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

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

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

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

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

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

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

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>[src]

Returns a function which produces a BlockImportParams.

fn force_authoring(&self) -> bool[src]

Whether to force authoring if offline.

fn sync_oracle(&mut self) -> &mut Self::SyncOracle[src]

Returns a handle to a SyncOracle.

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

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

Loading content...

Provided methods

fn notify_slot(
    &self,
    _header: &B::Header,
    _slot: Slot,
    _epoch_data: &Self::EpochData
)[src]

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

fn should_backoff(&self, _slot: Slot, _chain_head: &B::Header) -> bool[src]

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.

fn slot_remaining_duration(&self, slot_info: &SlotInfo) -> Duration[src]

Remaining duration of the slot.

fn proposing_remaining_duration(
    &self,
    _head: &B::Header,
    slot_info: &SlotInfo
) -> Option<Duration>[src]

Remaining duration for proposing. None means unlimited.

fn on_slot(
    &mut self,
    chain_head: B::Header,
    slot_info: SlotInfo
) -> Pin<Box<dyn Future<Output = Option<SlotResult<B>>> + Send>> where
    <Self::Proposer as Proposer<B>>::Proposal: Unpin + Send + 'static, [src]

Implements SlotWorker::on_slot.

Loading content...

Implementors

Loading content...