reference.rs - iuna - iuna - experimental mainnet-candidate protocol

reference.rs (1418B)
      1 use kyn_vdf::{Form, KynVdfError, create_discriminant, get_b};
      2 use num_bigint::BigUint;
      3 use num_traits::One;
      4 
      5 use super::wesolowski::{DISCRIMINANT_BITS, serialize_solution};
      6 
      7 fn prove(seed: &[u8], rounds: u64) -> Result<Vec<u8>, KynVdfError> {
      8     if rounds == 0 {
      9         return Err(KynVdfError::InvalidIterations(rounds));
     10     }
     11     let shift = usize::try_from(rounds).map_err(|_| KynVdfError::InvalidIterations(rounds))?;
     12     let discriminant = create_discriminant(seed, DISCRIMINANT_BITS)?;
     13     let generator =
     14         Form::generator(&discriminant).ok_or(KynVdfError::InvalidDiscriminantIdentity)?;
     15     let exponent = BigUint::one() << shift;
     16     let output = generator.pow(&exponent, &discriminant);
     17     let challenge = get_b(&discriminant, &generator, &output)?;
     18     let quotient = &exponent / challenge;
     19     let proof = generator.pow(&quotient, &discriminant);
     20     serialize_solution(&output, &proof)
     21 }
     22 
     23 #[cfg(test)]
     24 mod tests {
     25     use super::prove as reference_prove;
     26     use crate::domain::vdf::wesolowski::prove;
     27 
     28     #[test]
     29     fn sequential_prover_matches_independent_exponent_oracle() {
     30         for rounds in [1, 2, 16, 100, 300] {
     31             let sequential = prove(b"iuna-vdf-reference-oracle", rounds, |_, _| {}).unwrap();
     32             let reference = reference_prove(b"iuna-vdf-reference-oracle", rounds).unwrap();
     33 
     34             assert_eq!(sequential, reference, "rounds={rounds}");
     35         }
     36     }
     37 }