chore: added deterministic tests for keygen

chore: added support for refresh and reshare

chore: added eddsa and ckd support

feat: add support for ecdsa

feat: make all tests deterministic

fix: address nits

feat: do determinism tests independently, use cargo-insta

fix: minor after rebase

fix: rebase fixes

fix: minor

Author: gilcu3

Cargo.lock

@@ -58,6 +58,7 @@ test-utils = ["rand", "rand_chacha"]
 [dev-dependencies]
 criterion = {version = "0.7.0", features = ["html_reports"]}
 bincode = { version = "2.0.1", features = ["serde"] }
+insta = { version = "1.43.1", features = ["json", "redactions"] }
 rand = { version = "0.8.5"}
 rand_core = { version = "0.6.4", features = ["getrandom"]}
 threshold-signatures = { path = ".", features = ["test-utils"] }

Cargo.toml

@@ -2,18 +2,19 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use frost_core::{Field, Group};
 use frost_secp256k1::{Secp256K1ScalarField, Secp256K1Sha256};
-use rand_core::OsRng;
+use rand::SeedableRng;
 use std::hint::black_box;
-use threshold_signatures::batch_invert;
+use threshold_signatures::{batch_invert, test_utils::MockCryptoRng};
 
 fn bench_inversion(c: &mut Criterion) {
     let mut group = c.benchmark_group("Single_vs_Batch_Inversion");
+    let mut rng = MockCryptoRng::seed_from_u64(42);
 
     group.measurement_time(std::time::Duration::from_secs(10));
 
     let num_inversions = 10_000;
     let values: Vec<_> = (0..num_inversions)
-        .map(|_| Secp256K1ScalarField::random(&mut OsRng))
+        .map(|_| Secp256K1ScalarField::random(&mut rng))
         .collect();
 
     group.bench_function("single_inversion", |b| {
@@ -35,19 +36,20 @@ fn bench_inversion(c: &mut Criterion) {
 
 fn bench_inversion_vs_multiplication(c: &mut Criterion) {
     let mut group = c.benchmark_group("Inversion_vs_Multiplication");
+    let mut rng = MockCryptoRng::seed_from_u64(42);
 
     group.bench_function("single_inversion", |b| {
         b.iter(|| {
-            let value_to_invert = Secp256K1ScalarField::random(&mut OsRng);
+            let value_to_invert = Secp256K1ScalarField::random(&mut rng);
             black_box(value_to_invert.invert().unwrap());
         });
     });
 
     group.bench_function("three_multiplications", |b| {
         b.iter(|| {
-            let a = Secp256K1ScalarField::random(&mut OsRng);
-            let b = Secp256K1ScalarField::random(&mut OsRng);
-            let c = Secp256K1ScalarField::random(&mut OsRng);
+            let a = Secp256K1ScalarField::random(&mut rng);
+            let b = Secp256K1ScalarField::random(&mut rng);
+            let c = Secp256K1ScalarField::random(&mut rng);
             black_box(a * b * c);
         });
     });

benches/inversion.rs

@@ -2,24 +2,26 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use frost_core::Field;
 use frost_secp256k1::{Secp256K1ScalarField, Secp256K1Sha256};
-use rand_core::OsRng;
+use rand::SeedableRng;
 use std::hint::black_box;
 use threshold_signatures::{
     batch_compute_lagrange_coefficients, compute_lagrange_coefficient, participants::Participant,
+    test_utils::MockCryptoRng,
 };
 
 type C = Secp256K1Sha256;
 
 fn bench_lagrange_computation(c: &mut Criterion) {
     let mut group = c.benchmark_group("Lagrange");
+    let mut rng = MockCryptoRng::seed_from_u64(42);
 
     for degree in &[1u32, 100, 1_000] {
         let participants = (0..=*degree).map(Participant::from).collect::<Vec<_>>();
         let ids = participants
             .iter()
             .map(Participant::scalar::<C>)
             .collect::<Vec<_>>();
-        let point = Some(Secp256K1ScalarField::random(&mut OsRng));
+        let point = Some(Secp256K1ScalarField::random(&mut rng));
 
         group.bench_with_input(
             format!("sequential_degree_{degree}"),
@@ -66,19 +68,20 @@ fn bench_lagrange_computation(c: &mut Criterion) {
 
 pub fn bench_inversion_vs_multiplication(c: &mut Criterion) {
     let mut group = c.benchmark_group("Inversion_vs_Multiplication");
+    let mut rng = MockCryptoRng::seed_from_u64(42);
 
     group.bench_function("single_inversion", |b| {
         b.iter(|| {
-            let value_to_invert = Secp256K1ScalarField::random(&mut OsRng);
+            let value_to_invert = Secp256K1ScalarField::random(&mut rng);
             black_box(value_to_invert.invert().unwrap());
         });
     });
 
     group.bench_function("three_multiplications", |b| {
         b.iter(|| {
-            let a = Secp256K1ScalarField::random(&mut OsRng);
-            let b = Secp256K1ScalarField::random(&mut OsRng);
-            let c = Secp256K1ScalarField::random(&mut OsRng);
+            let a = Secp256K1ScalarField::random(&mut rng);
+            let b = Secp256K1ScalarField::random(&mut rng);
+            let c = Secp256K1ScalarField::random(&mut rng);
             black_box(a * b * c);
         });
     });