refactor(fix): relocate bench_utils ckd functions (near#3634)

Author: gilcu3

crates/threshold-signatures/benches/bench_utils.rs

@@ -5,6 +5,8 @@
     clippy::indexing_slicing
 )]
 
+#[path = "bench_utils/ckd.rs"]
+mod ckd;
 #[path = "bench_utils/dkg.rs"]
 mod dkg;
 #[path = "bench_utils/frost_eddsa.rs"]
@@ -14,6 +16,7 @@ mod ot_based_ecdsa;
 #[path = "bench_utils/robust_ecdsa.rs"]
 mod robust_ecdsa;
 
+pub use ckd::*;
 pub use dkg::*;
 pub use frost_eddsa::*;
 pub use ot_based_ecdsa::*;

crates/threshold-signatures/benches/bench_utils/ckd.rs

@@ -0,0 +1,74 @@
+use rand::Rng;
+use rand_core::{CryptoRngCore, SeedableRng};
+
+use threshold_signatures::{
+    ReconstructionThreshold,
+    confidential_key_derivation::{
+        self as ckd,
+        ciphersuite::{Field as _, Group as _},
+    },
+    participants::Participant,
+    protocol::Protocol,
+    test_utils::{MockCryptoRng, generate_participants_with_random_ids, run_keygen},
+};
+
+use super::MAX_MALICIOUS;
+
+pub fn prepare_ckd<R: CryptoRngCore + SeedableRng + Send + 'static>(
+    threshold: ReconstructionThreshold,
+    rng: &mut R,
+) -> PreparedCkdPackage {
+    let num_participants = threshold.value();
+    // collect all participants
+    let participants = generate_participants_with_random_ids(num_participants, rng);
+    let key_packages = run_keygen(&participants, *MAX_MALICIOUS + 1, rng);
+
+    // choose a coordinator at random
+    let coordinator_index = rng.gen_range(0..num_participants);
+    let coordinator = participants[coordinator_index];
+
+    let mut protocols = Vec::with_capacity(participants.len());
+
+    let mut app_id: [u8; 32] = [0u8; 32];
+    rng.fill_bytes(&mut app_id);
+    let app_id = ckd::AppId::try_new(app_id).expect("cannot fail");
+
+    let scalar_rng = MockCryptoRng::seed_from_u64(rng.next_u64());
+    let app_sk = ckd::Scalar::random(scalar_rng);
+    let app_pk = ckd::ElementG1::generator() * app_sk;
+
+    for (p, keygen_out) in &key_packages {
+        let rng_p = MockCryptoRng::seed_from_u64(rng.next_u64());
+        let protocol = ckd::protocol::ckd(
+            &participants,
+            coordinator,
+            *p,
+            keygen_out.clone(),
+            app_id.clone(),
+            app_pk,
+            rng_p,
+        )
+        .map(|ckd| Box::new(ckd) as Box<dyn Protocol<Output = ckd::CKDOutputOption>>)
+        .expect("Ckd should succeed");
+        protocols.push((*p, protocol));
+    }
+
+    PreparedCkdPackage {
+        protocols,
+        index: coordinator_index,
+        key_packages,
+        app_id,
+        app_pk,
+    }
+}
+
+pub struct PreparedCkdPackage {
+    pub protocols: Vec<(
+        Participant,
+        Box<dyn Protocol<Output = ckd::CKDOutputOption>>,
+    )>,
+    pub index: usize,
+    pub key_packages: Vec<(Participant, ckd::KeygenOutput)>,
+    pub app_id: ckd::AppId,
+    pub app_pk: ckd::ElementG1,
+}

crates/threshold-signatures/benches/bench_utils/frost_eddsa.rs

@@ -3,10 +3,6 @@ use rand_core::{CryptoRngCore, SeedableRng};
 
 use threshold_signatures::{
     ReconstructionThreshold,
-    confidential_key_derivation::{
-        self as ckd,
-        ciphersuite::{Field as _, Group as _},
-    },
     frost::eddsa,
     participants::Participant,
     protocol::Protocol,
@@ -170,62 +166,3 @@ pub struct FrostEd25519SigV2 {
     pub key_packages: Vec<(Participant, eddsa::KeygenOutput)>,
     pub message: Vec<u8>,
 }
-
-pub fn prepare_ckd<R: CryptoRngCore + SeedableRng + Send + 'static>(
-    threshold: ReconstructionThreshold,
-    rng: &mut R,
-) -> PreparedCkdPackage {
-    let num_participants = threshold.value();
-    // collect all participants
-    let participants = generate_participants_with_random_ids(num_participants, rng);
-    let key_packages = run_keygen(&participants, *MAX_MALICIOUS + 1, rng);
-
-    // choose a coordinator at random
-    let coordinator_index = rng.gen_range(0..num_participants);
-    let coordinator = participants[coordinator_index];
-
-    let mut protocols = Vec::with_capacity(participants.len());
-
-    let mut app_id: [u8; 32] = [0u8; 32];
-    rng.fill_bytes(&mut app_id);
-    let app_id = ckd::AppId::try_new(app_id).expect("cannot fail");
-
-    let scalar_rng = MockCryptoRng::seed_from_u64(rng.next_u64());
-    let app_sk = ckd::Scalar::random(scalar_rng);
-    let app_pk = ckd::ElementG1::generator() * app_sk;
-
-    for (p, keygen_out) in &key_packages {
-        let rng_p = MockCryptoRng::seed_from_u64(rng.next_u64());
-        let protocol = ckd::protocol::ckd(
-            &participants,
-            coordinator,
-            *p,
-            keygen_out.clone(),
-            app_id.clone(),
-            app_pk,
-            rng_p,
-        )
-        .map(|ckd| Box::new(ckd) as Box<dyn Protocol<Output = ckd::CKDOutputOption>>)
-        .expect("Ckd should succeed");
-        protocols.push((*p, protocol));
-    }
-
-    PreparedCkdPackage {
-        protocols,
-        index: coordinator_index,
-        key_packages,
-        app_id,
-        app_pk,
-    }
-}
-
-pub struct PreparedCkdPackage {
-    pub protocols: Vec<(
-        Participant,
-        Box<dyn Protocol<Output = ckd::CKDOutputOption>>,
-    )>,
-    pub index: usize,
-    pub key_packages: Vec<(Participant, ckd::KeygenOutput)>,
-    pub app_id: ckd::AppId,
-    pub app_pk: ckd::ElementG1,
-}