chaincraft 0.3.2

A high-performance Rust-based platform for blockchain education and prototyping
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Verifiable Delay Function implementation
//!
//! Uses the `vdf` crate (Pietrzak/Wesolowski) when feature `vdf-crypto` is enabled.
//! Requires GMP: `apt-get install libgmp-dev` or `dnf install gmp-devel`.

use crate::error::{ChaincraftError, Result};

/// Verifiable Delay Function wrapper
#[derive(Debug, Clone)]
pub struct VerifiableDelayFunction {
    num_bits: u16,
}

impl VerifiableDelayFunction {
    pub fn new() -> Self {
        Self::with_bits(2048)
    }

    pub fn with_bits(num_bits: u16) -> Self {
        Self { num_bits }
    }

    /// Solve the VDF: compute output for challenge after `iterations` steps
    pub fn solve(&self, challenge: &[u8], iterations: u64) -> Result<Vec<u8>> {
        #[cfg(feature = "vdf-crypto")]
        {
            use vdf::{PietrzakVDFParams, VDFParams, VDF};
            let vdf = PietrzakVDFParams(self.num_bits).new();
            vdf.solve(challenge, iterations).map_err(|e| {
                ChaincraftError::Crypto(crate::error::CryptoError::VdfError {
                    reason: format!("{e:?}"),
                })
            })
        }
        #[cfg(not(feature = "vdf-crypto"))]
        {
            let _ = (challenge, iterations);
            Err(ChaincraftError::Crypto(crate::error::CryptoError::VdfError {
                reason: "VDF requires feature 'vdf-crypto'. Enable with: chaincraft = { version = \"..\", features = [\"vdf-crypto\"] }".to_string(),
            }))
        }
    }

    /// Verify a VDF solution
    pub fn verify(&self, challenge: &[u8], iterations: u64, solution: &[u8]) -> Result<bool> {
        #[cfg(feature = "vdf-crypto")]
        {
            use vdf::{PietrzakVDFParams, VDFParams, VDF};
            let vdf = PietrzakVDFParams(self.num_bits).new();
            vdf.verify(challenge, iterations, solution)
                .map(|_| true)
                .map_err(|e| {
                    ChaincraftError::Crypto(crate::error::CryptoError::VdfError {
                        reason: format!("{e:?}"),
                    })
                })
        }
        #[cfg(not(feature = "vdf-crypto"))]
        {
            let _ = (challenge, iterations, solution);
            Err(ChaincraftError::Crypto(crate::error::CryptoError::VdfError {
                reason: "VDF requires feature 'vdf-crypto'".to_string(),
            }))
        }
    }
}

impl Default for VerifiableDelayFunction {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg(not(feature = "vdf-crypto"))]
    #[test]
    fn test_vdf_without_feature_returns_error() {
        let vdf = VerifiableDelayFunction::new();
        let err = vdf.solve(b"challenge", 10);
        assert!(err.is_err());
        assert!(err.unwrap_err().to_string().contains("vdf-crypto"));
    }

    #[cfg(feature = "vdf-crypto")]
    #[test]
    fn test_vdf_solve_and_verify() {
        let vdf = VerifiableDelayFunction::with_bits(1024);
        let challenge = b"test";
        let iterations = 66u64; // Pietrzak requires at least 66 iterations
        let solution = vdf.solve(challenge, iterations).expect("solve");
        assert!(!solution.is_empty());
        assert!(vdf.verify(challenge, iterations, &solution).unwrap());
    }
}