Struct celestia_types::DataAvailabilityHeader

pub struct DataAvailabilityHeader { /* private fields */ }

Header with commitments of the data availability.

It consists of the root hashes of the merkle trees created from each row and column of the ExtendedDataSquare. Those are used to prove the inclusion of the data in a block.

The hash of this header is a hash of all rows and columns and thus a data commitment of the block.

Example

// fetch the block header and data for your namespace
let namespace = Namespace::new_v0(&[1, 2, 3, 4]).unwrap();
let eh = extended_header();
let (shares, proof) = shares_with_proof(eh.height(), &namespace);

// get the data commitment for a given row
let dah = eh.dah;
let root = dah.row_root(0).unwrap();

// verify a proof of the inclusion of the shares
assert!(proof.verify_complete_namespace(&root, &shares, *namespace).is_ok());

Implementations

impl DataAvailabilityHeader

pub fn new( row_roots: Vec<NamespacedHash>, column_roots: Vec<NamespacedHash>, ) -> Result<Self>

Create new DataAvailabilityHeader.

pub fn new_unchecked( row_roots: Vec<NamespacedHash>, column_roots: Vec<NamespacedHash>, ) -> Self

Create new non-validated DataAvailabilityHeader.

DataAvailabilityHeader::validate_basic can be used to check valitidy later on.

pub fn from_eds(eds: &ExtendedDataSquare) -> Self

Create a DataAvailabilityHeader by computing roots of a given ExtendedDataSquare.

pub fn root(&self, axis: AxisType, index: u16) -> Option<NamespacedHash>

Get the root from an axis at the given index.

pub fn row_roots(&self) -> &[NamespacedHash]

Merkle roots of the ExtendedDataSquare rows.

pub fn column_roots(&self) -> &[NamespacedHash]

Merkle roots of the ExtendedDataSquare columns.

pub fn row_root(&self, row: u16) -> Option<NamespacedHash>

Get a root of the row with the given index.

pub fn column_root(&self, column: u16) -> Option<NamespacedHash>

Get the a root of the column with the given index.

pub fn hash(&self) -> Hash

Compute the combined hash of all rows and columns.

This is the data commitment for the block.

Example

let eh = get_extended_header();
let dah = eh.dah;

assert_eq!(dah.hash(), eh.header.data_hash);

pub fn square_width(&self) -> u16

Get the size of the ExtendedDataSquare for which this header was built.

Trait Implementations

impl Clone for DataAvailabilityHeader

fn clone(&self) -> DataAvailabilityHeader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DataAvailabilityHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataAvailabilityHeader

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DataAvailabilityHeader> for DataAvailabilityHeader

fn from(value: DataAvailabilityHeader) -> RawDataAvailabilityHeader

Converts to this type from the input type.

impl PartialEq for DataAvailabilityHeader

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

fn encode<B>(&self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode into a buffer in Protobuf format.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode with a length-delimiter to a buffer in Protobuf format.

fn decode<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode an instance from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode a length-delimited instance from the buffer.

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn encode_vec(&self) -> Result<Vec<u8>, Infallible>

Encodes into a Protobuf-encoded Vec<u8>.

fn decode_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance from a Vec<u8> (or equivalent).

fn encode_length_delimited_vec(&self) -> Result<Vec<u8>, Infallible>

Encode with a length-delimiter to a Vec<u8> Protobuf-encoded message.

fn decode_length_delimited_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance with a length-delimiter from a Vec<u8> or equivalent.

impl Serialize for DataAvailabilityHeader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<DataAvailabilityHeader> for DataAvailabilityHeader

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: RawDataAvailabilityHeader) -> Result<Self, Self::Error>

Performs the conversion.

impl ValidateBasic for DataAvailabilityHeader

fn validate_basic(&self) -> Result<(), ValidationError>

Perform a basic validation of the data consistency.

impl Eq for DataAvailabilityHeader

impl StructuralPartialEq for DataAvailabilityHeader