Struct grin_core::pow::ProofOfWork

pub struct ProofOfWork {
    pub total_difficulty: Difficulty,
    pub secondary_scaling: u32,
    pub nonce: u64,
    pub proof: Proof,
}

Block header information pertaining to the proof of work

Fields

total_difficulty: Difficulty

Total accumulated difficulty since genesis block

secondary_scaling: u32

Variable difficulty scaling factor fo secondary proof of work After HardFork4, which obsoletes secondary PoW, this effectively becomes 4 more bytes of nonce. might be repurposed in future.

nonce: u64

Nonce increment used to mine this block.

proof: Proof

Proof of work data.

Implementations

impl ProofOfWork

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

Write the pre-hash portion of the header

pub fn to_difficulty(&self, height: u64) -> Difficulty

Maximum difficulty this proof of work can achieve

pub fn to_unscaled_difficulty(&self) -> Difficulty

Maximum unscaled difficulty this proof of work can achieve

pub fn edge_bits(&self) -> u8

The edge_bits used for the cuckoo cycle size on this proof

pub fn is_primary(&self) -> bool

Whether this proof of work is for the primary algorithm (as opposed to secondary). Only depends on the edge_bits at this time.

pub fn is_secondary(&self) -> bool

Whether this proof of work is for the secondary algorithm (as opposed to primary). Only depends on the edge_bits at this time.

Trait Implementations

impl Clone for ProofOfWork

fn clone(&self) -> ProofOfWork

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProofOfWork

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

Formats the value using the given formatter.

impl Default for ProofOfWork

fn default() -> ProofOfWork

Returns the “default value” for a type.

impl PartialEq for ProofOfWork

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

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

Reads the data necessary to this Readable from the provided reader

impl Serialize for ProofOfWork

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 ProofOfWork

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

Write the data held by this Writeable to the provided writer

impl StructuralPartialEq for ProofOfWork