Struct substreams_ethereum_core::pb::eth::v2::Block

pub struct Block {
    pub ver: i32,
    pub hash: Vec<u8>,
    pub number: u64,
    pub size: u64,
    pub header: Option<BlockHeader>,
    pub uncles: Vec<BlockHeader>,
    pub transaction_traces: Vec<TransactionTrace>,
    pub balance_changes: Vec<BalanceChange>,
    pub code_changes: Vec<CodeChange>,
}

Fields

ver: i32

hash: Vec<u8>

number: u64

size: u64

header: Option<BlockHeader>

uncles: Vec<BlockHeader>

Uncles represents block produced with a valid solution but were not actually choosen as the canonical block for the given height so they are mostly “forked” blocks.

If the Block has been produced using the Proof of Stake consensus algorithm, this field will actually be always empty.

transaction_traces: Vec<TransactionTrace>

balance_changes: Vec<BalanceChange>

code_changes: Vec<CodeChange>

Implementations

impl Block

pub fn transactions(&self) -> impl Iterator<Item = &TransactionTrace>

Iterates over succesful transactions.

pub fn receipts(&self) -> impl Iterator<Item = ReceiptView<'_>>

Iterates over transaction receipts of successful transactions.

pub fn logs(&self) -> impl Iterator<Item = LogView<'_>>

Iterates over logs in receipts of succesful transactions.

pub fn calls(&self) -> impl Iterator<Item = CallView<'_>>

Iterates over calls of succesful transactions.

pub fn events<'a, E: Event>(
    &'a self,
    addresses: &'a [&[u8]]
) -> impl Iterator<Item = (E, LogView<'_>)>

A convenience for handlers that process a single type of event. Returns an iterator over pairs of (event, log).

If you need to process multiple event types in a single handler, try something like:

for log in block.logs() {
    if !addresses.contains(&log.address()) {
       continue;
    }

    if let Some(event) = E1::match_and_decode(log) {
        // Process events of type E1
    } else if let Some(event) = E2::match_and_decode(log) {
        // Process events of type E2
    }
}

pub fn timestamp_seconds(&self) -> u64

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl Default for Block

fn default() -> Self

Returns the “default value” for a type.

impl Message for Block

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>where
    B: BufMut,
    Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8, Global> where
    Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>where
    B: BufMut,
    Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8, Global> where
    Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError>where
    B: Buf,
    Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>where
    B: Buf,
    Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>where
    B: Buf,
    Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>where
    B: Buf,
    Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<Block> for Block

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