Struct substreams_ethereum::pb::eth::v2::Call

pub struct Call {

    pub index: u32,
    pub parent_index: u32,
    pub depth: u32,
    pub call_type: i32,
    pub caller: Vec<u8>,
    pub address: Vec<u8>,
    pub value: Option<BigInt>,
    pub gas_limit: u64,
    pub gas_consumed: u64,
    pub return_data: Vec<u8>,
    pub input: Vec<u8>,
    pub executed_code: bool,
    pub suicide: bool,
    pub keccak_preimages: HashMap<String, String>,
    pub storage_changes: Vec<StorageChange>,
    pub balance_changes: Vec<BalanceChange>,
    pub nonce_changes: Vec<NonceChange>,
    pub logs: Vec<Log>,
    pub code_changes: Vec<CodeChange>,
    pub gas_changes: Vec<GasChange>,
    pub status_failed: bool,
    pub status_reverted: bool,
    pub failure_reason: String,
    pub state_reverted: bool,
    pub begin_ordinal: u64,
    pub end_ordinal: u64,
    pub account_creations: Vec<AccountCreation>,
}

Fields

index: u32

parent_index: u32

depth: u32

call_type: i32

caller: Vec<u8>

address: Vec<u8>

value: Option<BigInt>

gas_limit: u64

gas_consumed: u64

return_data: Vec<u8>

input: Vec<u8>

executed_code: bool

suicide: bool

keccak_preimages: HashMap<String, String>

hex representation of the hash -> preimage

storage_changes: Vec<StorageChange>

balance_changes: Vec<BalanceChange>

nonce_changes: Vec<NonceChange>

logs: Vec<Log>

code_changes: Vec<CodeChange>

gas_changes: Vec<GasChange>

status_failed: bool

In Ethereum, a call can be either:

• Successfull, execution passes without any problem encountered
• Failed, execution failed, and remaining gas should be consumed
• Reverted, execution failed, but only gas consumed so far is billed, remaining gas is refunded

When a call is either failed or reverted, the status_failed field below is set to true. If the status is reverted, then both status_failed and status_reverted are going to be set to true.

status_reverted: bool

failure_reason: String

Populated when a call either failed or reverted, so when status_failed == true, see above for details about those flags.

state_reverted: bool

This field represents wheter or not the state changes performed by this call were correctly recorded by the blockchain.

On Ethereum, a transaction can record state changes even if some of its inner nested calls failed. This is problematic however since a call will invalidate all its state changes as well as all state changes performed by its child call. This means that even if a call has a status of SUCCESS, the chain might have reverted all the state changes it performed.

   Trx 1
    Call #1 <Failed>
      Call #2 <Execution Success>
      Call #3 <Execution Success>
      |--- Failure here
    Call #4

In the transaction above, while Call #2 and Call #3 would have the status EXECUTED.

If you check all calls and check only state_reverted flag, you might be missing some balance changes and nonce changes. This is because when a full transaction fails in ethereum (e.g. calls.all(x.state_reverted == true)), there is still the transaction fee that are recorded to the chain.

Refer to [TransactionTrace#status] field for more details about the handling you must perform.

begin_ordinal: u64

The block’s global ordinal when the call started executing, refer to [Block] documentation for further information about ordinals and total ordering.

end_ordinal: u64

The block’s global ordinal when the call finished executing, refer to [Block] documentation for further information about ordinals and total ordering.

account_creations: Vec<AccountCreation>

Implementations

impl Call

pub fn call_type(&self) -> CallType

Returns the enum value of call_type, or the default if the field is set to an invalid enum value.

pub fn set_call_type(&mut self, value: CallType)

Sets call_type to the provided enum value.

Trait Implementations

impl AsRef<Call> for Call

fn as_ref(&self) -> &Call

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Call> for CallView<'_>

fn as_ref(&self) -> &Call

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Call

fn clone(&self) -> Call

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Call

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

Formats the value using the given formatter.

impl Default for Call

fn default() -> Call

Returns the “default value” for a type.

impl Message for Call

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>

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>

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 for Call

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