[][src]Struct sc_block_builder::BlockBuilder

pub struct BlockBuilder<'a, Block: BlockT, A: ProvideRuntimeApi<Block>, B> { /* fields omitted */ }

Utility for building new (valid) blocks from a stream of extrinsics.

Implementations

impl<'a, Block, A, B> BlockBuilder<'a, Block, A, B> where
    Block: BlockT,
    A: ProvideRuntimeApi<Block> + 'a,
    A::Api: BlockBuilderApi<Block, Error = Error> + ApiExt<Block, StateBackend = StateBackendFor<B, Block>>,
    B: Backend<Block>, 
[src]

pub fn new(
    api: &'a A,
    parent_hash: Block::Hash,
    parent_number: NumberFor<Block>,
    record_proof: RecordProof,
    inherent_digests: DigestFor<Block>,
    backend: &'a B
) -> Result<Self, ApiErrorFor<A, Block>>
[src]

Create a new instance of builder based on the given parent_hash and parent_number.

While proof recording is enabled, all accessed trie nodes are saved. These recorded trie nodes can be used by a third party to prove the output of this block builder without having access to the full storage.

pub fn push(
    &mut self,
    xt: <Block as BlockT>::Extrinsic
) -> Result<(), ApiErrorFor<A, Block>>
[src]

Push onto the block's list of extrinsics.

This will ensure the extrinsic can be validly executed (by executing it).

pub fn build(
    self
) -> Result<BuiltBlock<Block, StateBackendFor<B, Block>>, ApiErrorFor<A, Block>>
[src]

Consume the builder to build a valid Block containing all pushed extrinsics.

Returns the build Block, the changes to the storage and an optional StorageProof supplied by self.api, combined as BuiltBlock. The storage proof will be Some(_) when proof recording was enabled.

pub fn create_inherents(
    &mut self,
    inherent_data: InherentData
) -> Result<Vec<Block::Extrinsic>, ApiErrorFor<A, Block>>
[src]

Create the inherents for the block.

Returns the inherents created by the runtime or an error if something failed.

Auto Trait Implementations

impl<'a, Block, A, B> RefUnwindSafe for BlockBuilder<'a, Block, A, B> where
    B: RefUnwindSafe,
    <A as ProvideRuntimeApi<Block>>::Api: RefUnwindSafe,
    <Block as Block>::Extrinsic: RefUnwindSafe,
    <Block as Block>::Hash: RefUnwindSafe,
    <<Block as Block>::Header as Header>::Number: RefUnwindSafe

impl<'a, Block, A, B> Send for BlockBuilder<'a, Block, A, B> where
    B: Sync,
    <A as ProvideRuntimeApi<Block>>::Api: Send,
    <Block as Block>::Extrinsic: Send,
    <Block as Block>::Hash: Send,
    <<Block as Block>::Header as Header>::Number: Send

impl<'a, Block, A, B> Sync for BlockBuilder<'a, Block, A, B> where
    B: Sync,
    <A as ProvideRuntimeApi<Block>>::Api: Sync,
    <Block as Block>::Extrinsic: Sync,
    <Block as Block>::Hash: Sync,
    <<Block as Block>::Header as Header>::Number: Sync

impl<'a, Block, A, B> Unpin for BlockBuilder<'a, Block, A, B> where
    <A as ProvideRuntimeApi<Block>>::Api: Unpin,
    <Block as Block>::Extrinsic: Unpin,
    <Block as Block>::Hash: Unpin,
    <<Block as Block>::Header as Header>::Number: Unpin

impl<'a, Block, A, B> UnwindSafe for BlockBuilder<'a, Block, A, B> where
    B: RefUnwindSafe,
    <A as ProvideRuntimeApi<Block>>::Api: UnwindSafe,
    <Block as Block>::Extrinsic: UnwindSafe,
    <Block as Block>::Hash: UnwindSafe,
    <<Block as Block>::Header as Header>::Number: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> CheckedConversion for T[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, Outer> IsWrappedBy<Outer> for T where
    Outer: AsRef<T> + AsMut<T> + From<T>,
    T: From<Outer>, 
[src]

fn from_ref(outer: &Outer) -> &T[src]

Get a reference to the inner from the outer.

fn from_mut(outer: &mut Outer) -> &mut T[src]

Get a mutable reference to the inner from the outer.

impl<T> MaybeRefUnwindSafe for T where
    T: RefUnwindSafe
[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> SaturatedConversion for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<S, T> UncheckedInto<T> for S where
    T: UncheckedFrom<S>, 
[src]

impl<T, S> UniqueSaturatedInto<T> for S where
    S: TryInto<T>,
    T: Bounded
[src]

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,