Enum reth::core::rpc::types::BlockTransactions

pub enum BlockTransactions<T = Transaction> {
    Full(Vec<T>),
    Hashes(Vec<FixedBytes<32>>),
    Uncle,
}

Block Transactions depending on the boolean attribute of eth_getBlockBy*, or if used by eth_getUncle*

Variants

Full(Vec<T>)

Full transactions

Hashes(Vec<FixedBytes<32>>)

Only hashes

Uncle

Special case for uncle response.

Implementations

impl<T> BlockTransactions<T>

pub const fn is_hashes(&self) -> bool

Check if the enum variant is used for hashes.

pub fn as_hashes(&self) -> Option<&[FixedBytes<32>]>

Fallibly cast to a slice of hashes.

pub const fn is_full(&self) -> bool

Returns true if the enum variant is used for full transactions.

pub fn as_transactions(&self) -> Option<&[T]>

Fallibly cast to a slice of transactions.

Returns None if the enum variant is not Full.

pub const fn is_uncle(&self) -> bool

Returns true if the enum variant is used for an uncle response.

pub fn txns(&self) -> impl Iterator<Item = &T>

Returns an iterator over the transactions (if any). This will be empty if the block is an uncle or if the transaction list contains only hashes.

pub fn into_transactions(self) -> IntoIter<T>

Returns an iterator over the transactions (if any). This will be empty if the block is not full.

pub const fn uncle() -> BlockTransactions<T>

Returns an instance of BlockTransactions with the Uncle special case.

pub fn len(&self) -> usize

Returns the number of transactions.

pub fn is_empty(&self) -> bool

Whether the block has no transactions.

impl BlockTransactions

pub fn convert_to_hashes(&mut self)

Converts self into Hashes.

pub fn into_hashes(self) -> BlockTransactions

Converts self into Hashes.

pub fn iter(&self) -> BlockTransactionHashes<'_, Transaction>

👎Deprecated: use hashes instead

Returns an iterator over the transaction hashes.

pub fn hashes(&self) -> BlockTransactionHashes<'_, Transaction>

Returns an iterator over references to the transaction hashes.

pub fn hashes_mut(&mut self) -> BlockTransactionHashesMut<'_>

Returns an iterator over mutable references to the transaction hashes.

Trait Implementations

impl<T> Clone for BlockTransactions<T>

where T: Clone,

fn clone(&self) -> BlockTransactions<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BlockTransactions<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for BlockTransactions<T>

fn default() -> BlockTransactions<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for BlockTransactions<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Vec<FixedBytes<32>>> for BlockTransactions

fn from(hashes: Vec<FixedBytes<32>>) -> BlockTransactions

Converts to this type from the input type.

impl<T> From<Vec<T>> for BlockTransactions<T>

fn from(transactions: Vec<T>) -> BlockTransactions<T>

Converts to this type from the input type.

impl<T> PartialEq for BlockTransactions<T>

where T: PartialEq,

fn eq(&self, other: &BlockTransactions<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Serialize for BlockTransactions<T>

where T: Serialize,

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<T> Eq for BlockTransactions<T>

where T: Eq,

impl<T> StructuralPartialEq for BlockTransactions<T>

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: 32 bytes

Size for each variant:

• Full: 24 bytes
• Hashes: 24 bytes
• Uncle: 0 bytes