Struct sc_basic_authorship::ProposerFactory

pub struct ProposerFactory<A, B, C, PR> { /* fields omitted */ }

Proposer factory.

Implementations

impl<A, B, C> ProposerFactory<A, B, C, DisableProofRecording>

pub fn new(
    spawn_handle: impl SpawnNamed + 'static,
    client: Arc<C>,
    transaction_pool: Arc<A>,
    prometheus: Option<&PrometheusRegistry>,
    telemetry: Option<TelemetryHandle>
) -> Self

Create a new proposer factory.

Proof recording will be disabled when using proposers built by this instance to build blocks.

impl<A, B, C> ProposerFactory<A, B, C, EnableProofRecording>

pub fn with_proof_recording(
    spawn_handle: impl SpawnNamed + 'static,
    client: Arc<C>,
    transaction_pool: Arc<A>,
    prometheus: Option<&PrometheusRegistry>,
    telemetry: Option<TelemetryHandle>
) -> Self

Create a new proposer factory with proof recording enabled.

Each proposer created by this instance will record a proof while building a block.

This will also include the proof into the estimation of the block size. This can be disabled by calling ProposerFactory::disable_proof_in_block_size_estimation.

pub fn disable_proof_in_block_size_estimation(&mut self)

Disable the proof inclusion when estimating the block size.

impl<A, B, C, PR> ProposerFactory<A, B, C, PR>

pub fn set_default_block_size_limit(&mut self, limit: usize)

Set the default block size limit in bytes.

The default value for the block size limit is: DEFAULT_BLOCK_SIZE_LIMIT.

If there is no block size limit passed to sp_consensus::Proposer::propose, this value will be used.

Trait Implementations

impl<A, B, Block, C, PR> Environment<Block> for ProposerFactory<A, B, C, PR> where
    A: TransactionPool<Block = Block> + 'static,
    B: Backend<Block> + Send + Sync + 'static,
    Block: BlockT,
    C: BlockBuilderProvider<B, Block, C> + HeaderBackend<Block> + ProvideRuntimeApi<Block> + Send + Sync + 'static,
    C::Api: ApiExt<Block, StateBackend = StateBackendFor<B, Block>> + BlockBuilderApi<Block>,
    PR: ProofRecording, 

type CreateProposer = Ready<Result<Self::Proposer, Self::Error>>

A future that resolves to the proposer.

type Proposer = Proposer<B, Block, C, A, PR>

The proposer type this creates.

type Error = Error

Error which can occur upon creation.

fn init(
    &mut self,
    parent_header: &<Block as BlockT>::Header
) -> Self::CreateProposer

Initialize the proposal logic on top of a specific header. Provide the authorities at that header.