Struct TransactionSignedNoHash

pub struct TransactionSignedNoHash {
    pub signature: PrimitiveSignature,
    pub transaction: Transaction,
}

Signed transaction without its Hash. Used type for inserting into the DB.

This can by converted to TransactionSigned by calling TransactionSignedNoHash::hash.

Fields

signature: PrimitiveSignature

The transaction signature values

transaction: Transaction

Raw transaction info

Implementations

impl TransactionSignedNoHash

pub fn hash(&self) -> FixedBytes<32>

Calculates the transaction hash. If used more than once, it’s better to convert it to TransactionSigned first.

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

Recover signer from signature and hash.

Returns None if the transaction’s signature is invalid, see also Self::recover_signer.

pub fn encode_and_recover_unchecked( &self, buffer: &mut Vec<u8>, ) -> Option<Address>

Recover signer from signature and hash without ensuring that the signature has a low s value.

Reuses a given buffer to avoid numerous reallocations when recovering batches. Clears the buffer before use.

Returns None if the transaction’s signature is invalid, see also recover_signer_unchecked.

Optimism

For optimism this will return Address::ZERO if the Signature is empty, this is because pre bedrock (on OP mainnet), relay messages to the L2 Cross Domain Messenger were sent as legacy transactions from the zero address with an empty signature, e.g.: https://optimistic.etherscan.io/tx/0x1bb352ff9215efe5a4c102f45d730bae323c3288d2636672eb61543ddd47abad This makes it possible to import pre bedrock transactions via the sender recovery stage.

pub fn with_hash(self) -> TransactionSigned

Converts into a transaction type with its hash: TransactionSigned.

Note: This will recalculate the hash of the transaction.

pub fn recover_signers<'a, T>(txes: T, num_txes: usize) -> Option<Vec<Address>>

where T: IntoParallelIterator<Item = &'a TransactionSignedNoHash> + IntoIterator<Item = &'a TransactionSignedNoHash> + Send,

Recovers a list of signers from a transaction list iterator

Returns None, if some transaction’s signature is invalid, see also Self::recover_signer.

Methods from Deref<Target = Transaction>

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

Heavy operation that return signature hash over rlp encoded transaction. It is only for signature signing or signer recovery.

pub fn kind(&self) -> TxKind

Gets the transaction’s TxKind, which is the address of the recipient or TxKind::Create if the transaction is a contract creation.

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

Get the transaction’s address of the contract that will be called, or the address that will receive the transfer.

Returns None if this is a CREATE transaction.

pub fn tx_type(&self) -> TxType

Get the transaction’s type

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

Returns the AccessList of the transaction.

Returns None for legacy transactions.

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

Returns the SignedAuthorization list of the transaction.

Returns None if this transaction is not EIP-7702.

pub fn is_dynamic_fee(&self) -> bool

Returns true if the tx supports dynamic fees

pub fn blob_versioned_hashes(&self) -> Option<Vec<FixedBytes<32>>>

Blob versioned hashes for eip4844 transaction, for legacy, eip1559, eip2930 and eip7702 transactions this is None

This is also commonly referred to as the “blob versioned hashes” (BlobVersionedHashes).

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

Returns the blob gas used for all blobs of the EIP-4844 transaction if it is an EIP-4844 transaction.

This is the number of blobs times the DATA_GAS_PER_BLOB a single blob consumes.

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

Returns the effective miner gas tip cap (gasTipCap) for the given base fee: min(maxFeePerGas - baseFee, maxPriorityFeePerGas)

If the base fee is None, the max_priority_fee_per_gas, or gas price for non-EIP1559 transactions is returned.

Returns None if the basefee is higher than the Transaction::max_fee_per_gas.

pub fn input(&self) -> &Bytes

Get the transaction’s input field.

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

This encodes the transaction without the signature, and is only suitable for creating a hash intended for signing.

pub fn eip2718_encode( &self, signature: &PrimitiveSignature, out: &mut dyn BufMut, )

Produces EIP-2718 encoding of the transaction

