Enum Transaction

Source

pub enum Transaction {
    Legacy(TxLegacy),
    Eip2930(TxEip2930),
    Eip1559(TxEip1559),
    Eip4844(TxEip4844),
    Eip7702(TxEip7702),
}

Expand description

A raw transaction.

Transaction types were introduced in EIP-2718.

Variants§

§

Legacy(TxLegacy)

Legacy transaction (type 0x0).

Traditional Ethereum transactions, containing parameters nonce, gasPrice, gasLimit, to, value, data, v, r, and s.

These transactions do not utilize access lists nor do they incorporate EIP-1559 fee market changes.

§

Eip2930(TxEip2930)

Transaction with an [AccessList] (EIP-2930), type 0x1.

The accessList specifies an array of addresses and storage keys that the transaction plans to access, enabling gas savings on cross-contract calls by pre-declaring the accessed contract and storage slots.

§

Eip1559(TxEip1559)

A transaction with a priority fee (EIP-1559), type 0x2.

Unlike traditional transactions, EIP-1559 transactions use an in-protocol, dynamically changing base fee per gas, adjusted at each block to manage network congestion.

maxPriorityFeePerGas, specifying the maximum fee above the base fee the sender is willing to pay
maxFeePerGas, setting the maximum total fee the sender is willing to pay.

The base fee is burned, while the priority fee is paid to the miner who includes the transaction, incentivizing miners to include transactions with higher priority fees per gas.

§

Eip4844(TxEip4844)

Shard Blob Transactions (EIP-4844), type 0x3.

Shard Blob Transactions introduce a new transaction type called a blob-carrying transaction to reduce gas costs. These transactions are similar to regular Ethereum transactions but include additional data called a blob.

Blobs are larger (~125 kB) and cheaper than the current calldata, providing an immutable and read-only memory for storing transaction data.

EIP-4844, also known as proto-danksharding, implements the framework and logic of danksharding, introducing new transaction formats and verification rules.

§

Eip7702(TxEip7702)

EOA Set Code Transactions (EIP-7702), type 0x4.

EOA Set Code Transactions give the ability to temporarily set contract code for an EOA for a single transaction. This allows for temporarily adding smart contract functionality to the EOA.

Enum TransactionCopy item path

Variants§

Legacy(TxLegacy)

Eip2930(TxEip2930)

Eip1559(TxEip1559)

Eip4844(TxEip4844)

Eip7702(TxEip7702)

Implementations§

impl Transaction

pub const fn tx_type(&self) -> TxType

Trait Implementations§

impl<'arbitrary> Arbitrary<'arbitrary> for Transaction

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

fn size_hint(depth: usize) -> (usize, Option<usize>)

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

impl AsRef<Transaction> for TransactionSigned

fn as_ref(&self) -> &Transaction

impl Clone for Transaction

fn clone(&self) -> Transaction

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

impl Compact for Transaction

fn to_compact<B>(&self, buf: &mut B) -> usizewhere B: BufMut + AsMut<[u8]>,

fn from_compact(buf: &[u8], identifier: usize) -> (Self, &[u8])

fn specialized_to_compact<B>(&self, buf: &mut B) -> usizewhere B: BufMut + AsMut<[u8]>,

fn specialized_from_compact(buf: &[u8], len: usize) -> (Self, &[u8])

impl Debug for Transaction

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

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl From<TxEip1559> for Transaction

fn from(value: TxEip1559) -> Self

impl From<TxEip2930> for Transaction

fn from(value: TxEip2930) -> Self

impl From<TxEip4844> for Transaction

fn from(value: TxEip4844) -> Self

impl From<TxEip7702> for Transaction

fn from(value: TxEip7702) -> Self

impl From<TxLegacy> for Transaction

fn from(value: TxLegacy) -> Self

impl Hash for Transaction

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl InMemorySize for Transaction

fn size(&self) -> usize

impl PartialEq for Transaction

fn eq(&self, other: &Transaction) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Serialize for Transaction

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

impl SignableTransaction<PrimitiveSignature> for Transaction

fn set_chain_id(&mut self, chain_id: ChainId)

fn encode_for_signing(&self, out: &mut dyn BufMut)

fn payload_len_for_signature(&self) -> usize

fn into_signed(self, signature: Signature) -> Signed<Self>

fn set_chain_id_checked(&mut self, chain_id: u64) -> bool

fn encoded_for_signing(&self) -> Vec<u8> ⓘ

fn signature_hash(&self) -> FixedBytes<32>

impl Transaction for Transaction

fn chain_id(&self) -> Option<ChainId>

fn nonce(&self) -> u64

fn gas_limit(&self) -> u64

fn gas_price(&self) -> Option<u128>

fn max_fee_per_gas(&self) -> u128

fn max_priority_fee_per_gas(&self) -> Option<u128>

fn max_fee_per_blob_gas(&self) -> Option<u128>

fn priority_fee_or_price(&self) -> u128

fn effective_gas_price(&self, base_fee: Option<u64>) -> u128

fn is_dynamic_fee(&self) -> bool

fn kind(&self) -> TxKind

fn access_list(&self) -> Option<&AccessList>

fn authorization_list(&self) -> Option<&[SignedAuthorization]>

fn is_create(&self) -> bool

fn value(&self) -> U256

fn input(&self) -> &Bytes

fn blob_versioned_hashes(&self) -> Option<&[B256]>

fn effective_tip_per_gas(&self, base_fee: u64) -> Option<u128>

fn to(&self) -> Option<Address>

fn blob_gas_used(&self) -> Option<u64>

impl Typed2718 for Transaction

Enum Transaction

fn to_compact<B>(&self, buf: &mut B) -> usize
where B: BufMut + AsMut<[u8]>,

fn specialized_to_compact<B>(&self, buf: &mut B) -> usize
where B: BufMut + AsMut<[u8]>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> DynClone for T
where T: Clone,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,