Struct grin_core::core::block::BlockHeader

pub struct BlockHeader {
    pub version: HeaderVersion,
    pub height: u64,
    pub prev_hash: Hash,
    pub prev_root: Hash,
    pub timestamp: DateTime<Utc>,
    pub output_root: Hash,
    pub range_proof_root: Hash,
    pub kernel_root: Hash,
    pub total_kernel_offset: BlindingFactor,
    pub output_mmr_size: u64,
    pub kernel_mmr_size: u64,
    pub pow: ProofOfWork,
}

Block header, fairly standard compared to other blockchains.

Fields

version: HeaderVersion

Version of the block

height: u64

Height of this block since the genesis block (height 0)

prev_hash: Hash

Hash of the block previous to this in the chain.

prev_root: Hash

Root hash of the header MMR at the previous header.

timestamp: DateTime<Utc>

Timestamp at which the block was built.

output_root: Hash

Merklish root of all the commitments in the TxHashSet

range_proof_root: Hash

Merklish root of all range proofs in the TxHashSet

kernel_root: Hash

Merklish root of all transaction kernels in the TxHashSet

total_kernel_offset: BlindingFactor

Total accumulated sum of kernel offsets since genesis block. We can derive the kernel offset sum for this block from the total kernel offset of the previous block header.

output_mmr_size: u64

Total size of the output MMR after applying this block

kernel_mmr_size: u64

Total size of the kernel MMR after applying this block

pow: ProofOfWork

Proof of work and related

Implementations

impl BlockHeader

pub fn write_pre_pow<W: Writer>(&self, writer: &mut W) -> Result<(), Error>

Write the pre-hash portion of the header

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

Return the pre-pow, unhashed Let the cuck(at)oo miner/verifier handle the hashing for consistency with how this call is performed everywhere else

pub fn from_pre_pow_and_proof( pre_pow: String, nonce: u64, proof: Proof ) -> Result<Self, Error>

Constructs a header given pre_pow string, nonce, and proof

pub fn output_mmr_count(&self) -> u64

Total number of outputs (spent and unspent) based on output MMR size committed to in this block. Note: Not the number of outputs in this block but total up to and including this block. The MMR size is the total number of hashes contained in the full MMR structure. We want the corresponding number of leaves in the MMR given the size.

pub fn kernel_mmr_count(&self) -> u64

Total number of kernels based on kernel MMR size committed to in this block. Note: Not the number of kernels in this block but total up to and including this block. The MMR size is the total number of hashes contained in the full MMR structure. We want the corresponding number of leaves in the MMR given the size.

pub fn total_difficulty(&self) -> Difficulty

Total difficulty accumulated by the proof of work on this header

pub fn overage(&self) -> i64

The “overage” to use when verifying the kernel sums. For a block header the overage is 0 - reward.

pub fn total_overage(&self, genesis_had_reward: bool) -> i64

The “total overage” to use when verifying the kernel sums for a full chain state. For a full chain state this is 0 - (height * reward).

pub fn total_kernel_offset(&self) -> BlindingFactor

Total kernel offset for the chain state up to and including this block.

Trait Implementations

impl Clone for BlockHeader

fn clone(&self) -> BlockHeader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BlockHeader

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

Formats the value using the given formatter.

impl Default for BlockHeader

fn default() -> BlockHeader

Returns the “default value” for a type.

impl From<UntrustedBlockHeader> for BlockHeader

fn from(header: UntrustedBlockHeader) -> Self

Converts to this type from the input type.

impl PMMRable for BlockHeader

type E = HeaderEntry

The type of element actually stored in the MMR data file. This allows us to store Hash elements in the header MMR for variable size BlockHeaders.

fn as_elmt(&self) -> Self::E

Convert the pmmrable into the element to be stored in the MMR data file.

fn elmt_size() -> Option<u16>

Size of each element if “fixed” size. Elements are “variable” size if None.

impl PartialEq for BlockHeader

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

Deserialization of a block header

fn read<R: Reader>(reader: &mut R) -> Result<BlockHeader, Error>

Reads the data necessary to this Readable from the provided reader

impl Serialize for BlockHeader

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Writeable for BlockHeader

Serialization of a block header

fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>

Write the data held by this Writeable to the provided writer

impl DefaultHashable for BlockHeader

impl StructuralPartialEq for BlockHeader