Struct MaybeImpersonatedTransaction

pub struct MaybeImpersonatedTransaction {
    pub transaction: TypedTransaction,
    pub impersonated_sender: Option<Address>,
}

A wrapper for TypedTransaction that allows impersonating accounts.

This is a helper that carries the impersonated sender so that the right hash TypedTransaction::impersonated_hash can be created.

Fields

transaction: TypedTransaction

impersonated_sender: Option<Address>

Implementations

impl MaybeImpersonatedTransaction

pub fn new(transaction: TypedTransaction) -> Self

Creates a new wrapper for the given transaction

pub fn impersonated( transaction: TypedTransaction, impersonated_sender: Address, ) -> Self

Creates a new impersonated transaction wrapper using the given sender

pub fn recover(&self) -> Result<Address, SignatureError>

Available on crate feature impersonated-tx only.

Recovers the Ethereum address which was used to sign the transaction.

Note: this is feature gated so it does not conflict with the Derefed TypedTransaction::recover function by default.

pub fn is_impersonated(&self) -> bool

Available on crate feature impersonated-tx only.

Returns whether the transaction is impersonated

Note: this is feature gated so it does not conflict with the Derefed TypedTransaction::hash function by default.

pub fn hash(&self) -> B256

Available on crate feature impersonated-tx only.

Returns the hash of the transaction

Note: this is feature gated so it does not conflict with the Derefed TypedTransaction::hash function by default.

Methods from Deref<Target = TypedTransaction>

pub fn is_dynamic_fee(&self) -> bool

Returns true if the transaction uses dynamic fees: EIP1559, EIP4844 or EIP7702

pub fn gas_price(&self) -> u128

pub fn gas_limit(&self) -> u64

pub fn value(&self) -> U256

pub fn data(&self) -> &Bytes

pub fn type(&self) -> Option<u8>

Returns the transaction type

pub fn max_cost(&self) -> u128

Max cost of the transaction It is the gas limit multiplied by the gas price, and if the transaction is EIP-4844, the result of (total blob gas cost * max fee per blob gas) is also added

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

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

pub fn essentials(&self) -> TransactionEssentials

Returns a helper type that contains commonly used values as fields

pub fn nonce(&self) -> u64

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

pub fn as_legacy(&self) -> Option<&Signed<TxLegacy>>

pub fn is_legacy(&self) -> bool

Returns true whether this tx is a legacy transaction

pub fn is_eip1559(&self) -> bool

Returns true whether this tx is a EIP1559 transaction

pub fn is_eip2930(&self) -> bool

Returns true whether this tx is a EIP2930 transaction

pub fn is_eip4844(&self) -> bool

Returns true whether this tx is a EIP4844 transaction

pub fn hash(&self) -> B256

Returns the hash of the transaction.

Note: If this transaction has the Impersonated signature then this returns a modified unique hash. This allows us to treat impersonated transactions as unique.

pub fn impersonated_hash(&self, sender: Address) -> B256

Available on crate feature impersonated-tx only.

Returns the hash if the transaction is impersonated (using a fake signature)

This appends the address before hashing it

pub fn recover(&self) -> Result<Address, SignatureError>

Recovers the Ethereum address which was used to sign the transaction.

pub fn kind(&self) -> TxKind

Returns what kind of transaction this is

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

Returns the callee if this transaction is a call

pub fn signature(&self) -> PrimitiveSignature

Returns the Signature of the transaction

Trait Implementations

impl AsRef<TypedTransaction> for MaybeImpersonatedTransaction

fn as_ref(&self) -> &TypedTransaction

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for MaybeImpersonatedTransaction

fn clone(&self) -> MaybeImpersonatedTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MaybeImpersonatedTransaction

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

Formats the value using the given formatter.

impl Decodable for MaybeImpersonatedTransaction

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

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

impl Deref for MaybeImpersonatedTransaction

type Target = TypedTransaction

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for MaybeImpersonatedTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for MaybeImpersonatedTransaction

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

fn from(value: MaybeImpersonatedTransaction) -> Self

Converts to this type from the input type.

impl From<MaybeImpersonatedTransaction> for TypedTransaction

fn from(value: MaybeImpersonatedTransaction) -> Self

Converts to this type from the input type.

impl From<TypedTransaction> for MaybeImpersonatedTransaction

fn from(value: TypedTransaction) -> Self

Converts to this type from the input type.

impl PartialEq for MaybeImpersonatedTransaction

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MaybeImpersonatedTransaction

impl StructuralPartialEq for MaybeImpersonatedTransaction

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: 448 bytes