Struct ReceiptWithBloom

pub struct ReceiptWithBloom<T = Receipt> {
    pub receipt: T,
    pub logs_bloom: Bloom,
}

Receipt with calculated bloom filter.

This convenience type allows us to lazily calculate the bloom filter for a receipt, similar to Sealed.

Fields

receipt: T

The receipt.

logs_bloom: Bloom

The bloom filter.

Implementations

impl<R> ReceiptWithBloom<R>

pub fn map_receipt<U>(self, f: impl FnOnce(R) -> U) -> ReceiptWithBloom<U>

Converts the receipt type by applying the given closure to it.

Returns the type with the new receipt type.

pub const fn new(receipt: R, logs_bloom: Bloom) -> ReceiptWithBloom<R>

Create new ReceiptWithBloom

pub fn into_components(self) -> (R, Bloom)

Consume the structure, returning the receipt and the bloom filter

pub const fn bloom_ref(&self) -> &Bloom

Returns a reference to the bloom.

impl<L> ReceiptWithBloom<Receipt<L>>

pub fn map_logs<U>(self, f: impl FnMut(L) -> U) -> ReceiptWithBloom<Receipt<U>>

Converts the receipt’s log type by applying a function to each log.

Returns the receipt with the new log type.

pub fn into_primitives_receipt(self) -> ReceiptWithBloom

where L: Into<Log>,

Converts a ReceiptWithBloom with a custom log type into a ReceiptWithBloom with the primitives Log type by converting the logs.

This is useful if log types that embed the primitives log type, e.g. the log receipt rpc type.

Trait Implementations

impl<T> Clone for ReceiptWithBloom<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ReceiptWithBloom<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<R> Decodable for ReceiptWithBloom<R>

where R: RlpDecodableReceipt,

fn decode(buf: &mut &[u8]) -> Result<ReceiptWithBloom<R>, Error>

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

impl<T> Default for ReceiptWithBloom<T>

where T: Default,

fn default() -> ReceiptWithBloom<T>

Returns the “default value” for a type.

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

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> Encodable for ReceiptWithBloom<R>

where R: RlpEncodableReceipt,

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<R> Encodable2718 for ReceiptWithBloom<R>

where R: Eip2718EncodableReceipt + Send + Sync,

fn encode_2718_len(&self) -> usize

The length of the 2718 encoded envelope. This is the length of the type flag + the length of the inner encoding.

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

Encode the transaction according to EIP-2718 rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn type_flag(&self) -> Option<u8>

Return the type flag (if any).

fn encoded_2718(&self) -> Vec<u8>

Encode the transaction according to [EIP-2718] rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

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

Compute the hash as committed to in the MPT trie. This hash is used ONLY by the Ethereum merkle-patricia trie and associated proofs. Do not call this method unless you are building a full or light client.

fn seal(self) -> Sealed<Self>

Seal the encodable, by encoding and hashing it.

fn network_len(&self) -> usize

The length of the 2718 encoded envelope in network format. This is the length of the header + the length of the type flag and inner encoding.

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

Encode in the network format. The network format is used ONLY by the Ethereum p2p protocol. Do not call this method unless you are building a p2p protocol client.

impl<R> From<R> for ReceiptWithBloom<R>

where R: TxReceipt,

fn from(receipt: R) -> ReceiptWithBloom<R>

Converts to this type from the input type.

impl<T> From<ReceiptWithBloom<Receipt<T>>> for Receipt<T>

fn from(receipt_with_bloom: ReceiptWithBloom<Receipt<T>>) -> Receipt<T>

Consume the structure, returning only the receipt

impl<T> PartialEq for ReceiptWithBloom<T>

where T: PartialEq,

fn eq(&self, other: &ReceiptWithBloom<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 ReceiptWithBloom<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<R> TxReceipt for ReceiptWithBloom<R>

where R: TxReceipt,

type Log = <R as TxReceipt>::Log

The associated log type.

fn status_or_post_state(&self) -> Eip658Value

Returns the status or post state of the transaction.

fn status(&self) -> bool

Returns true if the transaction was successful OR if the transaction is pre-EIP-658. Results for transactions before EIP-658 are not reliable.

fn bloom(&self) -> Bloom

Returns the bloom filter for the logs in the receipt. This operation may be expensive.

fn bloom_cheap(&self) -> Option<Bloom>

Returns the bloom filter for the logs in the receipt, if it is cheap to compute.

fn cumulative_gas_used(&self) -> u64

Returns the cumulative gas used in the block after this transaction was executed.

fn logs(&self) -> &[<ReceiptWithBloom<R> as TxReceipt>::Log]

Returns the logs emitted by this transaction.

fn with_bloom_ref(&self) -> ReceiptWithBloom<&Self>

Returns ReceiptWithBloom with the computed bloom filter Self::bloom and a reference to the receipt.

fn into_with_bloom(self) -> ReceiptWithBloom<Self>

Consumes the type and converts it into ReceiptWithBloom with the computed bloom filter Self::bloom and the receipt.

impl<R> Typed2718 for ReceiptWithBloom<R>

where R: Typed2718,

fn ty(&self) -> u8

Returns the EIP-2718 type flag.

fn is_type(&self, ty: u8) -> bool

Returns true if the type matches the given type.

fn is_legacy(&self) -> bool

Returns true if the type is a legacy transaction.

fn is_eip2930(&self) -> bool

Returns true if the type is an EIP-2930 transaction.

fn is_eip1559(&self) -> bool

Returns true if the type is an EIP-1559 transaction.

fn is_eip4844(&self) -> bool

Returns true if the type is an EIP-4844 transaction.

fn is_eip7702(&self) -> bool

Returns true if the type is an EIP-7702 transaction.

impl<T> Eq for ReceiptWithBloom<T>

where T: Eq,

impl<T> StructuralPartialEq for ReceiptWithBloom<T>