Struct BlobTransactionSidecar 

#[repr(C)]
pub struct BlobTransactionSidecar {
    pub blobs: Vec<FixedBytes<alloy_eips::::eip4844::Blob::{constant#0}>>,
    pub commitments: Vec<FixedBytes<48>>,
    pub proofs: Vec<FixedBytes<48>>,
}

This represents a set of blobs, and its corresponding commitments and proofs.

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

Fields

blobs: Vec<FixedBytes<alloy_eips::::eip4844::Blob::{constant#0}>>

The blob data.

commitments: Vec<FixedBytes<48>>

The blob commitments.

proofs: Vec<FixedBytes<48>>

The blob proofs.

Implementations

impl BlobTransactionSidecar

pub fn match_versioned_hashes<'a>( &'a self, versioned_hashes: &'a [FixedBytes<32>], ) -> impl Iterator<Item = (usize, BlobAndProofV1)> + 'a

Matches versioned hashes and returns an iterator of (index, BlobAndProofV1) pairs where index is the position in versioned_hashes that matched the versioned hash in the sidecar.

This is used for the engine_getBlobsV1 RPC endpoint of the engine API

impl BlobTransactionSidecar

pub const fn new( blobs: Vec<FixedBytes<alloy_eips::::eip4844::Blob::{constant#0}>>, commitments: Vec<FixedBytes<48>>, proofs: Vec<FixedBytes<48>>, ) -> BlobTransactionSidecar

Constructs a new BlobTransactionSidecar from a set of blobs, commitments, and proofs.

pub fn from_kzg( blobs: Vec<Blob>, commitments: Vec<Bytes48>, proofs: Vec<Bytes48>, ) -> BlobTransactionSidecar

Creates a new instance from the given KZG types.

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

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

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 versioned_hashes(&self) -> VersionedHashIter<'_>

Returns an iterator over the versioned hashes of the commitments.

pub fn versioned_hash_for_blob( &self, blob_index: usize, ) -> Option<FixedBytes<32>>

Returns the versioned hash for the blob at the given index, if it exists.

pub fn size(&self) -> usize

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

pub fn try_from_blobs_hex<I, B>( blobs: I, ) -> Result<BlobTransactionSidecar, Error>

where I: IntoIterator<Item = B>, B: AsRef<str>,

Tries to create a new BlobTransactionSidecar from the hex encoded blob str.

See also Blob::from_hex

pub fn try_from_blobs_bytes<I, B>( blobs: I, ) -> Result<BlobTransactionSidecar, Error>

where I: IntoIterator<Item = B>, B: AsRef<[u8]>,

Tries to create a new BlobTransactionSidecar from the given blob bytes.

See also Blob::from_bytes

pub fn try_from_blobs(blobs: Vec<Blob>) -> Result<BlobTransactionSidecar, Error>

Tries to create a new BlobTransactionSidecar from the given blobs.

This uses the global/default KZG settings, see also EnvKzgSettings::Default.

pub fn rlp_encoded_length(&self) -> usize

Calculates the length of the BlobTransactionSidecar when encoded as RLP.

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

Encodes the BlobTransactionSidecar as RLP bytes.

pub fn rlp_decode(buf: &mut &[u8]) -> Result<BlobTransactionSidecar, Error>

Decodes the BlobTransactionSidecar from RLP bytes.

Trait Implementations

impl<'a> Arbitrary<'a> for BlobTransactionSidecar

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

fn clone(&self) -> BlobTransactionSidecar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlobTransactionSidecar

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

Formats the value using the given formatter.

impl Decodable for BlobTransactionSidecar

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

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

impl Decodable7594 for BlobTransactionSidecar

fn decode_7594(buf: &mut &[u8]) -> Result<BlobTransactionSidecar, 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 BlobTransactionSidecar

fn default() -> BlobTransactionSidecar

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BlobTransactionSidecar

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for BlobTransactionSidecar

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

Encodes the inner 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 BlobTransactionSidecar

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 From<BlobTransactionSidecar> for BlobTransactionSidecarVariant

fn from(value: BlobTransactionSidecar) -> BlobTransactionSidecarVariant

Converts to this type from the input type.

impl FromIterator<BlobTransactionSidecar> for BlobsBundleV1

fn from_iter<T>(iter: T) -> BlobsBundleV1

where T: IntoIterator<Item = BlobTransactionSidecar>,

Creates a value from an iterator.

impl Hash for BlobTransactionSidecar

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 IntoIterator for BlobTransactionSidecar

type Item = BlobTransactionSidecarItem

The type of the elements being iterated over.

type IntoIter = IntoIter<BlobTransactionSidecarItem>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <BlobTransactionSidecar as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for BlobTransactionSidecar

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

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 TxEip4844Sidecar for BlobTransactionSidecar

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

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.

impl Eq for BlobTransactionSidecar

impl StructuralPartialEq for BlobTransactionSidecar

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