Struct ExtendedHeader 

pub struct ExtendedHeader {
    pub header: Header,
    pub commit: Commit,
    pub validator_set: ValidatorSet,
    pub dah: DataAvailabilityHeader,
}

Block header together with the relevant Data Availability metadata.

ExtendedHeaders are used to announce and describe the blocks in the Celestia network.

Before being used, each header should be validated and verified with a header you trust.

Example

let genesis_header = trusted_genesis_header();

// fetch new header
let fetched_header = some_untrusted_header();

fetched_header.validate().expect("Invalid block header");
genesis_header.verify(&fetched_header).expect("Malicious header received");

Fields

header: Header

Tendermint block header.

commit: Commit

Commit metadata and signatures from validators committing the block.

validator_set: ValidatorSet

Information about the set of validators commiting the block.

dah: DataAvailabilityHeader

Header of the block data availability.

Implementations

impl ExtendedHeader

pub fn decode_and_validate(bytes: &[u8]) -> Result<Self>

Decode protobuf encoded header and then validate it.

pub fn app_version(&self) -> Result<AppVersion>

Get the app version.

Errors

This function returns an error if the app version set in header is not currently supported.

pub fn chain_id(&self) -> &Id

Get the block chain id.

pub fn height(&self) -> Height

Get the block height.

pub fn time(&self) -> Time

Get the block time.

pub fn hash(&self) -> Hash

Get the block hash.

pub fn last_header_hash(&self) -> Hash

Get the hash of the previous header.

pub fn validate(&self) -> Result<()>

Validate header.

Performs a consistency check of the data included in the header.

Errors

If validation fails, this function will return an error with a reason of failure.

// fetch new header
let mut fetched_header = get_header(15);

assert!(fetched_header.validate().is_ok());

fetched_header.dah = DataAvailabilityHeader::new_unchecked(vec![], vec![]);

assert!(fetched_header.validate().is_err());

pub fn verify(&self, untrusted: &ExtendedHeader) -> Result<()>

Verify an untrusted header.

Ensures that the untrusted header can be trusted by verifying it against self.

Note

This method does not do validation for optimization purposes. Validation should be done from before and ideally with ExtendedHeader::decode_and_validate.

Errors

If verification fails, this function will return an error with a reason of failure.

Please note that if verifying unadjacent headers, the verification will always fail if the validator set commiting those blocks was changed. If that is the case, consider verifying the untrusted header with a more recent or even previous header.

pub fn verify_adjacent(&self, untrusted: &ExtendedHeader) -> Result<()>

Verify an untrusted header and make sure they are adjacent to self.

Ensures that the untrusted header is adjacent and can be trusted by verifying it against self.

Note

This method does not do validation for optimization purposes. Validation should be done from before and ideally with ExtendedHeader::decode_and_validate.

Errors

If verification fails, this function will return an error with a reason of failure.

pub fn verify_range(&self, untrusted: &[ExtendedHeader]) -> Result<()>

Verify a chain of adjacent untrusted headers.

Note

This method does not do validation for optimization purposes. Validation should be done from before and ideally with ExtendedHeader::decode_and_validate.

Errors

If verification fails, this function will return an error with a reason of failure. This function will also return an error if untrusted headers are not adjacent to each other.

Example

let genesis_header = trusted_genesis();
let next_headers = get_headers_range(5..50);

assert!(genesis_header.verify_range(&next_headers).is_ok());

pub fn verify_adjacent_range(&self, untrusted: &[ExtendedHeader]) -> Result<()>

Verify a chain of adjacent untrusted headers and make sure they are adjacent to self.

Note

This method does not do validation for optimization purposes. Validation should be done from before and ideally with ExtendedHeader::decode_and_validate.

Errors

If verification fails, this function will return an error with a reason of failure. This function will also return an error if untrusted headers and self don’t form contiguous range

Example

let genesis_header = trusted_genesis();
let next_headers = get_headers_range(5..50);

// fails, not adjacent to genesis
assert!(genesis_header.verify_adjacent_range(&next_headers).is_err());

let next_headers = get_headers_range(2..50);

// succeeds
genesis_header.verify_adjacent_range(&next_headers).unwrap();

Trait Implementations

impl Clone for ExtendedHeader

fn clone(&self) -> ExtendedHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExtendedHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExtendedHeader

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExtendedHeader

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

Formats the value using the given formatter.

impl From<ExtendedHeader> for ExtendedHeader

fn from(value: ExtendedHeader) -> RawExtendedHeader

Converts to this type from the input type.

impl PartialEq for ExtendedHeader

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

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) -> Vec<u8>

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) -> Vec<u8>

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 ExtendedHeader

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<ExtendedHeader> for ExtendedHeader

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for ExtendedHeader

impl StructuralPartialEq for ExtendedHeader