Enum BlockTransactions 

pub enum BlockTransactions<T> {
    Full(Vec<T>),
    Hashes(Vec<B256>),
    Uncle,
}

Representation of the transactions field in block JSON-RPC responses.

Full corresponds to a block requested with full transactions, Hashes to a block requested with transaction hashes, and Uncle to the omitted transaction field in uncle responses. Default is an empty Hashes value, not an empty Full value. With Serde, the representation is untagged and an empty JSON array deserializes as Full([]), so that ambiguous case does not preserve which request form produced it.

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.

The function is called only for Self::Full; hash and uncle representations pass through unchanged.

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.

The function is called only for Self::Full; hash and uncle representations pass through unchanged.

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,

Calculates a transaction root from the ordered EIP-2718 encodings of full transactions.

Returns None for other representations. This does not compare the result against a block header.

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.

Use Self::try_into_transactions when those representations should be treated as an error instead of an empty collection.

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.

Use Self::try_into_transactions to preserve the distinction between a full empty block and a non-full representation.

pub fn into_transactions_vec(self) -> Vec<T>

Consumes the type and returns the transactions as a vector.

Hash and uncle representations are collapsed to an empty vector. Use Self::try_into_transactions when that distinction matters.

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

Attempts to unwrap the Self::Full variant.

Returns an error retaining the original representation for hash and uncle variants.

pub const fn uncle() -> Self

Returns an instance of BlockTransactions with the Uncle special case.

pub const fn len(&self) -> usize

Returns the number of transactions.

pub const 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 full transactions to same-order hashes.

Existing hashes are unchanged. Self::Uncle is normalized to an empty hash list, losing the omitted-field representation.

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 full transactions to same-order hashes.

Existing hashes are unchanged. Self::Uncle is normalized to an empty hash list, losing the omitted-field representation.

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

Converts self into Hashes if the given condition is true.

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

Returns transaction hashes by value.

Stored hashes are copied, full transactions use TransactionResponse::tx_hash, and Self::Uncle yields an empty iterator.

pub fn into_hashes_vec(self) -> Vec<B256>

Consumes the type and returns the hashes as a vector.

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

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>,

Available on crate feature serde only.

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Eq> Eq for BlockTransactions<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T> Serialize for BlockTransactions<T>

where T: Serialize,

Available on crate feature serde only.

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq> 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