Struct alloy_consensus::transaction::eip4844::TxEip4844

pub struct TxEip4844 {
    pub chain_id: ChainId,
    pub nonce: u64,
    pub gas_limit: u128,
    pub max_fee_per_gas: u128,
    pub max_priority_fee_per_gas: u128,
    pub to: Address,
    pub value: U256,
    pub access_list: AccessList,
    pub blob_versioned_hashes: Vec<B256>,
    pub max_fee_per_blob_gas: u128,
    pub input: Bytes,
}

EIP-4844 Blob Transaction

A transaction with blob hashes and max blob fee. It does not have the Blob sidecar.

Fields

chain_id: ChainId

Added as EIP-pub 155: Simple replay attack protection

nonce: u64

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

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.

max_fee_per_gas: 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.

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

This is also known as GasFeeCap

max_priority_fee_per_gas: u128

Max Priority fee that transaction is paying

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

This is also known as GasTipCap

to: Address

The 160-bit address of the message call’s recipient.

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.

access_list: AccessList

The accessList specifies a list of addresses and storage keys; these addresses and storage keys are added into the accessed_addresses and accessed_storage_keys global sets (introduced in EIP-2929). A gas cost is charged, though at a discount relative to the cost of accessing outside the list.

blob_versioned_hashes: Vec<B256>

It contains a vector of fixed size hash(32 bytes)

max_fee_per_blob_gas: u128

Max fee per data gas

aka BlobFeeCap or blobGasFeeCap

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 TxEip4844

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

Returns the effective gas price for the given base_fee.

pub fn blob_gas(&self) -> u64

Returns the total gas for all blobs in this transaction.

pub fn validate_blob( &self, sidecar: &BlobTransactionSidecar, proof_settings: &KzgSettings, ) -> Result<(), BlobTransactionValidationError>

Available on crate feature kzg only.

Verifies that the given blob data, commitments, and proofs are all valid for this transaction.

Takes as input the KzgSettings, which should contain the parameters derived from the KZG trusted setup.

This ensures that the blob transaction payload has the same number of blob data elements, commitments, and proofs. Each blob data element is verified against its commitment and proof.

Returns BlobTransactionValidationError::InvalidProof if any blob KZG proof in the response fails to verify, or if the versioned hashes in the transaction do not match the actual commitment versioned hashes.

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

Decodes the inner TxEip4844Variant fields from RLP bytes.

NOTE: This assumes a RLP header has already been decoded, and just decodes the following RLP fields in the following order:

• chain_id
• nonce
• max_priority_fee_per_gas
• max_fee_per_gas
• gas_limit
• to
• value
• data (input)
• access_list
• max_fee_per_blob_gas
• blob_versioned_hashes

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

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

pub fn size(&self) -> usize

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

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

Returns what the encoded length should be, if the transaction were RLP encoded with the given signature, depending on the value of with_header.

If with_header is true, the payload length will include the RLP header length. If with_header is false, the payload length will not include the RLP header length.

pub(crate) 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 const fn tx_type(&self) -> TxType

Get transaction type.

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

Encodes the EIP-4844 transaction in RLP for signing.

This encodes the transaction as: tx_type || rlp(chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, input, access_list, max_fee_per_blob_gas, blob_versioned_hashes)

Note that there is no rlp header before the transaction type byte.

pub fn payload_len_for_signature(&self) -> usize

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

Trait Implementations

impl Clone for TxEip4844

fn clone(&self) -> TxEip4844

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TxEip4844

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

Formats the value using the given formatter.

impl Decodable for TxEip4844

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 TxEip4844

fn default() -> TxEip4844

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TxEip4844

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for TxEip4844

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<TxEip4844> for TxEip4844Variant

fn from(tx: TxEip4844) -> Self

Converts to this type from the input type.

impl From<TxEip4844> for TypedTransaction

fn from(tx: TxEip4844) -> Self

Converts to this type from the input type.

impl From<TxEip4844WithSidecar> for TxEip4844

fn from(tx_with_sidecar: TxEip4844WithSidecar) -> Self

Consumes the TxEip4844WithSidecar and returns the inner TxEip4844.

impl Hash for TxEip4844

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 TxEip4844

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

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 TxEip4844

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 use_eip155(&self) -> bool

True if the transaction uses EIP-155 signatures.

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 TxEip4844

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 TxEip4844

impl StructuralPartialEq for TxEip4844

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