Struct Chain

pub struct Chain<N = EthPrimitives>
where
    N: NodePrimitives,
{ /* private fields */ }

A chain of blocks and their final state.

The chain contains the state of accounts after execution of its blocks, changesets for those blocks (and their transactions), as well as the blocks themselves.

Used inside the BlockchainTree.

Warning

A chain of blocks should not be empty.

Implementations

impl<N> Chain<N>

where N: NodePrimitives,

pub fn new( blocks: impl IntoIterator<Item = SealedBlockWithSenders>, execution_outcome: ExecutionOutcome<<N as NodePrimitives>::Receipt>, trie_updates: Option<TrieUpdates>, ) -> Chain<N>

Create new Chain from blocks and state.

Warning

A chain of blocks should not be empty.

pub fn from_block( block: SealedBlockWithSenders, execution_outcome: ExecutionOutcome<<N as NodePrimitives>::Receipt>, trie_updates: Option<TrieUpdates>, ) -> Chain<N>

Create new Chain from a single block and its state.

pub const fn blocks(&self) -> &BTreeMap<u64, SealedBlockWithSenders>

Get the blocks in this chain.

pub fn into_blocks(self) -> BTreeMap<u64, SealedBlockWithSenders>

Consumes the type and only returns the blocks in this chain.

pub fn headers(&self) -> impl Iterator<Item = SealedHeader>

Returns an iterator over all headers in the block with increasing block numbers.

pub const fn trie_updates(&self) -> Option<&TrieUpdates>

Get cached trie updates for this chain.

pub fn clear_trie_updates(&mut self)

Remove cached trie updates for this chain.

pub const fn execution_outcome( &self, ) -> &ExecutionOutcome<<N as NodePrimitives>::Receipt>

Get execution outcome of this chain

pub fn execution_outcome_mut( &mut self, ) -> &mut ExecutionOutcome<<N as NodePrimitives>::Receipt>

Get mutable execution outcome of this chain

pub fn prepend_state(&mut self, state: BundleState)

Prepends the given state to the current state.

pub fn is_empty(&self) -> bool

Return true if chain is empty and has no blocks.

pub fn block_number(&self, block_hash: FixedBytes<32>) -> Option<u64>

Return block number of the block hash.

pub fn block(&self, block_hash: FixedBytes<32>) -> Option<&SealedBlock>

Returns the block with matching hash.

pub fn block_with_senders( &self, block_hash: FixedBytes<32>, ) -> Option<&SealedBlockWithSenders>

Returns the block with matching hash.

pub fn execution_outcome_at_block( &self, block_number: u64, ) -> Option<ExecutionOutcome<<N as NodePrimitives>::Receipt>>

Return execution outcome at the block_number or None if block is not known

pub fn into_inner( self, ) -> (ChainBlocks<'static>, ExecutionOutcome<<N as NodePrimitives>::Receipt>, Option<TrieUpdates>)

Destructure the chain into its inner components:

1. The blocks contained in the chain.
2. The execution outcome representing the final state.
3. The optional trie updates.

pub const fn inner( &self, ) -> (ChainBlocks<'_>, &ExecutionOutcome<<N as NodePrimitives>::Receipt>)

Destructure the chain into its inner components:

1. A reference to the blocks contained in the chain.
2. A reference to the execution outcome representing the final state.

pub fn block_receipts_iter( &self, ) -> impl Iterator<Item = &Vec<Option<<N as NodePrimitives>::Receipt>>>

Returns an iterator over all the receipts of the blocks in the chain.

pub fn blocks_iter(&self) -> impl Iterator<Item = &SealedBlockWithSenders>

Returns an iterator over all blocks in the chain with increasing block number.

pub fn blocks_and_receipts( &self, ) -> impl Iterator<Item = (&SealedBlockWithSenders, &Vec<Option<<N as NodePrimitives>::Receipt>>)>

Returns an iterator over all blocks and their receipts in the chain.

pub fn fork_block(&self) -> NumHash

Get the block at which this chain forked.

pub fn first(&self) -> &SealedBlockWithSenders

Get the first block in this chain.

Panics

If chain doesn’t have any blocks.

pub fn tip(&self) -> &SealedBlockWithSenders

Get the tip of the chain.

Panics

If chain doesn’t have any blocks.

pub fn len(&self) -> usize

Returns length of the chain.

pub fn range(&self) -> RangeInclusive<u64>

Returns the range of block numbers in the chain.

Panics

If chain doesn’t have any blocks.

pub fn receipts_by_block_hash( &self, block_hash: FixedBytes<32>, ) -> Option<Vec<&<N as NodePrimitives>::Receipt>>

Get all receipts for the given block.

pub fn receipts_with_attachment( &self, ) -> Vec<BlockReceipts<<N as NodePrimitives>::Receipt>>

Get all receipts with attachment.

Attachment includes block number, block hash, transaction hash and transaction index.

pub fn append_block( &mut self, block: SealedBlockWithSenders, execution_outcome: ExecutionOutcome<<N as NodePrimitives>::Receipt>, )

Append a single block with state to the chain. This method assumes that blocks attachment to the chain has already been validated.

pub fn append_chain( &mut self, other: Chain<N>, ) -> Result<(), BlockExecutionError>

Merge two chains by appending the given chain into the current one.

The state of accounts for this chain is set to the state of the newest chain.

pub fn split(self, split_at: ChainSplitTarget) -> ChainSplit<N>

Split this chain at the given block.

The given block will be the last block in the first returned chain.

If the given block is not found, ChainSplit::NoSplitPending is returned. Split chain at the number or hash, block with given number will be included at first chain. If any chain is empty (Does not have blocks) None will be returned.

Note

The plain state is only found in the second chain, making it impossible to perform any state reverts on the first chain.

The second chain only contains the changes that were reverted on the first chain; however, it retains the up to date state as if the chains were one, i.e. the second chain is an extension of the first.

Panics

If chain doesn’t have any blocks.

Trait Implementations

impl<N> Clone for Chain<N>

where N: Clone + NodePrimitives, <N as NodePrimitives>::Receipt: Clone,

fn clone(&self) -> Chain<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Debug for Chain<N>

where N: Debug + NodePrimitives, <N as NodePrimitives>::Receipt: Debug,

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

Formats the value using the given formatter.

impl<N> Default for Chain<N>

where N: Default + NodePrimitives, <N as NodePrimitives>::Receipt: Default,

fn default() -> Chain<N>

Returns the “default value” for a type.

impl<'de, N> Deserialize<'de> for Chain<N>

where N: NodePrimitives,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Chain<N>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> DeserializeAs<'de, Chain> for Chain<'de>

fn deserialize_as<D>( deserializer: D, ) -> Result<Chain, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a Chain> for Chain<'a>

fn from(value: &'a Chain) -> Chain<'a>

Converts to this type from the input type.

impl<'a> From<Chain<'a>> for Chain

fn from(value: Chain<'a>) -> Chain

Converts to this type from the input type.

impl<N> PartialEq for Chain<N>

where N: PartialEq + NodePrimitives, <N as NodePrimitives>::Receipt: PartialEq,

fn eq(&self, other: &Chain<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N> Serialize for Chain<N>

where N: NodePrimitives,

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 SerializeAs<Chain> for Chain<'_>

fn serialize_as<S>( source: &Chain, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<N> Eq for Chain<N>

where N: Eq + NodePrimitives, <N as NodePrimitives>::Receipt: Eq,

impl<N> StructuralPartialEq for Chain<N>

where N: NodePrimitives,

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 344 bytes