Trait Block

pub trait Block:
    HeaderProvider<HeaderT = Self::Header>
    + Clone
    + Send
    + Sync
    + Codec
    + Eq
    + MaybeSerialize
    + Debug
    + 'static {
    type Extrinsic: Member + Codec + Extrinsic + MaybeSerialize;
    type Header: Header<Hash = Self::Hash> + MaybeSerializeDeserialize;
    type Hash: HashOutput;

    // Required methods
    fn header(&self) -> &Self::Header;
    fn extrinsics(&self) -> &[Self::Extrinsic];
    fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>);
    fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self;
    fn encode_from(
        header: &Self::Header,
        extrinsics: &[Self::Extrinsic],
    ) -> Vec<u8> ;

    // Provided method
    fn hash(&self) -> Self::Hash { ... }
}

Something which fulfills the abstract idea of a Substrate block. It has types for Extrinsic pieces of information as well as a Header.

You can get an iterator over each of the extrinsics and retrieve the header.

Required Associated Types

type Extrinsic: Member + Codec + Extrinsic + MaybeSerialize

Type for extrinsics.

type Header: Header<Hash = Self::Hash> + MaybeSerializeDeserialize

Header type.

type Hash: HashOutput

Block hash type.

Required Methods

fn header(&self) -> &Self::Header

Returns a reference to the header.

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

Returns a reference to the list of extrinsics.

fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>)

Split the block into header and list of extrinsics.

fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self

Creates new block from header and extrinsics.

fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8>

Creates an encoded block from the given header and extrinsics without requiring the creation of an instance.

Provided Methods

fn hash(&self) -> Self::Hash

Returns the hash of the block.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Header, Extrinsic> Block for gclient::ext::sp_runtime::generic::Block<Header, Extrinsic>

where Extrinsic: MaybeSerialize + Member + Codec + Extrinsic, Header: Header + MaybeSerializeDeserialize,

type Extrinsic = Extrinsic

type Header = Header

type Hash = <<Block<Header, Extrinsic> as Block>::Header as Header>::Hash

impl<Xt> Block for gclient::ext::sp_runtime::testing::Block<Xt>

where Xt: 'static + Codec + Send + Sync + Serialize + Clone + Eq + Debug + Extrinsic,

type Extrinsic = Xt

type Header = Header<u64, BlakeTwo256>

type Hash = <Header<u64, BlakeTwo256> as Header>::Hash