Struct Proof

pub struct Proof {
    pub edge_bits: u8,
    pub nonces: Vec<u64>,
}

A Cuck(at)oo Cycle proof of work, consisting of the edge_bits to get the graph size (i.e. the 2-log of the number of edges) and the nonces of the graph solution. While being expressed as u64 for simplicity, nonces a.k.a. edge indices range from 0 to (1 << edge_bits) - 1

The hash of the Proof is the hash of its packed nonces when serializing them at their exact bit size. The resulting bit sequence is padded to be byte-aligned. We form a PROOFSIZE*edge_bits integer by packing the PROOFSIZE edge indices together, with edge index i occupying bits i * edge_bits through (i+1) * edge_bits - 1, padding it with up to 7 0-bits to a multiple of 8 bits, writing as a little endian byte array, and hashing with blake2b using 256 bit digest.

Fields

edge_bits: u8

Power of 2 used for the size of the cuckoo graph

nonces: Vec<u64>

The nonces

Implementations

impl Proof

pub fn new(in_nonces: Vec<u64>) -> Proof

Builds a proof with provided nonces at default edge_bits

pub fn zero(proof_size: usize) -> Proof

Builds a proof with all bytes zeroed out

pub fn pack_len(bit_width: u8) -> usize

Number of bytes required store a proof of given edge bits

pub fn random(proof_size: usize) -> Proof

Builds a proof with random POW data, needed so that tests that ignore POW don’t fail due to duplicate hashes

pub fn proof_size(&self) -> usize

Returns the proof size

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

Pack the nonces of the proof to their exact bit size as described above

Trait Implementations

impl Clone for Proof

fn clone(&self) -> Proof

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Proof

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

Formats the value using the given formatter.

impl PartialEq for Proof

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

fn partial_cmp(&self, other: &Proof) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Readable for Proof

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

Reads the data necessary to this Readable from the provided reader

impl Serialize for Proof

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 Proof

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

Write the data held by this Writeable to the provided writer

impl DefaultHashable for Proof

impl Eq for Proof

impl StructuralPartialEq for Proof