Enum BlockTransactions 

pub enum BlockTransactions<T> {
    Full(Vec<T>),
    Hashes(Vec<B256>),
    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<B256>)

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<&[B256]>

Fallibly cast to a slice of hashes.

pub fn first_transaction(&self) -> Option<&T>

Returns the first transaction if the transactions are full.

pub const fn is_full(&self) -> bool

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

pub fn map<U>(self, f: impl FnMut(T) -> U) -> BlockTransactions<U>

Converts the transaction type by applying a function to each transaction.

Returns the block with the new transaction type.

pub fn try_map<U, E>( self, f: impl FnMut(T) -> Result<U, E>, ) -> Result<BlockTransactions<U>, E>

Converts the 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 as_transactions(&self) -> Option<&[T]>

Fallibly cast to a slice of transactions.

Returns None if the enum variant is not Full.

pub fn calculate_transactions_root(&self) -> Option<B256>

where T: Encodable2718,

Calculate the transaction root for the full transactions.

Returns None if this is not the BlockTransactions::Full variant

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 fn into_transactions_vec(self) -> Vec<T>

Consumes the type and returns the transactions as a vector.

Note: if this is an uncle or hashes, this will return an empty vector.

pub fn try_into_transactions(self) -> Result<Vec<T>, ValueError<Self>>

Attempts to unwrap the Self::Full variant.

Returns an error if the type is different variant.

pub const fn uncle() -> Self

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<T: TransactionResponse> BlockTransactions<T>

pub fn new_hashes(txs: impl IntoIterator<Item = impl AsRef<T>>) -> Self

Creates a new BlockTransactions::Hashes variant from the given iterator of transactions.

pub fn convert_to_hashes(&mut self)

Converts self into Hashes.

pub fn convert_to_hashes_if(&mut self, condition: bool)

Converts self into Hashes if the given condition is true.

pub fn into_hashes(self) -> Self

Converts self into Hashes.

pub fn into_hashes_if(self, condition: bool) -> Self

Converts self into Hashes if the given condition is true.

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

👎Deprecated: use hashes instead

Returns an iterator over the transaction hashes.

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

Returns an iterator over references to the transaction hashes.

Trait Implementations

impl<T: Clone> Clone for BlockTransactions<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BlockTransactions<T>

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

Formats the value using the given formatter.

impl<T> Default for BlockTransactions<T>

fn default() -> Self

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<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn from(hashes: Vec<B256>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for BlockTransactions<T>

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

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

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