Struct Block 

pub struct Block<T, H = Header> {
    pub header: H,
    pub body: BlockBody<T, H>,
}

Ethereum full block.

Withdrawals can be optionally included at the end of the RLP encoded message.

Taken from reth-primitives

See p2p block encoding reference: https://github.com/ethereum/devp2p/blob/master/caps/eth.md#block-encoding-and-validity

Fields

header: H

Block header.

body: BlockBody<T, H>

Block body.

Implementations

impl<T: Decodable, H: Decodable> Block<T, H>

pub fn decode_sealed(buf: &mut &[u8]) -> Result<Sealed<Self>>

Decodes the block from RLP, computing the header hash directly from the RLP bytes.

This is more efficient than decoding the block and then sealing it, as the header hash is computed from the raw RLP bytes without re-encoding.

impl<T, H> Block<T, H>

pub const fn new(header: H, body: BlockBody<T, H>) -> Self

Creates a new block with the given header and body.

pub fn uncle(header: H) -> Self

Creates a new empty uncle block.

pub fn into_header(self) -> H

Consumes the block and returns the header.

pub fn into_body(self) -> BlockBody<T, H>

Consumes the block and returns the body.

pub fn map_header<U>(self, f: impl FnMut(H) -> U) -> Block<T, U>

Converts the block’s header type by applying a function to it.

pub fn try_map_header<U, E>( self, f: impl FnMut(H) -> Result<U, E>, ) -> Result<Block<T, U>, E>

Converts the block’s header type by applying a fallible function to it.

pub fn convert_transactions<U>(self) -> Block<U, H>

where U: From<T>,

Converts the block’s transaction type to the given alternative that is From<T>

pub fn try_convert_transactions<U>(self) -> Result<Block<U, H>, U::Error>

where U: TryFrom<T>,

Converts the block’s transaction to the given alternative that is TryFrom<T>

Returns the block with the new transaction type if all conversions were successful.

pub fn map_transactions<U>(self, f: impl FnMut(T) -> U) -> Block<U, H>

Converts the block’s transaction type by applying a function to each transaction.

Returns the block with the new transaction type.

pub fn try_map_transactions<U, E>( self, f: impl FnMut(T) -> Result<U, E>, ) -> Result<Block<U, H>, E>

Converts the block’s transaction type by applying a fallible function to each transaction.

Returns the block with the new transaction type if all transactions were successfully.

pub fn into_with_encoded2718(self) -> Block<WithEncoded<T>, H>

where T: Encodable2718,

Converts the transactions in the block’s body to WithEncoded<T> by encoding them via Encodable2718

pub fn with_header(self, header: H) -> Self

Replaces the header of the block.

Note: This method only replaces the main block header. If you need to transform the ommer headers as well, use map_header instead.

pub fn rlp_encoded_from_parts(header: &H, body: &BlockBody<T, H>) -> Vec<u8>

where H: Encodable, T: Encodable,

Encodes the Block given header and block body.

Returns the rlp encoded block.

This is equivalent to block.encode.

pub fn rlp_encode_from_parts( header: &H, body: &BlockBody<T, H>, out: &mut dyn BufMut, )

where H: Encodable, T: Encodable,

Encodes the Block given header and block body

This is equivalent to block.encode.

pub fn rlp_length_for(header: &H, body: &BlockBody<T, H>) -> usize

where H: Encodable, T: Encodable,

Returns the RLP encoded length of the block’s header and body.

impl<T: Encodable2718> Block<T, Header>

pub fn from_transactions( header: Header, transactions: impl IntoIterator<Item = T>, ) -> Self

Creates a new block from a header and an iterator of transactions.

Computes and sets the transactions_root on the header automatically. ommers_hash is set to EMPTY_OMMER_ROOT_HASH.

Trait Implementations

impl<'a, T, H> Arbitrary<'a> for Block<T, H>

where T: Arbitrary<'a>, H: Arbitrary<'a>,

Available on crate features arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T, H> BorshDeserialize for Block<T, H>

where T: BorshDeserialize, H: BorshDeserialize,

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<T, H> BorshSerialize for Block<T, H>

where T: BorshSerialize, H: BorshSerialize,

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<T: Clone, H: Clone> Clone for Block<T, H>

fn clone(&self) -> Block<T, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, H: Debug> Debug for Block<T, H>

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

Formats the value using the given formatter.

impl<T: Decodable, H: Decodable> Decodable for Block<T, H>

fn decode(b: &mut &[u8]) -> Result<Self>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl<T, H> Default for Block<T, H>

where H: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, H> Deref for Block<T, H>

type Target = H

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, T, H> Deserialize<'de> for Block<T, H>

where T: Deserialize<'de>, H: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Encodable, H: Encodable> Encodable for Block<T, H>

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

impl<T: Eq, H: Eq> Eq for Block<T, H>

impl<T, H> EthBlock for Block<T, H>

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

Returns reference to withdrawals in the block if present

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

fn from(block: Block<T, H>) -> Self

Converts to this type from the input type.

impl<T: InMemorySize, H: InMemorySize> InMemorySize for Block<T, H>

fn size(&self) -> usize

Returns a heuristic for the in-memory size of a struct.

impl<T: PartialEq, H: PartialEq> PartialEq for Block<T, H>

fn eq(&self, other: &Block<T, H>) -> 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<T, H> Serialize for Block<T, H>

where T: Serialize, H: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, H> StructuralPartialEq for Block<T, H>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.