Enum Transaction 

pub enum Transaction {
    LegacyTransaction(LegacyTransaction),
    EIP2930Transaction(EIP2930Transaction),
    EIP1559Transaction(EIP1559Transaction),
    EIP4844Transaction(EIP4844Transaction),
    EIP7702Transaction(EIP7702Transaction),
    PrivilegedL2Transaction(PrivilegedL2Transaction),
    FeeTokenTransaction(FeeTokenTransaction),
}

Variants

LegacyTransaction(LegacyTransaction)

EIP2930Transaction(EIP2930Transaction)

EIP1559Transaction(EIP1559Transaction)

EIP4844Transaction(EIP4844Transaction)

EIP7702Transaction(EIP7702Transaction)

PrivilegedL2Transaction(PrivilegedL2Transaction)

FeeTokenTransaction(FeeTokenTransaction)

Implementations

impl Transaction

pub fn decode_canonical(bytes: &[u8]) -> Result<Self, RLPDecodeError>

Decodes a single transaction in canonical format Based on [EIP-2718] Transactions can be encoded in the following formats: A) TransactionType || Transaction (Where Transaction type is an 8-bit number between 0 and 0x7f, and Transaction is an rlp encoded transaction of type TransactionType) B) LegacyTransaction (An rlp encoded LegacyTransaction)

pub fn encode_canonical(&self, buf: &mut dyn BufMut)

Encodes a transaction in canonical format Based on [EIP-2718] Transactions can be encoded in the following formats: A) TransactionType || Transaction (Where Transaction type is an 8-bit number between 0 and 0x7f, and Transaction is an rlp encoded transaction of type TransactionType) B) LegacyTransaction (An rlp encoded LegacyTransaction)

pub fn encode_canonical_to_vec(&self) -> Vec<u8>

Encodes a transaction in canonical format into a newly created buffer Based on [EIP-2718] Transactions can be encoded in the following formats: A) TransactionType || Transaction (Where Transaction type is an 8-bit number between 0 and 0x7f, and Transaction is an rlp encoded transaction of type TransactionType) B) LegacyTransaction (An rlp encoded LegacyTransaction)

pub fn encode_canonical_len(&self) -> usize

Canonical-encoded length without allocating a buffer. Counts the 1-byte type prefix for typed txs (EIP-2718) plus the inner RLP payload length. Use this when only the size is needed (e.g. admission-time size caps) to avoid encode_canonical_to_vec().len().

impl Transaction

pub fn tx_type(&self) -> TxType

pub fn effective_gas_price(&self, base_fee_per_gas: Option<u64>) -> Option<U256>

pub fn cost_without_base_fee(&self) -> Option<U256>

pub fn fee_token(&self) -> Option<Address>

impl Transaction

pub fn sender(&self, crypto: &dyn Crypto) -> Result<Address, CryptoError>

pub fn gas_limit(&self) -> u64

pub fn gas_price(&self) -> U256

pub fn to(&self) -> TxKind

pub fn value(&self) -> U256

pub fn max_priority_fee(&self) -> Option<u64>

pub fn chain_id(&self) -> Option<u64>

pub fn access_list(&self) -> &AccessList

pub fn authorization_list(&self) -> Option<&AuthorizationList>

pub fn nonce(&self) -> u64

pub fn data(&self) -> &Bytes

pub fn blob_versioned_hashes(&self) -> Vec<H256>

pub fn max_fee_per_blob_gas(&self) -> Option<U256>

pub fn is_contract_creation(&self) -> bool

pub fn is_privileged(&self) -> bool

pub fn max_fee_per_gas(&self) -> Option<u64>

pub fn hash(&self) -> H256

pub fn gas_tip_cap(&self) -> U256

pub fn gas_fee_cap(&self) -> U256

pub fn effective_gas_tip(&self, base_fee: Option<u64>) -> Option<U256>

Returns the effective tip per gas for this transaction. Returns None if the transaction’s fee cap is below the base fee (i.e. the transaction cannot pay for its inclusion).

pub fn protected(&self) -> bool

Returns whether the transaction is replay-protected. For more information check out EIP-155

Trait Implementations

impl Archive for Transaction

where LegacyTransaction: Archive, EIP2930Transaction: Archive, EIP1559Transaction: Archive, EIP4844Transaction: Archive, EIP7702Transaction: Archive, PrivilegedL2Transaction: Archive, FeeTokenTransaction: Archive,

type Archived = ArchivedTransaction

The archived representation of this type.

type Resolver = TransactionResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

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<'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<__D: Fallible + ?Sized> Deserialize<Transaction, __D> for Archived<Transaction>

where LegacyTransaction: Archive, <LegacyTransaction as Archive>::Archived: Deserialize<LegacyTransaction, __D>, EIP2930Transaction: Archive, <EIP2930Transaction as Archive>::Archived: Deserialize<EIP2930Transaction, __D>, EIP1559Transaction: Archive, <EIP1559Transaction as Archive>::Archived: Deserialize<EIP1559Transaction, __D>, EIP4844Transaction: Archive, <EIP4844Transaction as Archive>::Archived: Deserialize<EIP4844Transaction, __D>, EIP7702Transaction: Archive, <EIP7702Transaction as Archive>::Archived: Deserialize<EIP7702Transaction, __D>, PrivilegedL2Transaction: Archive, <PrivilegedL2Transaction as Archive>::Archived: Deserialize<PrivilegedL2Transaction, __D>, FeeTokenTransaction: Archive, <FeeTokenTransaction as Archive>::Archived: Deserialize<FeeTokenTransaction, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Transaction, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for Transaction

impl From<Transaction> for GenericTransaction

fn from(value: Transaction) -> Self

Converts to this type from the input type.

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 PayloadRLPEncode for Transaction

fn encode_payload(&self, buf: &mut dyn BufMut)

fn encode_payload_to_vec(&self) -> Vec<u8>

impl RLPDecode for Transaction

fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError>

Transactions can be encoded in the following formats: A) Legacy transactions: rlp(LegacyTransaction) B) Non legacy transactions: rlp(Bytes) where Bytes represents the canonical encoding for the transaction as a bytes object. Checkout Transaction::decode_canonical for more information

fn decode(rlp: &[u8]) -> Result<Self, RLPDecodeError>

impl RLPEncode for Transaction

fn encode(&self, buf: &mut dyn BufMut)

Transactions can be encoded in the following formats: A) Legacy transactions: rlp(LegacyTransaction) B) Non legacy transactions: rlp(Bytes) where Bytes represents the canonical encoding for the transaction as a bytes object. Checkout Transaction::encode_canonical for more information

fn length(&self) -> usize

fn encode_to_vec(&self) -> Vec<u8>

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<__S: Fallible + ?Sized> Serialize<__S> for Transaction

where LegacyTransaction: Serialize<__S>, EIP2930Transaction: Serialize<__S>, EIP1559Transaction: Serialize<__S>, EIP4844Transaction: Serialize<__S>, EIP7702Transaction: Serialize<__S>, PrivilegedL2Transaction: Serialize<__S>, FeeTokenTransaction: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for Transaction

impl TryInto<Transaction> for P2PTransaction

type Error = String

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Transaction, Self::Error>

Performs the conversion.