Struct Transaction 

pub struct Transaction {

    pub block_hash: Option<Hash>,
    pub block_number: Option<BlockNumber>,
    pub from: Option<Address>,
    pub gas: Option<Quantity>,
    pub gas_price: Option<Quantity>,
    pub hash: Option<Hash>,
    pub input: Option<Data>,
    pub nonce: Option<Quantity>,
    pub to: Option<Address>,
    pub transaction_index: Option<TransactionIndex>,
    pub value: Option<Quantity>,
    pub v: Option<Quantity>,
    pub r: Option<Quantity>,
    pub s: Option<Quantity>,
    pub y_parity: Option<Quantity>,
    pub max_priority_fee_per_gas: Option<Quantity>,
    pub max_fee_per_gas: Option<Quantity>,
    pub chain_id: Option<Quantity>,
    pub access_list: Option<Vec<AccessList>>,
    pub authorization_list: Option<Vec<Authorization>>,
    pub max_fee_per_blob_gas: Option<Quantity>,
    pub blob_versioned_hashes: Option<Vec<Hash>>,
    pub cumulative_gas_used: Option<Quantity>,
    pub effective_gas_price: Option<Quantity>,
    pub gas_used: Option<Quantity>,
    pub contract_address: Option<Address>,
    pub logs_bloom: Option<BloomFilter>,
    pub kind: Option<TransactionType>,
    pub root: Option<Hash>,
    pub status: Option<TransactionStatus>,
    pub l1_fee: Option<Quantity>,
    pub l1_gas_price: Option<Quantity>,
    pub l1_gas_used: Option<Quantity>,
    pub l1_fee_scalar: Option<f64>,
    pub gas_used_for_l1: Option<Quantity>,
}

Transaction object

Fields

block_hash: Option<Hash>

The Keccak 256-bit hash of the block

block_number: Option<BlockNumber>

A scalar value equal to the number of ancestor blocks. The genesis block has a number of zero; formally Hi.

from: Option<Address>

The 160-bit address of the message call’s sender

gas: Option<Quantity>

A scalar value equal to the maximum amount of gas that should be used in executing this transaction. This is paid up-front, before any computation is done and may not be increased later; formally Tg.

gas_price: Option<Quantity>

A scalar value equal to the number of Wei to be paid per unit of gas for all computation costs incurred as a result of the execution of this transaction; formally Tp.

hash: Option<Hash>

A transaction hash is a keccak hash of an RLP encoded signed transaction.

input: Option<Data>

Input has two uses depending if transaction is Create or Call (if to field is None or Some). pub init: An unlimited size byte array specifying the EVM-code for the account initialisation procedure CREATE, data: An unlimited size byte array specifying the input data of the message call, formally Td.

nonce: Option<Quantity>

A scalar value equal to the number of transactions sent by the sender; formally Tn.

to: Option<Address>

The 160-bit address of the message call’s recipient or, for a contract creation transaction, ∅, used here to denote the only member of B0 ; formally Tt.

transaction_index: Option<TransactionIndex>

Index of the transaction in the block

value: Option<Quantity>

A scalar value equal to the number of Wei to be transferred to the message call’s recipient or, in the case of contract creation, as an endowment to the newly created account; formally Tv.

v: Option<Quantity>

Replay protection value based on chain_id. See EIP-155 for more info.

r: Option<Quantity>

The R field of the signature; the point on the curve.

s: Option<Quantity>

The S field of the signature; the point on the curve.

y_parity: Option<Quantity>

yParity: Signature Y parity; formally Ty

max_priority_fee_per_gas: Option<Quantity>

Max Priority fee that transaction is paying

As ethereum circulation is around 120mil eth as of 2022 that is around 120000000000000000000000000 wei we are safe to use u128 as its max number is: 340282366920938463463374607431768211455

This is also known as GasTipCap

max_fee_per_gas: Option<Quantity>

A scalar value equal to the maximum amount of gas that should be used in executing this transaction. This is paid up-front, before any computation is done and may not be increased later; formally Tg.

As ethereum circulation is around 120mil eth as of 2022 that is around 120000000000000000000000000 wei we are safe to use u128 as its max number is: 340282366920938463463374607431768211455

This is also known as GasFeeCap

chain_id: Option<Quantity>

Added as EIP-pub 155: Simple replay attack protection

access_list: Option<Vec<AccessList>>

The accessList specifies a list of addresses and storage keys; these addresses and storage keys are added into the accessed_addresses and accessed_storage_keys global sets (introduced in EIP-2929). A gas cost is charged, though at a discount relative to the cost of accessing outside the list.

authorization_list: Option<Vec<Authorization>>

The authorization_list specifies a list of authorizations for the transaction (introduced in EIP-7702)

max_fee_per_blob_gas: Option<Quantity>

Max fee per data gas

aka BlobFeeCap or blobGasFeeCap

blob_versioned_hashes: Option<Vec<Hash>>

It contains a vector of fixed size hash(32 bytes)

cumulative_gas_used: Option<Quantity>

The total amount of gas used in the block until this transaction was executed.

effective_gas_price: Option<Quantity>

The sum of the base fee and tip paid per unit of gas.

gas_used: Option<Quantity>

Gas used by transaction

contract_address: Option<Address>

Address of created contract if transaction was a contract creation

logs_bloom: Option<BloomFilter>

Bloom filter for logs produced by this transaction

kind: Option<TransactionType>

Transaction type. For ethereum: Legacy, Eip2930, Eip1559, Eip4844

root: Option<Hash>

The Keccak 256-bit hash of the root node of the trie structure populated with each transaction in the transactions list portion of the block; formally Ht.

status: Option<TransactionStatus>

If transaction is executed successfully.

This is the statusCode

l1_fee: Option<Quantity>

The fee associated with a transaction on the Layer 1, it is calculated as l1GasPrice multiplied by l1GasUsed

l1_gas_price: Option<Quantity>

The gas price for transactions on the Layer 1

l1_gas_used: Option<Quantity>

The amount of gas consumed by a transaction on the Layer 1

l1_fee_scalar: Option<f64>

A multiplier applied to the actual gas usage on Layer 1 to calculate the dynamic costs. If set to 1, it has no impact on the L1 gas usage

gas_used_for_l1: Option<Quantity>

Amount of gas spent on L1 calldata in units of L2 gas.

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl Default for Transaction

fn default() -> Transaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Transaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromArrow for Transaction

fn from_arrow_bin_array<B: List<Item = [u8]> + 'static, U>( 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 Transaction

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Transaction