Struct sc_consensus::block_import::BlockImportParams

#[non_exhaustive]
pub struct BlockImportParams<Block: BlockT, Transaction> {

    pub origin: BlockOrigin,
    pub header: Block::Header,
    pub justifications: Option<Justifications>,
    pub post_digests: Vec<DigestItem>,
    pub body: Option<Vec<Block::Extrinsic>>,
    pub indexed_body: Option<Vec<Vec<u8>>>,
    pub state_action: StateAction<Block, Transaction>,
    pub finalized: bool,
    pub intermediates: HashMap<Cow<'static, [u8]>, Box<dyn Any + Send>>,
    pub auxiliary: Vec<(Vec<u8>, Option<Vec<u8>>)>,
    pub fork_choice: Option<ForkChoiceStrategy>,
    pub import_existing: bool,
    pub post_hash: Option<Block::Hash>,
}

Data required to import a Block.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

origin: BlockOrigin

Origin of the Block

header: Block::Header

The header, without consensus post-digests applied. This should be in the same state as it comes out of the runtime.

Consensus engines which alter the header (by adding post-runtime digests) should strip those off in the initial verification process and pass them via the post_digests field. During block authorship, they should not be pushed to the header directly.

The reason for this distinction is so the header can be directly re-executed in a runtime that checks digest equivalence – the post-runtime digests are pushed back on after.

justifications: Option<Justifications>

Justification(s) provided for this block from the outside.

post_digests: Vec<DigestItem>

Digest items that have been added after the runtime for external work, like a consensus signature.

body: Option<Vec<Block::Extrinsic>>

The body of the block.

indexed_body: Option<Vec<Vec<u8>>>

Indexed transaction body of the block.

state_action: StateAction<Block, Transaction>

Specify how the new state is computed.

finalized: bool

Is this block finalized already? true implies instant finality.

intermediates: HashMap<Cow<'static, [u8]>, Box<dyn Any + Send>>

Intermediate values that are interpreted by block importers. Each block importer, upon handling a value, removes it from the intermediate list. The final block importer rejects block import if there are still intermediate values that remain unhandled.

auxiliary: Vec<(Vec<u8>, Option<Vec<u8>>)>

Auxiliary consensus data produced by the block. Contains a list of key-value pairs. If values are None, the keys will be deleted.

fork_choice: Option<ForkChoiceStrategy>

Fork choice strategy of this import. This should only be set by a synchronous import, otherwise it may race against other imports. None indicates that the current verifier or importer cannot yet determine the fork choice value, and it expects subsequent importer to modify it. If None is passed all the way down to bottom block importer, the import fails with an IncompletePipeline error.

import_existing: bool

Re-validate existing block.

post_hash: Option<Block::Hash>

Cached full header hash (with post-digests applied).

Implementations

impl<Block: BlockT, Transaction> BlockImportParams<Block, Transaction>

pub fn new(origin: BlockOrigin, header: Block::Header) -> Self

Create a new block import params.

pub fn post_hash(&self) -> Block::Hash

Get the full header hash (with post-digests applied).

pub fn post_header(&self) -> Block::Header

Get the post header.

pub fn clear_storage_changes_and_mutate<Transaction2>(
    self
) -> BlockImportParams<Block, Transaction2>

Auxiliary function for “converting” the transaction type.

Actually this just sets StorageChanges::Changes to None and makes rustc think that Self now uses a different transaction type.

pub fn take_intermediate<T: 'static>(
    &mut self,
    key: &[u8]
) -> Result<Box<T>, Error>

Take intermediate by given key, and remove it from the processing list.

pub fn intermediate<T: 'static>(&self, key: &[u8]) -> Result<&T, Error>

Get a reference to a given intermediate.

pub fn intermediate_mut<T: 'static>(
    &mut self,
    key: &[u8]
) -> Result<&mut T, Error>

Get a mutable reference to a given intermediate.

pub fn with_state(&self) -> bool

Check if this block contains state import action