Struct Tables 

pub struct Tables<const K: u8>
where
    Self: Supported,
    EvaluatableUsize<{ _ }>: Sized,
    [(); { _ }]:,
{ /* private fields */ }

Collection of Chia tables

Implementations

impl<const K: u8> Tables<K>

where Self: Supported, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, EvaluatableUsize<{ _ }>: Sized, [(); { _ }]:,

pub fn create(seed: [u8; 32], cache: &TablesCache) -> Self

Create Chia proof of space tables.

There is also Self::create_parallel() that can achieve higher performance and lower latency at the cost of lower CPU efficiency and higher memory usage.

pub fn create_proofs(seed: [u8; 32], cache: &TablesCache) -> Box<Proofs<K>>

where [(); { _ }]:,

Create proofs.

This is an optimized combination of Self::create() and Self::find_proof().

There is also Self::create_proofs_parallel() that can achieve higher performance and lower latency at the cost of lower CPU efficiency and higher memory usage.

pub fn create_parallel(seed: [u8; 32], cache: &TablesCache) -> Self

Almost the same as Self::create(), but uses parallelism internally for better performance and lower latency at the cost of lower CPU efficiency and higher memory usage

pub fn create_proofs_parallel( seed: [u8; 32], cache: &TablesCache, ) -> Box<Proofs<K>>

where [(); { _ }]:,

Almost the same as Self::create_proofs(), but uses parallelism internally for better performance and lower latency at the cost of lower CPU efficiency and higher memory usage

pub fn find_quality<'a>( &'a self, challenge: &'a [u8; 32], ) -> impl Iterator<Item = [u8; 32]> + 'a

Find proof of space quality for a given challenge

pub fn find_proof_raw<'a>( &'a self, first_k_challenge_bits: u32, ) -> impl Iterator<Item = [u8; { _ }]> + 'a

Similar to Self::find_proof(), but takes the first k challenge bits in the least significant bits of u32 as a challenge instead

pub fn find_proof<'a>( &'a self, first_challenge_bytes: [u8; 4], ) -> impl Iterator<Item = [u8; { _ }]> + 'a

Find proof of space for a given challenge

pub fn verify_only_raw( seed: &[u8; 32], first_k_challenge_bits: u32, proof_of_space: &[u8; { _ }], ) -> bool

Similar to Self::verify(), but takes the first k challenge bits in the least significant bits of u32 as a challenge instead and doesn’t compute quality

pub fn verify( seed: &[u8; 32], challenge: &[u8; 32], proof_of_space: &[u8; { _ }], ) -> Option<[u8; 32]>

where EvaluatableUsize<{ _ }>: Sized,

Verify proof of space for a given seed and challenge

Trait Implementations

impl<const K: u8> Debug for Tables<K>

where Self: Supported, EvaluatableUsize<{ _ }>: Sized, [(); { _ }]:,

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

Formats the value using the given formatter.