Enum BlobTransactionSidecarVariant 

pub enum BlobTransactionSidecarVariant {
    Eip4844(BlobTransactionSidecar),
    Eip7594(BlobTransactionSidecarEip7594),
}

This represents a set of blobs, and its corresponding commitments and proofs. Proof type depends on the sidecar variant.

This type encodes and decodes the fields without an rlp header.

Variants

Eip4844(BlobTransactionSidecar)

EIP-4844 style blob transaction sidecar.

Eip7594(BlobTransactionSidecarEip7594)

EIP-7594 style blob transaction sidecar with cell proofs.

Implementations

impl BlobTransactionSidecarVariant

pub const fn is_eip4844(&self) -> bool

Returns true if this is a BlobTransactionSidecarVariant::Eip4844.

pub const fn is_eip7594(&self) -> bool

Returns true if this is a BlobTransactionSidecarVariant::Eip7594.

pub const fn as_eip4844(&self) -> Option<&BlobTransactionSidecar>

Returns the EIP-4844 sidecar if it is Self::Eip4844.

pub const fn as_eip7594(&self) -> Option<&BlobTransactionSidecarEip7594>

Returns the EIP-7594 sidecar if it is Self::Eip7594.

pub fn into_eip4844(self) -> Option<BlobTransactionSidecar>

Converts into EIP-4844 sidecar if it is Self::Eip4844.

pub fn into_eip7594(self) -> Option<BlobTransactionSidecarEip7594>

Converts the EIP-7594 sidecar if it is Self::Eip7594.

