Struct celestia_types::DataAvailabilityHeader

pub struct DataAvailabilityHeader {
    pub row_roots: Vec<NamespacedHash>,
    pub column_roots: Vec<NamespacedHash>,
}

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());

Fields

row_roots: Vec<NamespacedHash>

Merkle roots of the ExtendedDataSquare rows.

column_roots: Vec<NamespacedHash>

Merkle roots of the ExtendedDataSquare columns.

Implementations

impl DataAvailabilityHeader

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

Get the root from an axis at the given index.

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

Get a root of the row with the given index.

pub fn column_root(&self, column: usize) -> 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_len(&self) -> usize

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

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 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 StructuralEq for DataAvailabilityHeader

impl StructuralPartialEq for DataAvailabilityHeader