subspace_proof_of_space/
chiapos.rs

1//! Chia proof of space reimplementation in Rust
2
3mod constants;
4mod table;
5mod tables;
6mod utils;
7
8use crate::chiapos::table::metadata_size_bytes;
9pub use crate::chiapos::table::TablesCache;
10use crate::chiapos::tables::TablesGeneric;
11use crate::chiapos::utils::EvaluatableUsize;
12
13type Seed = [u8; 32];
14type Challenge = [u8; 32];
15type Quality = [u8; 32];
16
17/// Collection of Chia tables
18#[derive(Debug)]
19pub struct Tables<const K: u8>(TablesGeneric<K>)
20where
21    EvaluatableUsize<{ metadata_size_bytes(K, 1) }>: Sized,
22    EvaluatableUsize<{ metadata_size_bytes(K, 2) }>: Sized,
23    EvaluatableUsize<{ metadata_size_bytes(K, 3) }>: Sized,
24    EvaluatableUsize<{ metadata_size_bytes(K, 4) }>: Sized,
25    EvaluatableUsize<{ metadata_size_bytes(K, 5) }>: Sized,
26    EvaluatableUsize<{ metadata_size_bytes(K, 6) }>: Sized,
27    EvaluatableUsize<{ metadata_size_bytes(K, 7) }>: Sized;
28
29macro_rules! impl_any {
30    ($($k: expr$(,)? )*) => {
31        $(
32impl Tables<$k> {
33    /// Create Chia proof of space tables. There also exists [`Self::create_parallel()`] that trades
34    /// CPU efficiency and memory usage for lower latency.
35    ///
36    /// Advanced version of [`Self::create_simple`] that allows to reuse cache.
37    pub fn create(seed: Seed, cache: &mut TablesCache<$k>) -> Self {
38        Self(TablesGeneric::<$k>::create(
39            seed, cache,
40        ))
41    }
42
43    /// Almost the same as [`Self::create()`], but uses parallelism internally for better
44    /// performance (though not efficiency of CPU and memory usage), if you create multiple tables
45    /// in parallel, prefer [`Self::create()`] for better overall performance.
46    #[cfg(any(feature = "parallel", test))]
47    pub fn create_parallel(seed: Seed, cache: &mut TablesCache<$k>) -> Self {
48        Self(TablesGeneric::<$k>::create_parallel(
49            seed, cache,
50        ))
51    }
52
53    /// Create Chia proof of space tables.
54    ///
55    /// Simpler version of [`Self::create`].
56    pub fn create_simple(seed: Seed) -> Self {
57        Self::create(seed, &mut TablesCache::default())
58    }
59
60    /// Find proof of space quality for given challenge.
61    pub fn find_quality<'a>(
62        &'a self,
63        challenge: &'a Challenge,
64    ) -> impl Iterator<Item = Quality> + 'a {
65        self.0.find_quality(challenge)
66    }
67
68    /// Find proof of space for given challenge.
69    pub fn find_proof<'a>(
70        &'a self,
71        challenge: &'a Challenge,
72    ) -> impl Iterator<Item = [u8; 64 * $k / 8]> + 'a {
73        self.0.find_proof(challenge)
74    }
75
76    /// Verify proof of space for given seed and challenge.
77    pub fn verify(
78        seed: Seed,
79        challenge: &Challenge,
80        proof_of_space: &[u8; 64 * $k as usize / 8],
81    ) -> Option<Quality> {
82        TablesGeneric::<$k>::verify(seed, challenge, proof_of_space)
83    }
84}
85        )*
86    }
87}
88
89// Only these k values are supported by current implementation
90impl_any!(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25);