Struct substreams_ethereum_core::pb::eth::v2::TransactionTrace

pub struct TransactionTrace {

    pub to: Vec<u8>,
    pub nonce: u64,
    pub gas_price: Option<BigInt>,
    pub gas_limit: u64,
    pub value: Option<BigInt>,
    pub input: Vec<u8>,
    pub v: Vec<u8>,
    pub r: Vec<u8>,
    pub s: Vec<u8>,
    pub gas_used: u64,
    pub type: i32,
    pub access_list: Vec<AccessTuple>,
    pub max_fee_per_gas: Option<BigInt>,
    pub max_priority_fee_per_gas: Option<BigInt>,
    pub index: u32,
    pub hash: Vec<u8>,
    pub from: Vec<u8>,
    pub return_data: Vec<u8>,
    pub public_key: Vec<u8>,
    pub begin_ordinal: u64,
    pub end_ordinal: u64,
    pub status: i32,
    pub receipt: Option<TransactionReceipt>,
    pub calls: Vec<Call>,
}

Fields

to: Vec<u8>

consensus

nonce: u64

gas_price: Option<BigInt>

GasPrice represents the effective price that has been paid for each gas unit of this transaction. Over time, the Ethereum rules changes regarding GasPrice field here. Before London fork, the GasPrice was always set to the fixed gas price. After London fork, this value has different meaning depending on the transaction type (see Type field).

In cases where TransactionTrace.Type == TRX_TYPE_LEGACY || TRX_TYPE_ACCESS_LIST, then GasPrice has the same meaning as before the London fork.

In cases where TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE, then GasPrice is the effective gas price paid for the transaction which is equals to BlockHeader.BaseFeePerGas + TransactionTrace.

gas_limit: u64

GasLimit is the maximum of gas unit the sender of the transaction is willing to consume when perform the EVM execution of the whole transaction

value: Option<BigInt>

Value is the amount of Ether transferred as part of this transaction.

input: Vec<u8>

Input data the transaction will receive for execution of EVM.

v: Vec<u8>

V is the recovery ID value for the signature Y point.

r: Vec<u8>

R is the signature’s X point on the elliptic curve (32 bytes).

s: Vec<u8>

S is the signature’s Y point on the elliptic curve (32 bytes).

gas_used: u64

GasUsed is the total amount of gas unit used for the whole execution of the transaction.

type: i32

Type represents the Ethereum transaction type, available only since EIP-2718 & EIP-2930 activation which happened on Berlin fork. The value is always set even for transaction before Berlin fork because those before the fork are still legacy transactions.

access_list: Vec<AccessTuple>

AcccessList represents the storage access this transaction has agreed to do in which case those storage access cost less gas unit per access.

This will is populated only if TransactionTrace.Type == TRX_TYPE_ACCESS_LIST || TRX_TYPE_DYNAMIC_FEE which is possible only if Berlin (TRX_TYPE_ACCESS_LIST) nor London (TRX_TYPE_DYNAMIC_FEE) fork are active on the chain.

max_fee_per_gas: Option<BigInt>

MaxFeePerGas is the maximum fee per gas the user is willing to pay for the transaction gas used.

This will is populated only if TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE which is possible only if Londong fork is active on the chain.

max_priority_fee_per_gas: Option<BigInt>

MaxPriorityFeePerGas is priority fee per gas the user to pay in extra to the miner on top of the block’s base fee.

This will is populated only if TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE which is possible only if Londong fork is active on the chain.

index: u32

meta

hash: Vec<u8>

from: Vec<u8>

return_data: Vec<u8>

public_key: Vec<u8>

begin_ordinal: u64

end_ordinal: u64

status: i32

receipt: Option<TransactionReceipt>

calls: Vec<Call>

Implementations

impl TransactionTrace

pub fn type(&self) -> Type

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

pub fn set_type(&mut self, value: Type)

Sets type to the provided enum value.

pub fn status(&self) -> TransactionTraceStatus

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

pub fn set_status(&mut self, value: TransactionTraceStatus)

Sets status to the provided enum value.

impl TransactionTrace

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

pub fn receipt(&self) -> ReceiptView<'_>

Trait Implementations

impl Clone for TransactionTrace

fn clone(&self) -> TransactionTrace

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionTrace

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

Formats the value using the given formatter.

impl Default for TransactionTrace

fn default() -> Self

Returns the “default value” for a type.

impl Message for TransactionTrace

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

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