Struct Trace 

pub struct Trace {

    pub from: Option<Address>,
    pub to: Option<Address>,
    pub call_type: Option<String>,
    pub gas: Option<Quantity>,
    pub input: Option<Data>,
    pub init: Option<Data>,
    pub value: Option<Quantity>,
    pub author: Option<Address>,
    pub reward_type: Option<String>,
    pub block_hash: Option<Hash>,
    pub block_number: Option<u64>,
    pub address: Option<Address>,
    pub code: Option<Data>,
    pub gas_used: Option<Quantity>,
    pub output: Option<Data>,
    pub subtraces: Option<u64>,
    pub trace_address: Option<Vec<u64>>,
    pub transaction_hash: Option<Hash>,
    pub transaction_position: Option<u64>,
    pub kind: Option<String>,
    pub error: Option<String>,
}

Trace object

Fields

from: Option<Address>

The address of the sender who initiated the transaction.

to: Option<Address>

The address of the recipient of the transaction if it was a transaction to an address. For contract creation transactions, this field is None.

call_type: Option<String>

The type of trace, call or delegatecall, two ways to invoke a function in a smart contract.

call creates a new environment for the function to work in, so changes made in that function won’t affect the environment where the function was called.

delegatecall doesn’t create a new environment. Instead, it runs the function within the environment of the caller, so changes made in that function will affect the caller’s environment.

gas: Option<Quantity>

The units of gas included in the transaction by the sender.

input: Option<Data>

The optional input data sent with the transaction, usually used to interact with smart contracts.

init: Option<Data>

The init code.

value: Option<Quantity>

The value of the native token transferred along with the transaction, in Wei.

author: Option<Address>

The address of the receiver for reward transaction.

reward_type: Option<String>

Kind of reward. Block reward or Uncle reward.

block_hash: Option<Hash>

The hash of the block in which the transaction was included.

block_number: Option<u64>

The number of the block in which the transaction was included.

address: Option<Address>

Destroyed address.

code: Option<Data>

Contract code.

gas_used: Option<Quantity>

The total used gas by the call, encoded as hexadecimal.

output: Option<Data>

The return value of the call, encoded as a hexadecimal string.

subtraces: Option<u64>

The number of sub-traces created during execution. When a transaction is executed on the EVM, it may trigger additional sub-executions, such as when a smart contract calls another smart contract or when an external account is accessed.

trace_address: Option<Vec<u64>>

An array that indicates the position of the transaction in the trace.

transaction_hash: Option<Hash>

The hash of the transaction.

transaction_position: Option<u64>

The index of the transaction in the block.

kind: Option<String>

The type of action taken by the transaction, call, create, reward and suicide.

call is the most common type of trace and occurs when a smart contract invokes another contract’s function.

create represents the creation of a new smart contract. This type of trace occurs when a smart contract is deployed to the blockchain.

error: Option<String>

A string that indicates whether the transaction was successful or not.

None if successful, Reverted if not.

Trait Implementations

impl Clone for Trace

fn clone(&self) -> Trace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Trace

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

Formats the value using the given formatter.

impl Default for Trace

fn default() -> Trace

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Trace

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromArrow for Trace

fn from_arrow_bin_array<B: List<Item = [u8]> + 'static, U: List<Item = str> + 'static>( batch: &ArrowBatch, ) -> Vec<Self>

Converts to the Vector type from the ArrowBatch type. B is the type of binary array used to downcast since we use both binary views and binary arrays

fn from_arrow(batch: &ArrowBatch) -> Vec<Self>

Default implementation that uses the binary array type. IPC is written with regular binary arrays. Named ‘from_arrow’ for backwards compatibility.

fn from_arrow_bin_view_array(batch: &ArrowBatch) -> Vec<Self>

An additional method that uses the binary view array type. This is to be able to reuse the trait server side where Binary Views are used instead.

impl PartialEq for Trace

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Trace

impl StructuralPartialEq for Trace