Restore tests in vrf::threshold

Author: sebastiencs

node/common/src/service/block_producer/vrf_evaluator.rs

@@ -78,3 +78,70 @@ impl node::block_producer_effectful::vrf_evaluator_effectful::BlockProducerVrfEv
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    // use mina_signer::keypair;
+    use node::account::AccountSecretKey;
+
+    use super::*;
+
+    #[test]
+    #[ignore]
+    fn test_vrf() {
+        let json = std::fs::read_to_string("/tmp/vrf.json").unwrap();
+        let vrf_evaluator_input: VrfEvaluatorInput = serde_json::from_str(&json).unwrap();
+
+        let private = "SOME_KEY";
+        let private = AccountSecretKey::from_str(private).unwrap();
+        let keypair: Keypair = private.into();
+
+        let VrfEvaluatorInput {
+            epoch_seed,
+            delegator_table,
+            global_slot,
+            total_currency,
+            staking_ledger_hash: _,
+        } = &vrf_evaluator_input;
+
+        let now = std::time::Instant::now();
+
+        let vrf_result = delegator_table
+            .par_iter()
+            .map(|(index, (pub_key, stake))| {
+                let vrf_input = VrfEvaluationInput {
+                    producer_key: keypair.clone(),
+                    global_slot: *global_slot,
+                    epoch_seed: epoch_seed.clone(),
+                    account_pub_key: pub_key.clone(),
+                    delegator_index: *index,
+                    delegated_stake: (*stake).into(),
+                    total_currency: (*total_currency).into(),
+                };
+                // let now = redux::Instant::now();
+                let vrf_result = vrf::evaluate_vrf(vrf_input).unwrap();
+                // let elapsed = now.elapsed();
+                // let slot = global_slot;
+                // eprintln!("vrf::evaluate_vrf: {elapsed:?} slot:{slot:?} index:{index:?}");
+                // openmina_core::info!(openmina_core::log::system_time(); "vrf::evaluate_vrf: {elapsed:?} slot:{slot:?} index:{index:?}");
+
+                // nevaluated.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
+
+                // the first delegate that won the slot
+                if let VrfEvaluationOutput::SlotWon(_) = vrf_result {
+                    return Some(vrf_result);
+                }
+                None
+            })
+            .collect::<Vec<_>>();
+
+        let elapsed = now.elapsed();
+        let slot = vrf_evaluator_input.global_slot;
+        let ndelegator = vrf_evaluator_input.delegator_table.len();
+        // let nevaluated = nevaluated.load(std::sync::atomic::Ordering::Relaxed);
+        eprintln!("TOTAL vrf::evaluate_vrf: {elapsed:?} slot:{slot:?} ndelegators:{ndelegator:?}");
+        dbg!(vrf_result);
+    }
+}

vrf/src/threshold.rs

