Struct SubspaceSlotWorker

pub struct SubspaceSlotWorker<PosTable, Block, Client, E, SO, L, BS, AS>
where
    Block: BlockT,
    SO: SyncOracle + Send + Sync,
{ /* private fields */ }

Subspace slot worker responsible for block and vote production

Implementations

impl<PosTable, Block, Client, E, Error, SO, L, BS, AS> SubspaceSlotWorker<PosTable, Block, Client, E, SO, L, BS, AS>

where PosTable: Table, Block: BlockT, Client: ProvideRuntimeApi<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + AuxStore + 'static, Client::Api: SubspaceApi<Block, PublicKey>, E: Environment<Block, Error = Error> + Send + Sync, E::Proposer: Proposer<Block, Error = Error>, SO: SyncOracle + Send + Sync, L: JustificationSyncLink<Block>, BS: BackoffAuthoringBlocksStrategy<NumberFor<Block>> + Send + Sync, Error: Error + Send + From<Error> + 'static, AS: AuxStore + Send + Sync + 'static, BlockNumber: From<<Block::Header as Header>::Number>,

pub fn new( _: SubspaceSlotWorkerOptions<Block, Client, E, SO, L, BS, AS>, ) -> Self

Create new Subspace slot worker

Trait Implementations

impl<PosTable, Block, Client, E, SO, L, BS, AS> PotSlotWorker<Block> for SubspaceSlotWorker<PosTable, Block, Client, E, SO, L, BS, AS>

where Block: BlockT, Client: HeaderBackend<Block> + ProvideRuntimeApi<Block>, Client::Api: SubspaceApi<Block, PublicKey>, SO: SyncOracle + Send + Sync,

fn on_proof(&mut self, slot: Slot, checkpoints: PotCheckpoints)

Called when new proof of time is available for slot.

impl<PosTable, Block, Client, E, Error, SO, L, BS, AS> SimpleSlotWorker<Block> for SubspaceSlotWorker<PosTable, Block, Client, E, SO, L, BS, AS>

where PosTable: Table, Block: BlockT, Client: ProvideRuntimeApi<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + AuxStore + 'static, Client::Api: SubspaceApi<Block, PublicKey>, E: Environment<Block, Error = Error> + Send + Sync, E::Proposer: Proposer<Block, Error = Error>, SO: SyncOracle + Send + Sync, L: JustificationSyncLink<Block>, BS: BackoffAuthoringBlocksStrategy<NumberFor<Block>> + Send + Sync, Error: Error + Send + From<Error> + 'static, AS: AuxStore + Send + Sync + 'static, BlockNumber: From<<Block::Header as Header>::Number>,

type BlockImport = Box<dyn BlockImport<Block, Error = Error> + Sync + Send>

A handle to a BlockImport.

type SyncOracle = SubspaceSyncOracle<SO>

A handle to a SyncOracle.

type JustificationSyncLink = L

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

type CreateProposer = Pin<Box<dyn Future<Output = Result<<E as Environment<Block>>::Proposer, Error>> + Send>>

The type of future resolving to the proposer.

type Proposer = <E as Environment<Block>>::Proposer

The type of proposer to use to build blocks.

type Claim = (PreDigest<PublicKey>, SubspaceJustification)

Data associated with a slot claim.

type AuxData = ()

Auxiliary data necessary for authoring.

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

The logging target to use when logging messages.

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

A handle to a BlockImport.

fn aux_data( &self, _parent: &Block::Header, _slot: Slot, ) -> Result<Self::AuxData, ConsensusError>

Returns the auxiliary data necessary for authoring.

fn authorities_len(&self, _epoch_data: &Self::AuxData) -> Option<usize>

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

fn claim_slot<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, parent_header: &'life1 Block::Header, slot: Slot, _aux_data: &'life2 Self::AuxData, ) -> Pin<Box<dyn Future<Output = Option<Self::Claim>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn pre_digest_data( &self, _slot: Slot, (pre_digest, _justification): &Self::Claim, ) -> Vec<DigestItem>

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

fn block_import_params<'life0, 'life1, 'async_trait>( &'life0 self, header: Block::Header, header_hash: &'life1 Block::Hash, body: Vec<Block::Extrinsic>, storage_changes: StorageChanges<Block>, __arg5: Self::Claim, _aux_data: Self::AuxData, ) -> Pin<Box<dyn Future<Output = Result<BlockImportParams<Block>, ConsensusError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns a function which produces a BlockImportParams.

fn force_authoring(&self) -> bool

Whether to force authoring if offline.

fn should_backoff(&self, slot: Slot, chain_head: &Block::Header) -> bool

Returns whether the block production should back off.

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

Returns a handle to a SyncOracle.

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

Returns a handle to a JustificationSyncLink.

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

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

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

Returns a [TelemetryHandle] if any.

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

Remaining duration for proposing.

fn notify_slot( &self, _header: &<B as Block>::Header, _slot: Slot, _aux_data: &Self::AuxData, )

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

fn propose<'life0, 'life1, 'async_trait>( &'life0 mut self, proposer: Self::Proposer, claim: &'life1 Self::Claim, slot_info: SlotInfo<B>, end_proposing_at: Instant, ) -> Pin<Box<dyn Future<Output = Option<Proposal<B, <Self::Proposer as Proposer<B>>::Proof>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 'async_trait,

Propose a block by Proposer.

fn create_inherent_data<'life0, 'life1, 'async_trait>( slot_info: &'life0 SlotInfo<B>, logging_target: &'life1 str, end_proposing_at: Instant, ) -> Pin<Box<dyn Future<Output = Option<InherentData>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait,

Calls create_inherent_data and handles errors.

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: Sync + Send + 'async_trait,

Implements [SlotWorker::on_slot].