Struct polkadot_service::generic::Block

pub struct Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,  {
    pub header: Header,
    pub extrinsics: Vec<Extrinsic, Global>,
}

Abstraction over a substrate block.

Fields

header: Header

The block header.

extrinsics: Vec<Extrinsic, Global>

The accompanying extrinsics.

Trait Implementations

impl<Header, Extrinsic> Block for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + Member + Codec + Extrinsic + MaybeMallocSizeOf,
    Header: Header, 

type Extrinsic = Extrinsic

Type for extrinsics.

type Header = Header

Header type.

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

Block hash type.

pub fn header(&self) -> &<Block<Header, Extrinsic> as Block>::Header

Returns a reference to the header.

pub fn extrinsics(&self) -> &[<Block<Header, Extrinsic> as Block>::Extrinsic]

Returns a reference to the list of extrinsics.

pub fn deconstruct(
    self
) -> (<Block<Header, Extrinsic> as Block>::Header, Vec<<Block<Header, Extrinsic> as Block>::Extrinsic, Global>)

Split the block into header and list of extrinsics.

pub fn new(
    header: <Block<Header, Extrinsic> as Block>::Header,
    extrinsics: Vec<<Block<Header, Extrinsic> as Block>::Extrinsic, Global>
) -> Block<Header, Extrinsic>

Creates new block from header and extrinsics.

pub fn encode_from(
    header: &<Block<Header, Extrinsic> as Block>::Header,
    extrinsics: &[<Block<Header, Extrinsic> as Block>::Extrinsic]
) -> Vec<u8, Global>

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

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

Returns the hash of the block.

impl BlockBackend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> for Client

