Struct TransactionSigned

pub struct TransactionSigned {
    pub hash: OnceLock<FixedBytes<32>>,
    pub signature: PrimitiveSignature,
    pub transaction: Transaction,
}

Signed transaction.

Fields

hash: OnceLock<FixedBytes<32>>

Transaction hash

signature: PrimitiveSignature

The transaction signature values

transaction: Transaction

Raw transaction info

Implementations

impl TransactionSigned

pub fn new( transaction: Transaction, signature: PrimitiveSignature, hash: FixedBytes<32>, ) -> TransactionSigned

Creates a new signed transaction from the given parts.

pub fn new_unhashed( transaction: Transaction, signature: PrimitiveSignature, ) -> TransactionSigned

Creates a new signed transaction from the given transaction and signature without the hash.

Note: this only calculates the hash on the first TransactionSigned::hash call.

pub const fn transaction(&self) -> &Transaction

Transaction

pub fn try_into_pooled(self) -> Result<PooledTransaction, TransactionSigned>

Tries to convert a TransactionSigned into a PooledTransaction.

This function used as a helper to convert from a decoded p2p broadcast message to PooledTransaction. Since EIP4844 variants are disallowed to be broadcasted on p2p, return an err if tx is Transaction::Eip4844.

pub fn try_into_pooled_eip4844( self, sidecar: BlobTransactionSidecar, ) -> Result<PooledTransaction, TransactionSigned>

Converts from an EIP-4844 RecoveredTx to a PooledTransactionsElementEcRecovered with the given sidecar.

Returns an Err containing the original TransactionSigned if the transaction is not EIP-4844.

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

Transaction hash. Used to identify transaction.

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

where T: IntoParallelIterator<Item = &'a TransactionSigned> + IntoIterator<Item = &'a TransactionSigned> + 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.

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

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

Recovers a list of signers from a transaction list iterator without ensuring that the signature has a low s value.

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

pub const fn with_signer(self, signer: Address) -> RecoveredTx

Returns the RecoveredTx transaction with the given sender.

pub fn into_ecrecovered(self) -> Option<RecoveredTx>

Consumes the type, recover signer and return RecoveredTx

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

pub fn into_ecrecovered_unchecked(self) -> Option<RecoveredTx>

Consumes the type, recover signer and return RecoveredTx without ensuring that the signature has a low s value (EIP-2).

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

pub fn try_into_ecrecovered_unchecked( self, ) -> Result<RecoveredTx, TransactionSigned>

Tries to recover signer and return RecoveredTx. without ensuring that the signature has a low s value (EIP-2).

Returns Err(Self) if the transaction’s signature is invalid, see also Self::recover_signer_unchecked.

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

Calculate transaction hash, eip2728 transaction does not contain rlp header and start with tx type.

pub fn into_parts(self) -> (Transaction, PrimitiveSignature, FixedBytes<32>)

Splits the transaction into parts.

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 tx_type(&self) -> TxType

Get the transaction’s type

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 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 TransactionSigned

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<TransactionSigned, 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 TransactionSigned

fn as_ref(&self) -> &Transaction

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

impl AsRef<TransactionSigned> for TransactionSigned

fn as_ref(&self) -> &TransactionSigned

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

impl Clone for TransactionSigned

