Trait polkadot_service::SelectChain

pub trait SelectChain<Block>: Sync + Send + Clone
where
    Block: Block,
{
    // Required methods
    fn leaves<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<<Block as Block>::Hash>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn best_chain<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<<Block as Block>::Header, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;

    // Provided method
    fn finality_target<'life0, 'async_trait>(
        &'life0 self,
        base_hash: <Block as Block>::Hash,
        _maybe_max_number: Option<<<Block as Block>::Header as Header>::Number>
    ) -> Pin<Box<dyn Future<Output = Result<<Block as Block>::Hash, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
}

The SelectChain trait defines the strategy upon which the head is chosen if multiple forks are present for an opaque definition of “best” in the specific chain build.

The Strategy can be customized for the two use cases of authoring new blocks upon the best chain or which fork to finalize. Unless implemented differently by default finalization methods fall back to use authoring, so as a minimum _authoring-functions must be implemented.

Any particular user must make explicit, however, whether they intend to finalize or author through the using the right function call, as these might differ in some implementations.

Non-deterministically finalizing chains may only use the _authoring functions.

Required Methods

fn leaves<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<<Block as Block>::Hash>, Error>> + 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<<Block as Block>::Header, Error>> + 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.

Provided Methods

fn finality_target<'life0, 'async_trait>( &'life0 self, base_hash: <Block as Block>::Hash, _maybe_max_number: Option<<<Block as Block>::Header as Header>::Number> ) -> Pin<Box<dyn Future<Output = Result<<Block as Block>::Hash, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

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

Object Safety

This trait is not object safe.

Implementors

impl<B> SelectChain<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>> for SelectRelayChain<B>

where B: Backend<Block> + 'static,

impl<B, Block> SelectChain<Block> for LongestChain<B, Block>

where B: Backend<Block>, Block: Block,