Trait BlockBody 

pub trait BlockBody:
    Send
    + Sync
    + Unpin
    + Clone
    + Default
    + Debug
    + PartialEq
    + Eq
    + Encodable
    + Decodable
    + InMemorySize
    + MaybeSerde
    + 'static {
    type Transaction: SignedTransaction;
    type OmmerHeader: BlockHeader;

    // Required methods
    fn transactions(&self) -> &[Self::Transaction];
    fn into_ethereum_body(
        self,
    ) -> BlockBody<Self::Transaction, Self::OmmerHeader>;
    fn into_transactions(self) -> Vec<Self::Transaction>;
    fn withdrawals(&self) -> Option<&Withdrawals>;
    fn ommers(&self) -> Option<&[Self::OmmerHeader]>;

    // Provided methods
    fn transactions_iter(&self) -> impl Iterator<Item = &Self::Transaction> { ... }
    fn transaction_by_hash(
        &self,
        hash: &FixedBytes<32>,
    ) -> Option<&Self::Transaction> { ... }
    fn contains_transaction(&self, hash: &FixedBytes<32>) -> bool { ... }
    fn clone_transactions(&self) -> Vec<Self::Transaction> { ... }
    fn transaction_hashes_iter(&self) -> impl Iterator<Item = &FixedBytes<32>> { ... }
    fn transaction_count(&self) -> usize { ... }
    fn contains_transaction_type(&self, tx_type: u8) -> bool { ... }
    fn calculate_tx_root(&self) -> FixedBytes<32> { ... }
    fn calculate_withdrawals_root(&self) -> Option<FixedBytes<32>> { ... }
    fn calculate_ommers_root(&self) -> Option<FixedBytes<32>> { ... }
    fn blob_gas_used(&self) -> u64 { ... }
    fn blob_versioned_hashes_iter(
        &self,
    ) -> impl Iterator<Item = &FixedBytes<32>> { ... }
    fn encoded_2718_transactions_iter(&self) -> impl Iterator<Item = Vec<u8>> { ... }
    fn encoded_2718_transactions(&self) -> Vec<Bytes> { ... }
    fn recover_signers(&self) -> Result<Vec<Address>, RecoveryError> { ... }
    fn try_recover_signers(&self) -> Result<Vec<Address>, RecoveryError> { ... }
    fn recover_signers_unchecked(&self) -> Result<Vec<Address>, RecoveryError> { ... }
    fn try_recover_signers_unchecked(
        &self,
    ) -> Result<Vec<Address>, RecoveryError> { ... }
    fn recover_transactions(
        &self,
    ) -> Result<Vec<Recovered<Self::Transaction>>, RecoveryError> { ... }
    fn recover_transactions_ref(
        &self,
    ) -> Result<impl Iterator<Item = Recovered<&Self::Transaction>>, RecoveryError> { ... }
    fn recover_transactions_unchecked_ref(
        &self,
    ) -> Result<impl Iterator<Item = Recovered<&Self::Transaction>>, RecoveryError> { ... }
}

Abstraction for block’s body.

This type is a container for everything that is included in a block except the header. For ethereum this includes transactions, ommers, and withdrawals.

Required Associated Types

type Transaction: SignedTransaction

Ordered list of signed transactions as committed in the block.

type OmmerHeader: BlockHeader

Ommer header type.

Required Methods

fn transactions(&self) -> &[Self::Transaction]

Returns reference to transactions in the block.

fn into_ethereum_body(self) -> BlockBody<Self::Transaction, Self::OmmerHeader>

A Convenience function to convert this type into the regular ethereum block body that consists of:

• Transactions
• Withdrawals
• Ommers

Note: This conversion can be incomplete. It is not expected that this Body is the same as [alloy_consensus::BlockBody] only that it can be converted into it which is useful for the eth_ RPC namespace (e.g. RPC block).

fn into_transactions(self) -> Vec<Self::Transaction>

Consume the block body and return a Vec of transactions.

fn withdrawals(&self) -> Option<&Withdrawals>

Returns block withdrawals if any.

fn ommers(&self) -> Option<&[Self::OmmerHeader]>

Returns block ommers if any.

Provided Methods

fn transactions_iter(&self) -> impl Iterator<Item = &Self::Transaction>

Returns an iterator over the transactions in the block.

fn transaction_by_hash( &self, hash: &FixedBytes<32>, ) -> Option<&Self::Transaction>