fn clone(&self) -> TransactionSigned

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compact for TransactionSigned

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) -> (TransactionSigned, &[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 TransactionSigned

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 TransactionSigned

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

Formats the value using the given formatter.

impl Decodable for TransactionSigned

fn decode(buf: &mut &[u8]) -> Result<TransactionSigned, Error>

This Decodable implementation only supports decoding rlp encoded transactions as it’s used by p2p.

The p2p encoding format always includes an RLP header, although the type RLP header depends on whether or not the transaction is a legacy transaction.

If the transaction is a legacy transaction, it is just encoded as a RLP list: rlp(tx-data).

If the transaction is a typed transaction, it is encoded as a RLP string: rlp(tx-type || rlp(tx-data))

This can be used for decoding all signed transactions in p2p BlockBodies responses.

This cannot be used for decoding EIP-4844 transactions in p2p PooledTransactions, since the EIP-4844 variant of TransactionSigned does not include the blob sidecar.

For a method suitable for decoding pooled transactions, see PooledTransaction.

CAUTION: Due to a quirk in [Header::decode], this method will succeed even if a typed transaction is encoded in this format, and does not start with a RLP header: tx-type || rlp(tx-data).

This is because [Header::decode] does not advance the buffer, and returns a length-1 string header if the first byte is less than 0xf7.

impl Decodable2718 for TransactionSigned

fn typed_decode( ty: u8, buf: &mut &[u8], ) -> Result<TransactionSigned, Eip2718Error>

Decode the appropriate variant, based on the type flag.

fn fallback_decode(buf: &mut &[u8]) -> Result<TransactionSigned, Eip2718Error>

Decode the default variant.

fn extract_type_byte(buf: &mut &[u8]) -> Option<u8>

Extract the type byte from the buffer, if any. The type byte is the first byte, provided that that first byte is 0x7f or lower.

fn decode_2718(buf: &mut &[u8]) -> Result<Self, Eip2718Error>

Encode the transaction according to EIP-2718 rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn network_decode(buf: &mut &[u8]) -> Result<Self, Eip2718Error>

Decode an EIP-2718 transaction in the network format. The network format is used ONLY by the Ethereum p2p protocol. Do not call this method unless you are building a p2p protocol client.

impl Decompress for TransactionSigned

fn decompress(value: &[u8]) -> Result<TransactionSigned, 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 TransactionSigned

fn default() -> TransactionSigned

Returns the “default value” for a type.

impl Deref for TransactionSigned

type Target = Transaction

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de> Deserialize<'de> for TransactionSigned

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> DeserializeAs<'de, TransactionSigned> for TransactionSigned<'de>

fn deserialize_as<D>( deserializer: D, ) -> Result<TransactionSigned, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for TransactionSigned

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

This encodes the transaction with the signature, and an rlp header.

For legacy transactions, it encodes the transaction data: rlp(tx-data)

For EIP-2718 typed transactions, it encodes the transaction type followed by the rlp of the transaction: rlp(tx-type || rlp(tx-data))

fn length(&self) -> usize

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

impl Encodable2718 for TransactionSigned

fn type_flag(&self) -> Option<u8>

Return the type flag (if any).

fn encode_2718_len(&self) -> usize

The length of the 2718 encoded envelope. This is the length of the type flag + the length of the inner encoding.

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

Encode the transaction according to EIP-2718 rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn trie_hash(&self) -> FixedBytes<32>

Compute the hash as committed to in the MPT trie. This hash is used ONLY by the Ethereum merkle-patricia trie and associated proofs. Do not call this method unless you are building a full or light client.

fn is_legacy(&self) -> bool

True if the envelope is the legacy variant.

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

Encode the transaction according to [EIP-2718] rules. First a 1-byte type flag in the range 0x0-0x7f, then the body of the transaction.

fn seal(self) -> Sealed<Self>

Seal the encodable, by encoding and hashing it.

fn network_len(&self) -> usize

The length of the 2718 encoded envelope in network format. This is the length of the header + the length of the type flag and inner encoding.

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

Encode in the network format. The network format is used ONLY by the Ethereum p2p protocol. Do not call this method unless you are building a p2p protocol client.

impl FillTxEnv for TransactionSigned

fn fill_tx_env(&self, tx_env: &mut TxEnv, sender: Address)

Fills TxEnv with an Address and transaction.

impl FillTxEnv for TransactionSigned

fn fill_tx_env(&self, tx_env: &mut TxEnv, sender: Address)

Fills TxEnv with an Address and transaction.

impl<'a> From<&'a TransactionSigned> for TransactionSigned<'a>

fn from(value: &'a TransactionSigned) -> TransactionSigned<'a>

Converts to this type from the input type.

impl From<PooledTransaction> for TransactionSigned

fn from(tx: PooledTransaction) -> TransactionSigned

Converts to this type from the input type.

impl From<RecoveredTx<PooledTransaction>> for TransactionSigned

fn from(recovered: RecoveredTx<PooledTransaction>) -> TransactionSigned

Converts to this type from the input type.

impl From<RecoveredTx> for TransactionSigned

fn from(recovered: RecoveredTx) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<Transaction>> for TransactionSigned

fn from(value: Signed<Transaction>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TxEip1559>> for TransactionSigned

fn from(value: Signed<TxEip1559>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TxEip2930>> for TransactionSigned

fn from(value: Signed<TxEip2930>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TxEip4844>> for TransactionSigned

fn from(value: Signed<TxEip4844>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TxEip4844WithSidecar>> for TransactionSigned

fn from(value: Signed<TxEip4844WithSidecar>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TxEip7702>> for TransactionSigned

fn from(value: Signed<TxEip7702>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TxLegacy>> for TransactionSigned

fn from(value: Signed<TxLegacy>) -> TransactionSigned

Converts to this type from the input type.

impl From<Signed<TypedTransaction>> for TransactionSigned

fn from(value: Signed<TypedTransaction>) -> TransactionSigned

Converts to this type from the input type.

impl<'a> From<TransactionSigned<'a>> for TransactionSigned

fn from(value: TransactionSigned<'a>) -> TransactionSigned

Converts to this type from the input type.

impl From<TransactionSigned> for Signed<Transaction>

fn from(value: TransactionSigned) -> Signed<Transaction>

Converts to this type from the input type.

impl Hash for TransactionSigned

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 InMemorySize for TransactionSigned

fn size(&self) -> usize

Calculate a heuristic for the in-memory size of the TransactionSigned.

impl PartialEq for TransactionSigned

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

type BincodeRepr<'a> = TransactionSigned<'a>

Serde representation of the type for bincode serialization.

impl Serialize for TransactionSigned

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 SerializeAs<TransactionSigned> for TransactionSigned<'_>

fn serialize_as<S>( source: &TransactionSigned, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SignedTransaction for TransactionSigned

fn tx_hash(&self) -> &FixedBytes<32>

Returns reference to transaction hash.

fn signature(&self) -> &PrimitiveSignature

Returns reference to signature.

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

Recover signer from signature and hash.

fn recover_signer_unchecked_with_buf( &self, buf: &mut Vec<u8>, ) -> Option<Address>

Same as Self::recover_signer_unchecked but receives a buffer to operate on. This is used during batch recovery to avoid allocating a new buffer for each transaction.

fn is_broadcastable_in_full(&self) -> bool

Returns whether this transaction type can be broadcasted as full transaction over the network.

fn recover_signer_unchecked(&self) -> Option<Address>

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

fn recalculate_hash(&self) -> FixedBytes<32>

Calculate transaction hash, eip2728 transaction does not contain rlp header and start with tx type.

impl Transaction for TransactionSigned

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

Get chain_id.

fn nonce(&self) -> u64

Get nonce.

fn gas_limit(&self) -> u64

Get gas_limit.

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

Get gas_price.

fn max_fee_per_gas(&self) -> u128

Returns the EIP-1559 the maximum fee per gas the caller is willing to pay.

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

Returns the EIP-1559 Priority fee the caller is paying to the block author.

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

Max fee per blob gas for EIP-4844 transaction.

fn priority_fee_or_price(&self) -> u128

Return the max priority fee per gas if the transaction is an EIP-1559 transaction, and otherwise return the gas price.

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

Returns the effective gas price for the given base fee.

fn is_dynamic_fee(&self) -> bool

Returns true if the transaction supports dynamic fees.

fn kind(&self) -> TxKind

Returns the transaction kind.

fn is_create(&self) -> bool

Returns true if the transaction is a contract creation. We don’t provide a default implementation via kind as it copies the 21-byte TxKind for this simple check. A proper implementation shouldn’t allocate.

fn value(&self) -> Uint<256, 4>

Get value.

fn input(&self) -> &Bytes

Get data.

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

Returns the EIP-2930 access_list for the particular transaction type. Returns None for older transaction types.

fn blob_versioned_hashes(&self) -> Option<&[FixedBytes<32>]>

Blob versioned hashes for eip4844 transaction. For previous transaction types this is None.

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

Returns the SignedAuthorization list of the transaction.

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

Returns the effective tip for this transaction.

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.

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

Returns the total gas for all blobs in this transaction.

impl TryFrom<TransactionSigned> for PooledTransaction

type Error = TransactionConversionError

The type returned in the event of a conversion error.

fn try_from( tx: TransactionSigned, ) -> Result<PooledTransaction, <PooledTransaction as TryFrom<TransactionSigned>>::Error>

Performs the conversion.

impl TryFrom<WithOtherFields<Transaction<AnyTxEnvelope>>> for TransactionSigned

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( tx: WithOtherFields<Transaction<AnyTxEnvelope>>, ) -> Result<TransactionSigned, <TransactionSigned as TryFrom<WithOtherFields<Transaction<AnyTxEnvelope>>>>::Error>

Performs the conversion.

impl Typed2718 for TransactionSigned

fn ty(&self) -> u8

Returns the EIP-2718 type flag.

fn is_type(&self, ty: u8) -> bool

Returns true if the type matches the given type.

fn is_legacy(&self) -> bool

Returns true if the type is a legacy transaction.

fn is_eip2930(&self) -> bool

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

fn is_eip1559(&self) -> bool

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

fn is_eip4844(&self) -> bool

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

fn is_eip7702(&self) -> bool

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

impl Eq for TransactionSigned

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