Struct alloy_consensus::transaction::legacy::TxLegacy

pub struct TxLegacy {
    pub chain_id: Option<ChainId>,
    pub nonce: u64,
    pub gas_price: u128,
    pub gas_limit: u128,
    pub to: TxKind,
    pub value: U256,
    pub input: Bytes,
}

Legacy transaction.

Fields

chain_id: Option<ChainId>

Added as EIP-155: Simple replay attack protection

nonce: u64

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

gas_price: u128

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.

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

gas_limit: u128

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.

to: TxKind

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.

value: U256

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.

input: Bytes

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.

Implementations

impl TxLegacy

pub const TX_TYPE: isize = 0isize

The EIP-2718 transaction type.

pub fn size(&self) -> usize

Calculates a heuristic for the in-memory size of the TxLegacy transaction.

pub(crate) fn encode_fields(&self, out: &mut dyn BufMut)

Encodes only the transaction’s fields into the desired buffer, without a RLP header or eip155 fields.

pub fn encode_with_signature_fields( &self, signature: &Signature, out: &mut dyn BufMut, )

Encodes the transaction from RLP bytes, including the signature. This does not encode a tx type byte or string header.

This does encode a list header and include a signature.

pub(crate) fn encoded_len_with_signature(&self, signature: &Signature) -> usize

Returns what the encoded length should be, if the transaction were RLP encoded with the given signature.

pub(crate) fn encode_eip155_signing_fields(&self, out: &mut dyn BufMut)

Encodes EIP-155 arguments into the desired buffer. Only encodes values for legacy transactions.

pub(crate) fn eip155_fields_len(&self) -> usize

Outputs the length of EIP-155 fields. Only outputs a non-zero value for EIP-155 legacy transactions.

pub(crate) fn decode_fields(data: &mut &[u8]) -> Result<Self>

Decode the RLP fields of the transaction, without decoding an RLP header.

Trait Implementations

impl Clone for TxLegacy

fn clone(&self) -> TxLegacy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TxLegacy

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

Formats the value using the given formatter.

impl Decodable for TxLegacy

fn decode(data: &mut &[u8]) -> Result<Self>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl Default for TxLegacy

fn default() -> TxLegacy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TxLegacy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for TxLegacy

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

Encodes the type into the out buffer.

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

impl From<TxLegacy> for TypedTransaction

fn from(tx: TxLegacy) -> Self

Converts to this type from the input type.

impl Hash for TxLegacy

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TxLegacy

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TxLegacy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SignableTransaction<Signature<Signature<Secp256k1>>> for TxLegacy

fn use_eip155(&self) -> bool

True if the transaction uses EIP-155 signatures.

fn set_chain_id(&mut self, chain_id: ChainId)

Sets chain_id.

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

RLP-encodes the transaction for signing.

fn payload_len_for_signature(&self) -> usize

Outputs the length of the signature RLP encoding for the transaction.

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

Convert to a signed transaction by adding a signature and computing the hash.

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

Set chain_id if it is not already set. Checks that the provided chain_id matches the existing chain_id if it is already set, returning false if they do not match.

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

RLP-encodes the transaction for signing it. Used to calculate signature_hash.

fn signature_hash(&self) -> B256

Calculate the signing hash for the transaction.

impl Transaction for TxLegacy

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

Get chain_id.

fn nonce(&self) -> u64

Get nonce.

fn gas_limit(&self) -> u128

Get gas_limit.

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

Get gas_price.

fn to(&self) -> TxKind

Get to.

fn value(&self) -> U256

Get value.

fn input(&self) -> &[u8]

Get data.

impl Eq for TxLegacy

impl StructuralPartialEq for TxLegacy

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 144 bytes