Enum TypedTransaction

pub enum TypedTransaction {
    Legacy(TransactionRequest),
    Eip2930(Eip2930TransactionRequest),
    Eip1559(Eip1559TransactionRequest),
    DepositTransaction(DepositTransaction),
}

The TypedTransaction enum represents all Ethereum transaction types.

Its variants correspond to specific allowed transactions:

1. Legacy (pre-EIP2718) TransactionRequest
2. EIP2930 (state access lists) Eip2930TransactionRequest
3. EIP1559 Eip1559TransactionRequest

To support Kovan and other non-London-compatbile networks, please enable the legacy crate feature. This will disable the type flag in the serialized transaction, and cause contract calls and other common actions to default to using the legacy transaction type.

Variants

Legacy(TransactionRequest)

Eip2930(Eip2930TransactionRequest)

Eip1559(Eip1559TransactionRequest)

DepositTransaction(DepositTransaction)

Implementations

impl TypedTransaction

pub fn from(&self) -> Option<&H160>

pub fn set_from(&mut self, from: H160) -> &mut TypedTransaction

pub fn to(&self) -> Option<&NameOrAddress>

pub fn to_addr(&self) -> Option<&H160>

pub fn set_to<T>(&mut self, to: T) -> &mut TypedTransaction

where T: Into<NameOrAddress>,

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

pub fn set_nonce<T>(&mut self, nonce: T) -> &mut TypedTransaction

where T: Into<U256>,

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

pub fn set_value<T>(&mut self, value: T) -> &mut TypedTransaction

where T: Into<U256>,

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

pub fn gas_mut(&mut self) -> &mut Option<U256>

pub fn set_gas<T>(&mut self, gas: T) -> &mut TypedTransaction

where T: Into<U256>,

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

pub fn set_gas_price<T>(&mut self, gas_price: T) -> &mut TypedTransaction

where T: Into<U256>,

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

pub fn set_chain_id<T>(&mut self, chain_id: T) -> &mut TypedTransaction

where T: Into<U64>,

pub fn data(&self) -> Option<&Bytes>

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

pub fn set_access_list( &mut self, access_list: AccessList, ) -> &mut TypedTransaction

pub fn set_data(&mut self, data: Bytes) -> &mut TypedTransaction

pub fn rlp_signed(&self, signature: &Signature) -> Bytes

pub fn rlp(&self) -> Bytes

pub fn sighash(&self) -> H256

Hashes the transaction’s data. Does not double-RLP encode

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

Max cost of the transaction

pub fn hash(&self, signature: &Signature) -> H256

Hashes the transaction’s data with the included signature.

pub fn decode_signed( rlp: &Rlp<'_>, ) -> Result<(TypedTransaction, Signature), TypedTransactionError>

Decodes a signed TypedTransaction from a rlp encoded byte stream

impl TypedTransaction

pub fn as_legacy_ref(&self) -> Option<&TransactionRequest>

pub fn as_eip2930_ref(&self) -> Option<&Eip2930TransactionRequest>

pub fn as_eip1559_ref(&self) -> Option<&Eip1559TransactionRequest>

pub fn as_optimism_deposited_ref(&self) -> Option<&DepositTransaction>

pub fn as_legacy_mut(&mut self) -> Option<&mut TransactionRequest>

pub fn as_eip2930_mut(&mut self) -> Option<&mut Eip2930TransactionRequest>

pub fn as_eip1559_mut(&mut self) -> Option<&mut Eip1559TransactionRequest>

pub fn as_optimism_deposited_mut(&mut self) -> Option<&mut DepositTransaction>

Trait Implementations

impl Clone for TypedTransaction

fn clone(&self) -> TypedTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypedTransaction

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

Formats the value using the given formatter.

impl Decodable for TypedTransaction

Get a TypedTransaction directly from a rlp encoded byte stream

fn decode(rlp: &Rlp<'_>) -> Result<TypedTransaction, DecoderError>

Decode a value from RLP bytes

impl Default for TypedTransaction

fn default() -> TypedTransaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TypedTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Transaction> for TypedTransaction

fn from(tx: &Transaction) -> TypedTransaction

Converts to this type from the input type.

impl From<DepositTransaction> for TypedTransaction

fn from(src: DepositTransaction) -> TypedTransaction

Converts to this type from the input type.

impl From<Eip1559TransactionRequest> for TypedTransaction

fn from(src: Eip1559TransactionRequest) -> TypedTransaction

Converts to this type from the input type.

impl From<Eip2930TransactionRequest> for TypedTransaction

fn from(src: Eip2930TransactionRequest) -> TypedTransaction

Converts to this type from the input type.

impl From<TransactionRequest> for TypedTransaction

fn from(src: TransactionRequest) -> TypedTransaction

Converts to this type from the input type.

impl From<TypedTransaction> for Eip1559TransactionRequest

fn from(src: TypedTransaction) -> Eip1559TransactionRequest

Converts to this type from the input type.

impl From<TypedTransaction> for Eip2930TransactionRequest

fn from(src: TypedTransaction) -> Eip2930TransactionRequest

Converts to this type from the input type.

impl From<TypedTransaction> for TransactionRequest

fn from(src: TypedTransaction) -> TransactionRequest

Converts to this type from the input type.

impl PartialEq for TypedTransaction

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TypedTransaction

impl StructuralPartialEq for TypedTransaction