Struct UnvalidatedLegacyTransaction 

pub struct UnvalidatedLegacyTransaction<'a> {
    pub nonce: Nonce,
    pub gas_price: Wei,
    pub gas_limit: Gas,
    pub to: LegacyTransactionTo,
    pub value: Wei,
    pub input: &'a [u8],
    pub v: [u8; 32],
    pub r: [u8; 32],
    pub s: [u8; 32],
}

Borrowed legacy transaction decoded only into field domains.

This type is intentionally unvalidated: no sender recovery, EIP-155 chain binding, intrinsic-gas check, nonce-state check, fork check, or signature validity is performed.

Fields

nonce: Nonce

Account nonce.

gas_price: Wei

Gas price in wei.

gas_limit: Gas

Gas limit.

to: LegacyTransactionTo

Call or contract-creation target.

value: Wei

Transferred value in wei.

input: &'a [u8]

Borrowed transaction input data.

v: [u8; 32]

Raw canonical U256 signature recovery value.

This is not checked for EIP-155, chain, or fork validity. Use Self::eip155_chain_id instead of subtracting from this value directly.

r: [u8; 32]

Raw canonical U256 signature r value.

This is not checked for secp256k1 scalar validity.

s: [u8; 32]

Raw canonical U256 signature s value.

This is not checked against the EIP-2 low-s bound or secp256k1 scalar validity.

Implementations

impl UnvalidatedLegacyTransaction<'_>

pub fn eip155_chain_id(&self) -> Option<ChainId>

Returns the nonzero EIP-155 chain ID encoded by v, if it fits this crate’s signed chain-domain width.

Returns None for pre-EIP-155 v values such as 27 and 28, and for oversized v values that cannot fit in u64. It also returns None when v maps to reserved ChainId(0), matching ChainId::try_from_signed_canonical_be_slice. This helper is intentionally syntactic: it does not prove that the chain ID is configured, active, or valid for any fork.

Trait Implementations

impl<'a> Clone for UnvalidatedLegacyTransaction<'a>

fn clone(&self) -> UnvalidatedLegacyTransaction<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for UnvalidatedLegacyTransaction<'a>

impl<'a> Debug for UnvalidatedLegacyTransaction<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for UnvalidatedLegacyTransaction<'a>

impl<'a> PartialEq for UnvalidatedLegacyTransaction<'a>

fn eq(&self, other: &UnvalidatedLegacyTransaction<'a>) -> 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<'a> StructuralPartialEq for UnvalidatedLegacyTransaction<'a>