pub fn is_legacy(&self) -> bool

Returns true if the transaction is a legacy transaction.

pub fn is_eip2930(&self) -> bool

Returns true if the transaction is an EIP-2930 transaction.

pub fn is_eip1559(&self) -> bool

Returns true if the transaction is an EIP-1559 transaction.

pub fn is_eip4844(&self) -> bool

Returns true if the transaction is an EIP-4844 transaction.

pub fn is_eip7702(&self) -> bool

Returns true if the transaction is an EIP-7702 transaction.

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

Returns the [TxLegacy] variant if the transaction is a legacy transaction.

pub fn as_eip2930(&self) -> Option<&TxEip2930>

Returns the [TxEip2930] variant if the transaction is an EIP-2930 transaction.

pub fn as_eip1559(&self) -> Option<&TxEip1559>

Returns the [TxEip1559] variant if the transaction is an EIP-1559 transaction.

pub fn as_eip4844(&self) -> Option<&TxEip4844>

Returns the [TxEip4844] variant if the transaction is an EIP-4844 transaction.

pub fn as_eip7702(&self) -> Option<&TxEip7702>

Returns the [TxEip7702] variant if the transaction is an EIP-7702 transaction.

Trait Implementations

impl<'a> Arbitrary<'a> for TransactionSignedNoHash

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<TransactionSignedNoHash, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

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

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

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

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl AsRef<Transaction> for TransactionSignedNoHash

fn as_ref(&self) -> &Transaction

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

impl Clone for TransactionSignedNoHash

fn clone(&self) -> TransactionSignedNoHash

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compact for TransactionSignedNoHash

Available on crate feature reth-codec only.

fn to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

Takes a buffer which can be written to. Ideally, it returns the length written to.

fn from_compact(buf: &[u8], _len: usize) -> (TransactionSignedNoHash, &[u8])

Takes a buffer which can be read from. Returns the object and buf with its internal cursor advanced (eg..advance(len)).

fn specialized_to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

“Optional”: If there’s no good reason to use it, don’t.

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

“Optional”: If there’s no good reason to use it, don’t.

impl Compress for TransactionSignedNoHash

type Compressed = Vec<u8>

Compressed type.

fn compress_to_buf<B>(self, buf: &mut B)

where B: BufMut + AsMut<[u8]>,

Compresses data to a given buffer.

fn uncompressable_ref(&self) -> Option<&[u8]>

If the type cannot be compressed, return its inner reference as Some(self.as_ref())

fn compress(self) -> Self::Compressed

Compresses data going into the database.

impl Debug for TransactionSignedNoHash

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

Formats the value using the given formatter.

impl Decompress for TransactionSignedNoHash

fn decompress(value: &[u8]) -> Result<TransactionSignedNoHash, DatabaseError>

Decompresses data coming from the database.

fn decompress_owned(value: Vec<u8>) -> Result<Self, DatabaseError>

Decompresses owned data coming from the database.

impl Default for TransactionSignedNoHash

fn default() -> TransactionSignedNoHash

Returns the “default value” for a type.

impl Deref for TransactionSignedNoHash

type Target = Transaction

The resulting type after dereferencing.

fn deref(&self) -> &<TransactionSignedNoHash as Deref>::Target

Dereferences the value.

impl<'de> Deserialize<'de> for TransactionSignedNoHash

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TransactionSigned> for TransactionSignedNoHash

fn from(tx: TransactionSigned) -> TransactionSignedNoHash

Converts to this type from the input type.

impl From<TransactionSignedNoHash> for TransactionSigned

fn from(tx: TransactionSignedNoHash) -> TransactionSigned

Converts to this type from the input type.

impl From<TransactionSignedNoHash> for TransactionSignedVariant

fn from(value: TransactionSignedNoHash) -> TransactionSignedVariant

Converts to this type from the input type.

impl Hash for TransactionSignedNoHash

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

where __H: Hasher,

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 TransactionSignedNoHash

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

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 TransactionSignedNoHash

impl StructuralPartialEq for TransactionSignedNoHash

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