Struct zebra_chain::block::Header

pub struct Header {
    pub version: u32,
    pub previous_block_hash: Hash,
    pub merkle_root: Root,
    pub commitment_bytes: HexDebug<[u8; 32]>,
    pub time: DateTime<Utc>,
    pub difficulty_threshold: CompactDifficulty,
    pub nonce: HexDebug<[u8; 32]>,
    pub solution: Solution,
}

A block header, containing metadata about a block.

How are blocks chained together? They are chained together via the backwards reference (previous header hash) present in the block header. Each block points backwards to its parent, all the way back to the genesis block (the first block in the blockchain).

Fields

version: u32

The block’s version field. This is supposed to be 4:

The current and only defined block version number for Zcash is 4.

but this was not enforced by the consensus rules, and defective mining software created blocks with other versions, so instead it’s effectively a free field. The only constraint is that it must be at least 4 when interpreted as an i32.

previous_block_hash: Hash

The hash of the previous block, used to create a chain of blocks back to the genesis block.

This ensures no previous block can be changed without also changing this block’s header.

merkle_root: Root

The root of the Bitcoin-inherited transaction Merkle tree, binding the block header to the transactions in the block.

Note that because of a flaw in Bitcoin’s design, the merkle_root does not always precisely bind the contents of the block (CVE-2012-2459). It is sometimes possible for an attacker to create multiple distinct sets of transactions with the same Merkle root, although only one set will be valid.

commitment_bytes: HexDebug<[u8; 32]>

Zcash blocks contain different kinds of commitments to their contents, depending on the network and height.

The interpretation of this field has been changed multiple times, without incrementing the block version. Therefore, this field cannot be parsed without the network and height. Use Block::commitment to get the parsed Commitment.

time: DateTime<Utc>

The block timestamp is a Unix epoch time (UTC) when the miner started hashing the header (according to the miner).

difficulty_threshold: CompactDifficulty

An encoded version of the target threshold this block’s header hash must be less than or equal to, in the same nBits format used by Bitcoin.

For a block at block height height, bits MUST be equal to ThresholdBits(height).

Bitcoin-nBits

nonce: HexDebug<[u8; 32]>

An arbitrary field that miners can change to modify the header hash in order to produce a hash less than or equal to the target threshold.

solution: Solution

The Equihash solution.

Implementations

impl Header

pub fn time_is_valid_at( &self, now: DateTime<Utc>, height: &Height, hash: &Hash, ) -> Result<(), BlockTimeError>

TODO: Inline this function into zebra_consensus::block::check::time_is_valid_at. See https://github.com/ZcashFoundation/zebra/issues/1021 for more details.

pub fn hash(&self) -> Hash

Compute the hash of this header.

Trait Implementations

impl Arbitrary for Header

type Parameters = LedgerState

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(ledger_state: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

type Strategy = BoxedStrategy<Header>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for Header

fn clone(&self) -> Header

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Header

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Header

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a Header> for Hash

fn from(block_header: &'a Header) -> Self

Converts to this type from the input type.

impl From<Header> for Hash

fn from(block_header: Header) -> Self

Converts to this type from the input type.

impl PartialEq for Header

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ZcashDeserialize for Header

fn zcash_deserialize<R: Read>(reader: R) -> Result<Self, SerializationError>

Try to read self from the given reader.

impl ZcashSerialize for Header

fn zcash_serialize<W: Write>(&self, writer: W) -> Result<(), Error>

Write self to the given writer using the canonical format.

fn zcash_serialize_to_vec(&self) -> Result<Vec<u8>, Error>

Helper function to construct a vec to serialize the current struct into

fn zcash_serialized_size(&self) -> usize

Get the size of self by using a fake writer.

impl Copy for Header

impl Eq for Header

impl StructuralPartialEq for Header