pub fn blobs(&self) -> &[FixedBytes<alloy_eips::::eip4844::Blob::{constant#0}>]

Get a reference to the blobs

pub fn into_blobs( self, ) -> Vec<FixedBytes<alloy_eips::::eip4844::Blob::{constant#0}>>

Consume self and return the blobs

pub const fn size(&self) -> usize

Calculates a size heuristic for the in-memory size of the BlobTransactionSidecarVariant.

pub fn try_convert_into_eip7594( self, ) -> Result<BlobTransactionSidecarVariant, Error>

Available on crate feature kzg only.

Attempts to convert this sidecar into the EIP-7594 format using default KZG settings.

This method converts an EIP-4844 sidecar to EIP-7594 by computing cell KZG proofs from the blob data. If the sidecar is already in EIP-7594 format, it returns itself unchanged.

The conversion requires computing CELLS_PER_EXT_BLOB cell proofs for each blob using the KZG trusted setup. The default KZG settings are loaded from the environment.

Returns

• Ok(Self) - The sidecar in EIP-7594 format (either converted or unchanged)
• Err(c_kzg::Error) - If KZG proof computation fails

Examples

// Convert an EIP-4844 sidecar to EIP-7594 format
let eip7594_sidecar = sidecar.try_convert_into_eip7594()?;

// Verify it's now in EIP-7594 format
assert!(eip7594_sidecar.is_eip7594());

pub fn try_convert_into_eip7594_with_settings( self, settings: &KZGSettings, ) -> Result<BlobTransactionSidecarVariant, Error>

Available on crate feature kzg only.

Attempts to convert this sidecar into the EIP-7594 format using custom KZG settings.

This method converts an EIP-4844 sidecar to EIP-7594 by computing cell KZG proofs from the blob data using the provided KZG settings. If the sidecar is already in EIP-7594 format, it returns itself unchanged.

The conversion requires computing CELLS_PER_EXT_BLOB cell proofs for each blob using the provided KZG trusted setup parameters.

Use this method when you need to specify custom KZG settings rather than using the defaults. For most use cases, try_convert_into_eip7594 is sufficient.

Arguments

• settings - The KZG settings to use for computing cell proofs

Returns

• Ok(Self) - The sidecar in EIP-7594 format (either converted or unchanged)
• Err(c_kzg::Error) - If KZG proof computation fails

Examples

// Load custom KZG settings
let kzg_settings = EnvKzgSettings::Default.get();

// Convert using custom settings
let eip7594_sidecar = sidecar.try_convert_into_eip7594_with_settings(kzg_settings)?;

// Verify it's now in EIP-7594 format
assert!(eip7594_sidecar.is_eip7594());

pub fn try_into_eip7594(self) -> Result<BlobTransactionSidecarEip7594, Error>

Available on crate feature kzg only.

Consumes this sidecar and returns a BlobTransactionSidecarEip7594 using default KZG settings.

This method converts an EIP-4844 sidecar to EIP-7594 by computing cell KZG proofs from the blob data. If the sidecar is already in EIP-7594 format, it extracts and returns the inner BlobTransactionSidecarEip7594.

Unlike try_convert_into_eip7594, this method returns the concrete BlobTransactionSidecarEip7594 type rather than the enum variant.

The conversion requires computing CELLS_PER_EXT_BLOB cell proofs for each blob using the KZG trusted setup. The default KZG settings are loaded from the environment.

Returns

• Ok(BlobTransactionSidecarEip7594) - The sidecar in EIP-7594 format
• Err(c_kzg::Error) - If KZG proof computation fails

Examples

// Convert and extract the EIP-7594 sidecar
let eip7594_sidecar = sidecar.try_into_eip7594()?;

// Now we have the concrete BlobTransactionSidecarEip7594 type
assert_eq!(eip7594_sidecar.blobs.len(), eip7594_sidecar.commitments.len());

pub fn try_into_eip7594_with_settings( self, settings: &KZGSettings, ) -> Result<BlobTransactionSidecarEip7594, Error>

Available on crate feature kzg only.

Consumes this sidecar and returns a BlobTransactionSidecarEip7594 using custom KZG settings.

This method converts an EIP-4844 sidecar to EIP-7594 by computing cell KZG proofs from the blob data using the provided KZG settings. If the sidecar is already in EIP-7594 format, it extracts and returns the inner BlobTransactionSidecarEip7594.

Unlike try_convert_into_eip7594_with_settings, this method returns the concrete BlobTransactionSidecarEip7594 type rather than the enum variant.

The conversion requires computing CELLS_PER_EXT_BLOB cell proofs for each blob using the provided KZG trusted setup parameters.

Use this method when you need to specify custom KZG settings rather than using the defaults. For most use cases, try_into_eip7594 is sufficient.

Arguments

• settings - The KZG settings to use for computing cell proofs

Returns

• Ok(BlobTransactionSidecarEip7594) - The sidecar in EIP-7594 format
• Err(c_kzg::Error) - If KZG proof computation fails

Examples

// Load custom KZG settings
let kzg_settings = EnvKzgSettings::Default.get();

// Convert and extract using custom settings
let eip7594_sidecar = sidecar.try_into_eip7594_with_settings(kzg_settings)?;

// Now we have the concrete BlobTransactionSidecarEip7594 type
assert_eq!(eip7594_sidecar.blobs.len(), eip7594_sidecar.commitments.len());

pub fn validate( &self, blob_versioned_hashes: &[FixedBytes<32>], proof_settings: &KZGSettings, ) -> Result<(), BlobTransactionValidationError>

Available on crate feature kzg only.

Verifies that the sidecar is valid. See relevant methods for each variant for more info.

pub fn commitments(&self) -> &[FixedBytes<48>]

Returns the commitments of the sidecar.

pub fn versioned_hashes(&self) -> VersionedHashIter<'_>

Returns an iterator over the versioned hashes of the commitments.

pub fn versioned_hash_index(&self, hash: &FixedBytes<32>) -> Option<usize>

Returns the index of the versioned hash in the commitments vector.

pub fn blob_by_versioned_hash( &self, hash: &FixedBytes<32>, ) -> Option<&FixedBytes<alloy_eips::::eip4844::Blob::{constant#0}>>

Returns the blob corresponding to the versioned hash, if it exists.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for BlobTransactionSidecarVariant

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

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

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlobTransactionSidecarVariant, 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 Clone for BlobTransactionSidecarVariant

fn clone(&self) -> BlobTransactionSidecarVariant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlobTransactionSidecarVariant

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

Formats the value using the given formatter.

impl Decodable for BlobTransactionSidecarVariant

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

Decodes the inner BlobTransactionSidecar fields from RLP bytes, without a RLP header.

impl Decodable7594 for BlobTransactionSidecarVariant

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

Decode the sidecar according to EIP-7594 rules. First a 1-byte wrapper version (if any), then the body of the sidecar.

impl Default for BlobTransactionSidecarVariant

fn default() -> BlobTransactionSidecarVariant

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BlobTransactionSidecarVariant

Available on crate feature serde only.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for BlobTransactionSidecarVariant

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

Encodes the BlobTransactionSidecar fields as RLP bytes, without a RLP header.

fn length(&self) -> usize

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

impl Encodable7594 for BlobTransactionSidecarVariant

fn encode_7594_len(&self) -> usize

The length of the 7594 encoded envelope. This is the length of the wrapper version + the length of the inner encoding.

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

Encode the sidecar according to EIP-7594 rules. First a 1-byte wrapper version (if any), then the body of the sidecar.

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

Encode the sidecar according to [EIP-7594] rules. First a 1-byte wrapper version (if any), then the body of the sidecar.

impl Eq for BlobTransactionSidecarVariant

impl From<BlobTransactionSidecar> for BlobTransactionSidecarVariant

fn from(value: BlobTransactionSidecar) -> BlobTransactionSidecarVariant

Converts to this type from the input type.

impl From<BlobTransactionSidecarEip7594> for BlobTransactionSidecarVariant

fn from(value: BlobTransactionSidecarEip7594) -> BlobTransactionSidecarVariant

Converts to this type from the input type.

impl<'a> From<BlobTransactionSidecarVariant<'a>> for BlobTransactionSidecarVariant

fn from( value: BlobTransactionSidecarVariant<'a>, ) -> BlobTransactionSidecarVariant

Converts to this type from the input type.

impl Hash for BlobTransactionSidecarVariant

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 BlobTransactionSidecarVariant

fn eq(&self, other: &BlobTransactionSidecarVariant) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for BlobTransactionSidecarVariant

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 StructuralPartialEq for BlobTransactionSidecarVariant

impl TryFrom<BlobTransactionSidecarVariant> for BlobTransactionSidecarEip7594

Available on crate feature kzg only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: BlobTransactionSidecarVariant, ) -> Result<BlobTransactionSidecarEip7594, <BlobTransactionSidecarEip7594 as TryFrom<BlobTransactionSidecarVariant>>::Error>

Performs the conversion.

impl TxEip4844Sidecar for BlobTransactionSidecarVariant

fn validate( &self, blob_versioned_hashes: &[B256], proof_settings: &KzgSettings, ) -> Result<(), BlobTransactionValidationError>

Available on crate feature kzg only.

Verifies that the versioned hashes are valid for this sidecar’s blob data, commitments, and proofs.

fn size(&self) -> usize

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

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

Size for each variant:

• Eip4844: 72 bytes
• Eip7594: 72 bytes