Trait sp_consensus::SelectChain

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

    // Provided method
    fn finality_target<'life0, 'async_trait>(
        &'life0 self,
        base_hash: <Block as BlockT>::Hash,
        _maybe_max_number: Option<NumberFor<Block>>
    ) -> Pin<Box<dyn Future<Output = Result<<Block as BlockT>::Hash, Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: '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 BlockT>::Hash>, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: '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 BlockT>::Header, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: '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 BlockT>::Hash, _maybe_max_number: Option<NumberFor<Block>> ) -> Pin<Box<dyn Future<Output = Result<<Block as BlockT>::Hash, Error>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: '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.

Implementors