Trait polkadot_service::BlockImport

pub trait BlockImport<B>where
    B: Block,{
    type Error: 'static + Error + Send;
    type Transaction: 'static + Send;

    fn check_block<'life0, 'async_trait>(
        &'life0 mut self,
        block: BlockCheckParams<B>
    ) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn import_block<'life0, 'async_trait>(
        &'life0 mut self,
        block: BlockImportParams<B, Self::Transaction>,
        cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
    ) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
}

Block import trait.

Required Associated Types

type Error: 'static + Error + Send

The error type.

type Transaction: 'static + Send

The transaction type used by the backend.

Required Methods

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<B>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Check block preconditions.

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<B, Self::Transaction>,
    cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Import a block.

Cached data can be accessed through the blockchain cache.

Trait Implementations

impl<B, Transaction> BlockImport<B> for Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global>where
    B: Block,
    Transaction: 'static + Send,

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<B>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global> as BlockImport<B>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global>: 'async_trait,

Check block preconditions.

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<B, Transaction>,
    cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global> as BlockImport<B>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global>: 'async_trait,

Import a block.

Cached data can be accessed through the blockchain cache.

type Error = Error

The error type.

type Transaction = Transaction

The transaction type used by the backend.

Implementations on Foreign Types

impl<BE, Block, Client, SC> BlockImport<Block> for GrandpaBlockImport<BE, Block, Client, SC>where
    Block: Block,
    <<Block as Block>::Header as Header>::Number: BlockNumberOps,
    BE: Backend<Block>,
    Client: ClientForGrandpa<Block, BE>,
    <Client as ProvideRuntimeApi<Block>>::Api: GrandpaApi<Block>,
    &'a Client: for<'a> BlockImport<Block, Error = Error, Transaction = <<<Client as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction>,
    <<<Client as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction: 'static,
    SC: Send,

type Error = Error

type Transaction = <<<Client as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<Block, <GrandpaBlockImport<BE, Block, Client, SC> as BlockImport<Block>>::Transaction>,
    new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <GrandpaBlockImport<BE, Block, Client, SC> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    GrandpaBlockImport<BE, Block, Client, SC>: 'async_trait,

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<Block>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <GrandpaBlockImport<BE, Block, Client, SC> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    GrandpaBlockImport<BE, Block, Client, SC>: 'async_trait,

impl<B, Transaction> BlockImport<B> for Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global>where
    B: Block,
    Transaction: 'static + Send,

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<B>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global> as BlockImport<B>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global>: 'async_trait,

Check block preconditions.

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<B, Transaction>,
    cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global> as BlockImport<B>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Box<dyn BlockImport<B, Error = Error, Transaction = Transaction> + Send + Sync + 'static, Global>: 'async_trait,

Import a block.

Cached data can be accessed through the blockchain cache.

type Error = Error

type Transaction = Transaction

impl<B, T, E, Transaction> BlockImport<B> for Arc<T>where
    B: Block,
    E: 'static + Error + Send,
    &'r T: for<'r> BlockImport<B, Error = E, Transaction = Transaction>,
    T: Send + Sync,
    Transaction: 'static + Send,

type Error = E

type Transaction = Transaction

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<B>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Arc<T> as BlockImport<B>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Arc<T>: 'async_trait,

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<B, Transaction>,
    cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Arc<T> as BlockImport<B>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Arc<T>: 'async_trait,

impl<Block, Client, Inner> BlockImport<Block> for BabeBlockImport<Block, Client, Inner>where
    Block: Block,
    Inner: BlockImport<Block, Transaction = <<<Client as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction> + Send + Sync,
    <Inner as BlockImport<Block>>::Error: Into<Error>,
    Client: HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + AuxStore + ProvideRuntimeApi<Block> + Send + Sync,
    <Client as ProvideRuntimeApi<Block>>::Api: BabeApi<Block> + ApiExt<Block>,

type Error = Error

type Transaction = <<<Client as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<Block, <BabeBlockImport<Block, Client, Inner> as BlockImport<Block>>::Transaction>,
    new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <BabeBlockImport<Block, Client, Inner> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    BabeBlockImport<Block, Client, Inner>: 'async_trait,

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<Block>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <BabeBlockImport<Block, Client, Inner> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    BabeBlockImport<Block, Client, Inner>: 'async_trait,

impl<Block, BE, Runtime, I> BlockImport<Block> for BeefyBlockImport<Block, BE, Runtime, I>where
    Block: Block,
    BE: Backend<Block>,
    I: BlockImport<Block, Error = Error, Transaction = <<<Runtime as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction> + Send + Sync,
    Runtime: ProvideRuntimeApi<Block> + Send + Sync,
    <Runtime as ProvideRuntimeApi<Block>>::Api: BeefyApi<Block>,

type Error = Error

type Transaction = <<<Runtime as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction

fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockImportParams<Block, <BeefyBlockImport<Block, BE, Runtime, I> as BlockImport<Block>>::Transaction>,
    new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <BeefyBlockImport<Block, BE, Runtime, I> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    BeefyBlockImport<Block, BE, Runtime, I>: 'async_trait,

fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<Block>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <BeefyBlockImport<Block, BE, Runtime, I> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    BeefyBlockImport<Block, BE, Runtime, I>: 'async_trait,

Implementors