Returns the transaction with the matching hash.

This is a convenience function for transactions_iter().find()

fn contains_transaction(&self, hash: &FixedBytes<32>) -> bool

Returns true if the block body contains a transaction with the given hash.

This is a convenience function for transaction_by_hash().is_some()

fn clone_transactions(&self) -> Vec<Self::Transaction>

Clones the transactions in the block.

This is a convenience function for transactions().to_vec()

fn transaction_hashes_iter(&self) -> impl Iterator<Item = &FixedBytes<32>>

Returns an iterator over all transaction hashes in the block body.

fn transaction_count(&self) -> usize

Returns the number of the transactions in the block.

fn contains_transaction_type(&self, tx_type: u8) -> bool

Returns true if the block body contains a transaction of the given type.

fn calculate_tx_root(&self) -> FixedBytes<32>

Calculate the transaction root for the block body.

fn calculate_withdrawals_root(&self) -> Option<FixedBytes<32>>

Calculate the withdrawals root for the block body.

Returns Some(root) if withdrawals are present, otherwise None.

fn calculate_ommers_root(&self) -> Option<FixedBytes<32>>

Calculate the ommers root for the block body.

Returns Some(root) if ommers are present, otherwise None.

fn blob_gas_used(&self) -> u64

Calculates the total blob gas used by all EIP-4844 transactions in the block.

fn blob_versioned_hashes_iter(&self) -> impl Iterator<Item = &FixedBytes<32>>

Returns an iterator over all blob versioned hashes in the block body.

fn encoded_2718_transactions_iter(&self) -> impl Iterator<Item = Vec<u8>>

Returns an iterator over the encoded 2718 transactions.

This is also known as raw transactions.

See also Encodable2718.

fn encoded_2718_transactions(&self) -> Vec<Bytes>

Returns a vector of encoded 2718 transactions.

This is also known as raw transactions.

See also Encodable2718.

fn recover_signers(&self) -> Result<Vec<Address>, RecoveryError>

Recover signer addresses for all transactions in the block body.

fn try_recover_signers(&self) -> Result<Vec<Address>, RecoveryError>

Recover signer addresses for all transactions in the block body.

Returns an error if some transaction’s signature is invalid.

fn recover_signers_unchecked(&self) -> Result<Vec<Address>, RecoveryError>

Recover signer addresses for all transactions in the block body without ensuring that the signature has a low s value.

Returns RecoveryError, if some transaction’s signature is invalid.

fn try_recover_signers_unchecked(&self) -> Result<Vec<Address>, RecoveryError>

Recover signer addresses for all transactions in the block body without ensuring that the signature has a low s value.

Returns an error if some transaction’s signature is invalid.

fn recover_transactions( &self, ) -> Result<Vec<Recovered<Self::Transaction>>, RecoveryError>

Recovers signers for all transactions in the block body and returns a vector of Recovered.

fn recover_transactions_ref( &self, ) -> Result<impl Iterator<Item = Recovered<&Self::Transaction>>, RecoveryError>

Returns an iterator over Recovered<&Transaction> for all transactions in the block body.

This method recovers signers and returns an iterator without cloning transactions, making it more efficient than BlockBody::recover_transactions when owned values are not required.

Errors

Returns an error if any transaction’s signature is invalid.

fn recover_transactions_unchecked_ref( &self, ) -> Result<impl Iterator<Item = Recovered<&Self::Transaction>>, RecoveryError>

Returns an iterator over Recovered<&Transaction> for all transactions in the block body without ensuring that the signature has a low s value.

This method recovers signers and returns an iterator without cloning transactions, making it more efficient than recovering with owned transactions when owned values are not required.

Errors

Returns an error if any transaction’s signature is invalid.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T, H> BlockBody for BlockBody<T, H>

where T: SignedTransaction, H: BlockHeader,

type Transaction = T

type OmmerHeader = H

fn transactions(&self) -> &[<BlockBody<T, H> as BlockBody>::Transaction]

fn into_ethereum_body(self) -> BlockBody<T, H>

fn into_transactions(self) -> Vec<<BlockBody<T, H> as BlockBody>::Transaction>

fn withdrawals(&self) -> Option<&Withdrawals>

fn ommers(&self) -> Option<&[<BlockBody<T, H> as BlockBody>::OmmerHeader]>

Implementors