pub fn block_body(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<Option<Vec<<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Extrinsic, Global>>, Error>

Get block body by ID. Returns None if the body is not stored.

pub fn block(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<Option<SignedBlock<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>, Error>

Get full block by id.

pub fn block_status(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<BlockStatus, Error>

Get block status.

pub fn justifications(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<Option<Justifications>, Error>

Get block justifications for the block with the given id.

pub fn block_hash(
    &self,
    number: <<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Header as Header>::Number
) -> Result<Option<<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Hash>, Error>

Get block hash by number.

pub fn indexed_transaction(
    &self,
    id: &<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Hash
) -> Result<Option<Vec<u8, Global>>, Error>

Get single indexed transaction by content hash.

pub fn block_indexed_body(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<Option<Vec<Vec<u8, Global>, Global>>, Error>

Get all indexed transactions for a block, including renewed transactions.

fn has_indexed_transaction(
    &self,
    hash: &<Block as Block>::Hash
) -> Result<bool, Error>

Check if transaction index exists.

impl<Header, Extrinsic> Clone for Block<Header, Extrinsic> where
    Header: Clone,
    Extrinsic: Clone + MaybeSerialize, 

pub fn clone(&self) -> Block<Header, Extrinsic>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Header, Extrinsic> Debug for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + Debug,
    Header: Debug, 

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

Formats the value using the given formatter.

impl<Header, Extrinsic> Decode for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,
    Header: Decode,
    Vec<Extrinsic, Global>: Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Block<Header, Extrinsic>, Error> where
    __CodecInputEdqy: Input, 

Attempt to deserialise the value from input.

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<'de, Header, Extrinsic> Deserialize<'de> for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + Deserialize<'de>,
    Header: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Block<Header, Extrinsic>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<Header, Extrinsic> Encode for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,
    Header: Encode,
    Vec<Extrinsic, Global>: Encode, 

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

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    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 HeaderBackend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> for Client

pub fn header(
    &self,
    id: BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<Option<Header<u32, BlakeTwo256>>, Error>

Get block header. Returns None if block is not found.

pub fn info(&self) -> Info<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>

Get blockchain info.

pub fn status(
    &self,
    id: BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>
) -> Result<BlockStatus, Error>

Get block status.

pub fn number(&self, hash: H256) -> Result<Option<u32>, Error>

Get block number by hash. Returns None if the header is not in the chain.

pub fn hash(&self, number: u32) -> Result<Option<H256>, Error>

Get block hash by number. Returns None if the header is not in the chain.

fn block_hash_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>

Convert an arbitrary block ID into a block hash.

fn block_number_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>

Convert an arbitrary block ID into a block hash.

fn expect_header(
    &self,
    id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>

Get block header. Returns UnknownBlock error if block is not found.

fn expect_block_number_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>

Convert an arbitrary block ID into a block number. Returns UnknownBlock error if block is not found.

fn expect_block_hash_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>

Convert an arbitrary block ID into a block hash. Returns UnknownBlock error if block is not found.

impl<Header, Extrinsic> MallocSizeOf for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + MallocSizeOf,
    Header: MallocSizeOf, 

pub fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself. If T::size_of is a constant, consider implementing constant_size as well.

fn constant_size() -> Option<usize>

Used to optimize MallocSizeOf implementation for collections like Vec and HashMap to avoid iterating over them unnecessarily. The Self: Sized bound is for object safety.

impl<Header, Extrinsic> PartialEq<Block<Header, Extrinsic>> for Block<Header, Extrinsic> where
    Header: PartialEq<Header>,
    Extrinsic: PartialEq<Extrinsic> + MaybeSerialize, 

pub fn eq(&self, other: &Block<Header, Extrinsic>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Block<Header, Extrinsic>) -> bool

This method tests for !=.

impl<B> SelectChain<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> for SelectRelayChain<B> where
    B: Backend<PolkadotBlock> + 'static, 

fn leaves<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<Hash>, ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all leaves of the chain, i.e. block hashes that have no children currently. Leaves that can never be finalized will not be returned.

fn best_chain<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<PolkadotHeader, ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Among those leaves deterministically pick one chain as the generally best chain to author new blocks upon and probably (but not necessarily) finalize.

fn finality_target<'life0, 'async_trait>(
    &'life0 self,
    target_hash: Hash,
    maybe_max_number: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<Hash, ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get the best descendent of target_hash that we should attempt to finalize next, if any. It is valid to return the given target_hash itself if no better descendent exists.

impl<Header, Extrinsic> Serialize for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize + Serialize,
    Header: Serialize, 

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StorageProvider<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>> for Client

pub fn storage(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    key: &StorageKey
) -> Result<Option<StorageData>, Error>

Given a BlockId and a key, return the value under the key in that block.

pub fn storage_keys(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>

Given a BlockId and a key prefix, return the matching storage keys in that block.

pub fn storage_hash(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    key: &StorageKey
) -> Result<Option<<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Hash>, Error>

Given a BlockId and a key, return the value under the hash in that block.

pub fn storage_pairs(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    key_prefix: &StorageKey
) -> Result<Vec<(StorageKey, StorageData), Global>, Error>

Given a BlockId and a key prefix, return the matching child storage keys and values in that block.

pub fn storage_keys_iter(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    prefix: Option<&'a StorageKey>,
    start_key: Option<&StorageKey>
) -> Result<KeyIterator<'a, <Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> as Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>::State, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Error>

Given a BlockId and a key prefix, return a KeyIterator iterates matching storage keys in that block.

pub fn child_storage(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    child_info: &ChildInfo,
    key: &StorageKey
) -> Result<Option<StorageData>, Error>

Given a BlockId, a key and a child storage key, return the value under the key in that block.

pub fn child_storage_keys(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    child_info: &ChildInfo,
    key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>

Given a BlockId, a key prefix, and a child storage key, return the matching child storage keys.

pub fn child_storage_keys_iter(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    child_info: ChildInfo,
    prefix: Option<&'a StorageKey>,
    start_key: Option<&StorageKey>
) -> Result<KeyIterator<'a, <Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> as Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>::State, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Error>

Given a BlockId and a key prefix and a child storage key, return a KeyIterator that iterates matching storage keys in that block.

pub fn child_storage_hash(
    &self,
    id: &BlockId<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,
    child_info: &ChildInfo,
    key: &StorageKey
) -> Result<Option<<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Hash>, Error>

Given a BlockId, a key and a child storage key, return the hash under the key in that block.

impl UsageProvider<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> for Client

pub fn usage_info(
    &self
) -> ClientInfo<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>

Get usage info about current client.

impl<Header, Extrinsic> EncodeLike<Block<Header, Extrinsic>> for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,
    Header: Encode,
    Vec<Extrinsic, Global>: Encode, 

impl<Header, Extrinsic> Eq for Block<Header, Extrinsic> where
    Header: Eq,
    Extrinsic: Eq + MaybeSerialize, 

impl<Header, Extrinsic> StructuralEq for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize, 

impl<Header, Extrinsic> StructuralPartialEq for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,