Struct RawBlockHeader 

pub struct RawBlockHeader {

    pub miner_address: Address,
    pub ticket: Option<Ticket>,
    pub election_proof: Option<ElectionProof>,
    pub beacon_entries: Vec<BeaconEntry>,
    pub winning_post_proof: Vec<PoStProof>,
    pub parents: TipsetKey,
    pub weight: BigInt,
    pub epoch: i64,
    pub state_root: Cid,
    pub message_receipts: Cid,
    pub messages: Cid,
    pub bls_aggregate: Option<Signature>,
    pub timestamp: u64,
    pub signature: Option<Signature>,
    pub fork_signal: u64,
    pub parent_base_fee: TokenAmount,
}

Fields

miner_address: Address

The address of the miner actor that mined this block

ticket: Option<Ticket>

election_proof: Option<ElectionProof>

beacon_entries: Vec<BeaconEntry>

The verifiable oracle randomness used to elect this block’s author leader

winning_post_proof: Vec<PoStProof>

parents: TipsetKey

The set of parents this block was based on. Typically one, but can be several in the case where there were multiple winning ticket-holders for an epoch

weight: BigInt

The aggregate chain weight of the parent set

epoch: i64

The period in which a new block is generated. There may be multiple rounds in an epoch.

state_root: Cid

The CID of the parent state root after calculating parent tipset.

message_receipts: Cid

The CID of the root of an array of MessageReceipts

messages: Cid

The CID of the Merkle links for bls_messages and secp_messages

bls_aggregate: Option<Signature>

Aggregate signature of miner in block

timestamp: u64

Block creation time, in seconds since the Unix epoch

signature: Option<Signature>

fork_signal: u64

parent_base_fee: TokenAmount

The base fee of the parent block

Implementations

impl RawBlockHeader

pub fn cid(&self) -> Cid

pub fn car_block(&self) -> Result<(Cid, Vec<u8>)>

pub(super) fn tipset_sort_key(&self) -> Option<([u8; 32], Vec<u8>)>

pub fn verify_signature_against(&self, addr: &Address) -> Result<(), Error>

Check to ensure block signature is valid

pub fn validate_block_drand( &self, network_version: NetworkVersion, b_schedule: &BeaconSchedule, parent_epoch: i64, prev_entry: &BeaconEntry, ) -> Result<(), Error>

Validates if the current header’s Beacon entries are valid to ensure randomness was generated correctly

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

Serializes the header to bytes for signing purposes i.e. without the signature field

pub fn is_within_clock_drift(&self) -> bool

If the block timestamp is within the allowable clock drift

Trait Implementations

impl Clone for RawBlockHeader

fn clone(&self) -> RawBlockHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawBlockHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawBlockHeader

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CachingBlockHeader> for RawBlockHeader

fn from(value: CachingBlockHeader) -> Self

Converts to this type from the input type.

impl From<RawBlockHeader> for CachingBlockHeader

fn from(value: RawBlockHeader) -> Self

Converts to this type from the input type.

impl From<RawBlockHeader> for Tipset

fn from(value: RawBlockHeader) -> Self

Converts to this type from the input type.

impl GetSize for RawBlockHeader

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_heap_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.

impl Hash for RawBlockHeader

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RawBlockHeader

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RawBlockHeader

impl StructuralPartialEq for RawBlockHeader