Struct BlobSidecar 

pub struct BlobSidecar {
    pub commitment: [u8; 48],
    pub proof: [u8; 48],
    pub data: BlobDataPart,
}

Contains the full contents of a blob, including its KZG commitment and proof.

Fields

commitment: [u8; 48]

KZG commitment to the blob (compressed G₁ point, 48 bytes)

proof: [u8; 48]

KZG proof for evaluation correctness (compressed G₁ point, 48 bytes)

data: BlobDataPart

Blob data: 4096 field elements, each 32 bytes (128 KiB total)

Implementations

impl BlobSidecar

pub fn to_var_bytes(&self) -> Vec<u8>

Serializes this object into a variable length buffer

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

Deserializes from a bytes buffer. Resets buffer to a position after the bytes read.

Errors

Errors when the bytes are not available.

Trait Implementations

impl Archive for BlobSidecar

where [u8; 48]: Archive, BlobDataPart: Archive,

type Archived = ArchivedBlobSidecar

The archived representation of this type.

type Resolver = BlobSidecarResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for BlobSidecar

fn clone(&self) -> BlobSidecar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlobSidecar

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<BlobSidecar, __D> for Archived<BlobSidecar>

where [u8; 48]: Archive, Archived<[u8; 48]>: Deserialize<[u8; 48], __D>, BlobDataPart: Archive, Archived<BlobDataPart>: Deserialize<BlobDataPart, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<BlobSidecar, __D::Error>

Deserializes using the given deserializer

impl PartialEq for BlobSidecar

fn eq(&self, other: &BlobSidecar) -> 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<__S: Fallible + ?Sized> Serialize<__S> for BlobSidecar

where [u8; 48]: Serialize<__S>, BlobDataPart: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for BlobSidecar

impl StructuralPartialEq for BlobSidecar