Struct sc_basic_authorship::ProposerFactory

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

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.

pub fn set_soft_deadline(&mut self, percent: Percent)

Set soft deadline percentage.

The value is used to compute soft deadline during block production. The soft deadline indicates where we should stop attempting to add transactions to the block, which exhaust resources. After soft deadline is reached, we switch to a fixed-amount mode, in which after we see MAX_SKIPPED_TRANSACTIONS transactions which exhaust resrouces, we will conclude that the block is full.

Setting the value too low will significantly limit the amount of transactions we try in case they exhaust resources. Setting the value too high can potentially open a DoS vector, where many “exhaust resources” transactions are being tried with no success, hence block producer ends up creating an empty block.

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<<ProposerFactory<A, B, C, PR> as Environment<Block>>::Proposer, <ProposerFactory<A, B, C, PR> as Environment<Block>>::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.