Trait sc_consensus_slots::SimpleSlotWorker

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_number: u64
    ) -> Result<Self::EpochData, Error>;
    fn authorities_len(&self, epoch_data: &Self::EpochData) -> Option<usize>;
    fn claim_slot(
        &self, 
        header: &B::Header, 
        slot_number: u64, 
        epoch_data: &Self::EpochData
    ) -> Option<Self::Claim>;
    fn pre_digest_data(
        &self, 
        slot_number: u64, 
        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_number: u64, 
        _epoch_data: &Self::EpochData
    ) { ... }
    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 = Result<(), Error>> + Send>>
    where
        Self: Send + Sync,
        <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

A handle to a BlockImport.

type SyncOracle: SyncOracle

A handle to a SyncOracle.

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

The type of future resolving to the proposer.

type Proposer: Proposer<B>

The type of proposer to use to build blocks.

type Claim: Send + 'static

Data associated with a slot claim.

type EpochData: Send + 'static

Epoch data necessary for authoring.

Loading content...

Required methods

fn logging_target(&self) -> &'static str

The logging target to use when logging messages.

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

A handle to a BlockImport.

fn epoch_data(
    &self,
    header: &B::Header,
    slot_number: u64
) -> Result<Self::EpochData, Error>

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>

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_number: u64,
    epoch_data: &Self::EpochData
) -> Option<Self::Claim>

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

fn pre_digest_data(
    &self,
    slot_number: u64,
    claim: &Self::Claim
) -> Vec<DigestItem<B::Hash>>

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>

Returns a function which produces a BlockImportParams.

fn force_authoring(&self) -> bool

Whether to force authoring if offline.

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

Returns a handle to a SyncOracle.

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

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

Loading content...

Provided methods

fn notify_slot(
    &self,
    _header: &B::Header,
    _slot_number: u64,
    _epoch_data: &Self::EpochData
)

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

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

Remaining duration of the slot.

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

Remaining duration for proposing. None means unlimited.

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

Implements the on_slot functionality from SlotWorker.

Loading content...

Implementors

Loading content...