Struct grin_core::pow::cuckatoo::CuckatooContext

pub struct CuckatooContext<T> where
    T: EdgeType,  { /* fields omitted */ }

Cuckatoo solver context

Methods

impl<T> CuckatooContext<T> where
    T: EdgeType, 

pub fn new_impl(
    edge_bits: u8,
    proof_size: usize,
    max_sols: u32
) -> Result<CuckatooContext<T>, Error>

New Solver context

pub fn sipkey_hex(&self, index: usize) -> Result<String, Error>

Get a siphash key as a hex string (for display convenience)

pub fn byte_count(&self) -> Result<u64, Error>

Return number of bytes used by the graph

pub fn set_header_nonce_impl(
    &mut self,
    header: Vec<u8>,
    nonce: Option<u32>,
    solve: bool
) -> Result<(), Error>

Set the header and optional nonce in the last part of the header

pub fn sipnode(&self, edge: T, uorv: u64) -> Result<T, Error>

Return siphash masked for type

pub fn find_cycles_iter<I>(&mut self, iter: I) -> Result<Vec<Proof>, Error> where
    I: Iterator<Item = u64>, 

Simple implementation of algorithm

pub fn verify_impl(&self, proof: &Proof) -> Result<(), Error>

Verify that given edges are ascending and form a cycle in a header-generated graph

Trait Implementations

impl<T> PoWContext<T> for CuckatooContext<T> where
    T: EdgeType, 

fn set_header_nonce(
    &mut self,
    header: Vec<u8>,
    nonce: Option<u32>,
    solve: bool
) -> Result<(), Error>

Sets the header along with an optional nonce at the end solve: whether to set up structures for a solve (true) or just validate (false)

fn find_cycles(&mut self) -> Result<Vec<Proof>, Error>

find solutions using the stored parameters and header

fn verify(&self, proof: &Proof) -> Result<(), Error>

Verify a solution with the stored parameters