@@ -216,89 +216,89 @@ pub fn bigrational_as_fixed_point<const N: usize>(
 //     Threshold::new(delegated_stake, total_currency).threshold_met(vrf_out)
 // }
 
-// #[cfg(test)]
-// mod test {
-//     use std::str::FromStr;
-
-//     use ark_ff::{One, Zero};
-//     use num::{BigInt, BigRational, ToPrimitive};
-
-//     use super::*;
-
-//     // TODO: move to regular fns, rework step
-//     fn first_non_zero(stake: BigInt, total_currency: BigInt, step: BigInt) -> BigInt {
-//         let ten = BigInt::from_str("10").unwrap();
-//         let mut stake = stake;
-//         if step == BigInt::zero() {
-//             stake + BigInt::one()
-//         } else {
-//             loop {
-//                 let thrs = Threshold::new(stake.to_digits(), total_currency.to_digits());
-
-//                 if thrs.threshold_rational != BigRational::zero() {
-//                     println!("stake: {stake} nanoMINA");
-//                     return first_non_zero(stake - step.clone(), total_currency, step / ten);
-//                 }
-//                 stake += step.clone();
-//             }
-//         }
-//     }
-
-//     #[test]
-//     #[ignore]
-//     fn test_threshold_nonzero() {
-//         // let total_currency = BigInt::from_str("1157953132840039233").unwrap();
-//         // let initial_stake = BigInt::zero();
-//         // let initial_step = BigInt::from_str("10000000000000000000").unwrap();
-
-//         let total_currency = BigInt::from_str("1025422352000001000").unwrap();
-//         let initial_stake = BigInt::zero();
-//         let initial_step = BigInt::from_str("10000000000000000000").unwrap();
-
-//         let first_non_zero_nanomina =
-//             first_non_zero(initial_stake, total_currency.clone(), initial_step);
-
-//         let last_zero = first_non_zero_nanomina.clone() - BigInt::one();
-
-//         let thrs_zero = Threshold::new(last_zero, total_currency.clone());
-//         assert_eq!(thrs_zero.threshold_rational, BigRational::zero());
-
-//         let thrs_first = Threshold::new(first_non_zero_nanomina.clone(), total_currency);
-//         assert!(thrs_first.threshold_rational > BigRational::zero());
-
-//         let first_non_zero_mina = first_non_zero_nanomina.to_f64().unwrap() / 1_000_000_000.0;
-
-//         println!("First non zero stake: {first_non_zero_mina} MINA");
-//         println!(
-//             "First non zero threshold: {}",
-//             thrs_first.threshold_rational.to_f64().unwrap()
-//         );
-//     }
-
-//     #[test]
-//     #[ignore]
-//     fn test_threshold_increase() {
-//         // let total_currency = BigInt::from_str("1157953132840039233").unwrap();
-//         // let mut stake_nanomina = BigInt::from_str("1104310162392").unwrap();
-//         // let mut step = BigInt::from_str("1000000000000").unwrap();
-
-//         let total_currency = BigInt::from_str("1025422352000001000").unwrap();
-//         let mut stake_nanomina = BigInt::from_str("2000000000000000").unwrap();
-//         let mut step = BigInt::from_str("1000000000000").unwrap();
-
-//         loop {
-//             if stake_nanomina > total_currency {
-//                 break;
-//             }
-//             let thrs = Threshold::new(stake_nanomina.clone(), total_currency.clone());
-//             let stake_mina = stake_nanomina.to_f64().unwrap() / 1_000_000_000.0;
-//             println!(
-//                 "stake: {stake_mina} MINA - threshold: {}",
-//                 thrs.threshold_rational.to_f64().unwrap()
-//             );
-
-//             stake_nanomina += step.clone();
-//             step *= 2;
-//         }
-//     }
-// }
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use ark_ff::{One, Zero};
+    use num::{BigInt, BigRational, ToPrimitive};
+
+    use super::*;
+
+    // TODO: move to regular fns, rework step
+    fn first_non_zero(stake: BigInt, total_currency: BigInt, step: BigInt) -> BigInt {
+        let ten = BigInt::from_str("10").unwrap();
+        let mut stake = stake;
+        if step == BigInt::zero() {
+            stake + BigInt::one()
+        } else {
+            loop {
+                let thrs = Threshold::new(stake.clone(), total_currency.clone());
+
+                if thrs.threshold_rational != BigRational::zero() {
+                    println!("stake: {stake} nanoMINA");
+                    return first_non_zero(stake - step.clone(), total_currency, step / ten);
+                }
+                stake += step.clone();
+            }
+        }
+    }
+
+    #[test]
+    #[ignore]
+    fn test_threshold_nonzero() {
+        // let total_currency = BigInt::from_str("1157953132840039233").unwrap();
+        // let initial_stake = BigInt::zero();
+        // let initial_step = BigInt::from_str("10000000000000000000").unwrap();
+
+        let total_currency = BigInt::from_str("1025422352000001000").unwrap();
+        let initial_stake = BigInt::zero();
+        let initial_step = BigInt::from_str("10000000000000000000").unwrap();
+
+        let first_non_zero_nanomina =
+            first_non_zero(initial_stake, total_currency.clone(), initial_step);
+
+        let last_zero = first_non_zero_nanomina.clone() - BigInt::one();
+
+        let thrs_zero = Threshold::new(last_zero, total_currency.clone());
+        assert_eq!(thrs_zero.threshold_rational, BigRational::zero());
+
+        let thrs_first = Threshold::new(first_non_zero_nanomina.clone(), total_currency);
+        assert!(thrs_first.threshold_rational > BigRational::zero());
+
+        let first_non_zero_mina = first_non_zero_nanomina.to_f64().unwrap() / 1_000_000_000.0;
+
+        println!("First non zero stake: {first_non_zero_mina} MINA");
+        println!(
+            "First non zero threshold: {}",
+            thrs_first.threshold_rational.to_f64().unwrap()
+        );
+    }
+
+    #[test]
+    #[ignore]
+    fn test_threshold_increase() {
+        // let total_currency = BigInt::from_str("1157953132840039233").unwrap();
+        // let mut stake_nanomina = BigInt::from_str("1104310162392").unwrap();
+        // let mut step = BigInt::from_str("1000000000000").unwrap();
+
+        let total_currency = BigInt::from_str("1025422352000001000").unwrap();
+        let mut stake_nanomina = BigInt::from_str("2000000000000000").unwrap();
+        let mut step = BigInt::from_str("1000000000000").unwrap();
+
+        loop {
+            if stake_nanomina > total_currency {
+                break;
+            }
+            let thrs = Threshold::new(stake_nanomina.clone(), total_currency.clone());
+            let stake_mina = stake_nanomina.to_f64().unwrap() / 1_000_000_000.0;
+            println!(
+                "stake: {stake_mina} MINA - threshold: {}",
+                thrs.threshold_rational.to_f64().unwrap()
+            );
+
+            stake_nanomina += step.clone();
+            step *= 2;
+        }
+    }
+}