Struct cumulus_primitives_core::ParachainBlockData

pub struct ParachainBlockData<B: BlockT> { /* private fields */ }

The parachain block that is created by a collator.

This is send as PoV (proof of validity block) to the relay-chain validators. There it will be passed to the parachain validation Wasm blob to be validated.

Implementations

impl<B: BlockT> ParachainBlockData<B>

pub fn new( header: <B as BlockT>::Header, extrinsics: Vec<<B as BlockT>::Extrinsic>, storage_proof: CompactProof ) -> Self

Creates a new instance of Self.

pub fn into_block(self) -> B

Convert self into the stored block.

pub fn into_header(self) -> B::Header

Convert self into the stored header.

pub fn header(&self) -> &B::Header

Returns the header.

pub fn extrinsics(&self) -> &[B::Extrinsic]

Returns the extrinsics.

pub fn storage_proof(&self) -> &CompactProof

Returns the CompactProof.

pub fn deconstruct(self) -> (B::Header, Vec<B::Extrinsic>, CompactProof)

Deconstruct into the inner parts.

Trait Implementations

impl<B: Clone + BlockT> Clone for ParachainBlockData<B>where B::Header: Clone, B::Extrinsic: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: BlockT> Decode for ParachainBlockData<B>where B::Header: Decode, Vec<B::Extrinsic>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<B: BlockT> Encode for ParachainBlockData<B>where B::Header: Encode, Vec<B::Extrinsic>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<B: BlockT> EncodeLike for ParachainBlockData<B>where B::Header: Encode, Vec<B::Extrinsic>: Encode,