Struct tp_consensus::block_import::BlockImportParams

#[non_exhaustive]pub struct BlockImportParams<Block: BlockT, Transaction> {
    pub origin: BlockOrigin,
    pub header: Block::Header,
    pub justification: Option<Justification>,
    pub post_digests: Vec<DigestItemFor<Block>>,
    pub body: Option<Vec<Block::Extrinsic>>,
    pub storage_changes: Option<StorageChanges<Transaction, HashFor<Block>, NumberFor<Block>>>,
    pub finalized: bool,
    pub intermediates: HashMap<Cow<'static, [u8]>, Box<dyn Any>>,
    pub auxiliary: Vec<(Vec<u8>, Option<Vec<u8>>)>,
    pub fork_choice: Option<ForkChoiceStrategy>,
    pub allow_missing_state: bool,
    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.

justification: Option<Justification>

Justification provided for this block from the outside.

post_digests: Vec<DigestItemFor<Block>>

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.

storage_changes: Option<StorageChanges<Transaction, HashFor<Block>, NumberFor<Block>>>

The changes to the storage to create the state for the block. If this is Some(_), the block import will not need to re-execute the block for importing it.

finalized: bool

Is this block finalized already? true implies instant finality.

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

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.

allow_missing_state: bool

Allow importing the block skipping state verification if parent state is missing.

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 convert_transaction<Transaction2>(
    self
) -> BlockImportParams<Block, Transaction2>

Auxiliary function for “converting” the transaction type.

Actually this just sets storage_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.