Struct IncomingBlock

pub struct IncomingBlock<B: BlockT> {
    pub hash: <B as BlockT>::Hash,
    pub header: Option<<B as BlockT>::Header>,
    pub body: Option<Vec<<B as BlockT>::Extrinsic>>,
    pub indexed_body: Option<Vec<Vec<u8>>>,
    pub justifications: Option<Justifications>,
    pub origin: Option<RuntimeOrigin>,
    pub allow_missing_state: bool,
    pub skip_execution: bool,
    pub import_existing: bool,
    pub state: Option<ImportedState<B>>,
}

Block data used by the queue.

Fields

hash: <B as BlockT>::Hash

Block header hash.

header: Option<<B as BlockT>::Header>

Block header if requested.

body: Option<Vec<<B as BlockT>::Extrinsic>>

Block body if requested.

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

Indexed block body if requested.

justifications: Option<Justifications>

Justification(s) if requested.

origin: Option<RuntimeOrigin>

The peer, we received this from

allow_missing_state: bool

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

skip_execution: bool

Skip block execution and state verification.

import_existing: bool

Re-validate existing block.

state: Option<ImportedState<B>>

Do not compute new state, but rather set it to the given set.

Trait Implementations

impl<B: Clone + BlockT> Clone for IncomingBlock<B>

fn clone(&self) -> IncomingBlock<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug + BlockT> Debug for IncomingBlock<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: PartialEq + BlockT> PartialEq for IncomingBlock<B>

fn eq(&self, other: &IncomingBlock<B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B: Eq + BlockT> Eq for IncomingBlock<B>

impl<B: BlockT> StructuralPartialEq for IncomingBlock<B>