Trait substrate_test_runtime_client::sp_consensus::Proposer[−][src]

pub trait Proposer<B> where
    B: Block, {
    type Error: 'static + From<Error> + Debug;
    type Transaction: 'static + Default + Send;
    type Proposal: 'static + Future + Send + Unpin;
    type ProofRecording: 'static + ProofRecording + Send + Sync;
    type Proof: 'static + Send + Sync;
    fn propose(
        self, 
        inherent_data: InherentData, 
        inherent_digests: Digest<<<B as Block>::Header as Header>::Hash>, 
        max_duration: Duration, 
        block_size_limit: Option<usize>
    ) -> Self::Proposal;
}
Expand description

Logic for a proposer.

This will encapsulate creation and evaluation of proposals at a specific block.

Proposers are generic over bits of “consensus data” which are engine-specific.

Associated Types

Error type which can occur when proposing or evaluating.

The transaction type used by the backend.

Future that resolves to a committed proposal with an optional proof.

The supported proof recording by the implementator of this trait. See ProofRecording for more information.

The proof type used by Self::ProofRecording.

Required methods

Create a proposal.

Gets the inherent_data and inherent_digests as input for the proposal. Additionally a maximum duration for building this proposal is given. If building the proposal takes longer than this maximum, the proposal will be very likely discarded.

If block_size_limit is given, the proposer should push transactions until the block size limit is hit. Depending on the finalize_block implementation of the runtime, it probably incorporates other operations (that are happening after the block limit is hit). So, when the block size estimation also includes a proof that is recorded alongside the block production, the proof can still grow. This means that the block_size_limit should not be the hard limit of what is actually allowed.

Return

Returns a future that resolves to a Proposal or to Error.

Implementors