Fix and DRY getting party size

src/node/protocol/dkg.rs

@@ -20,3 +20,12 @@ pub(crate) mod round_one;
 pub(crate) mod round_two;
 pub(crate) mod state;
 pub(crate) mod trigger;
+
+use crate::node::state::State;
+
+/// Get the max and min signers for the DKG
+pub(crate) async fn get_max_min_signers(state: &State) -> (usize, usize) {
+    let members = state.membership_handle.get_members().await.unwrap();
+    let num_members = members.len() + 1;
+    (num_members, (num_members * 2).div_ceil(3))
+}

src/node/protocol/dkg/round_one.rs

@@ -16,6 +16,7 @@
 // along with Frost-Federation. If not, see
 // <https://www.gnu.org/licenses/>.
 
+use crate::node::protocol::dkg::get_max_min_signers;
 use crate::node::protocol::BroadcastProtocol;
 use crate::node::protocol::Message;
 use crate::node::state::State;
@@ -46,22 +47,15 @@ async fn build_round1_package(
     sender_id: String,
     state: crate::node::state::State,
 ) -> Result<Message, frost::Error> {
-    let max_min_signers = state
-        .membership_handle
-        .get_members()
-        .await
-        .map(|members| {
-            let num_members = members.len();
-            (num_members, (num_members * 2).div_ceil(3))
-        })
-        .unwrap();
+    let (max_signers, min_signers) = get_max_min_signers(&state).await;
+
     let participant_identifier = frost::Identifier::derive(sender_id.as_bytes()).unwrap();
     let rng = thread_rng();
-    log::debug!("SIGNERS: {} {}", max_min_signers.0, max_min_signers.1);
+    log::debug!("SIGNERS: {} {}", max_signers, min_signers);
     let result = frost::keys::dkg::part1(
         participant_identifier,
-        max_min_signers.0 as u16,
-        max_min_signers.1 as u16,
+        max_signers as u16,
+        min_signers as u16,
         rng,
     );
     match result {

src/node/protocol/dkg/round_two.rs

@@ -18,6 +18,7 @@
 
 use crate::node;
 use crate::node::dkg::state::Round2Map;
+use crate::node::protocol::dkg::get_max_min_signers;
 use crate::node::protocol::Message;
 use frost_secp256k1 as frost;
 use serde::{Deserialize, Serialize};
@@ -74,15 +75,8 @@ pub async fn build_round2_packages(
     sender_id: String,
     state: crate::node::state::State,
 ) -> Result<(frost::keys::dkg::round2::SecretPackage, Round2Map), frost::Error> {
-    let max_min_signers = state
-        .membership_handle
-        .get_members()
-        .await
-        .map(|members| {
-            let num_members = members.len();
-            (num_members, (num_members * 2).div_ceil(3))
-        })
-        .unwrap();
+    let (max_signers, min_signers) = get_max_min_signers(&state).await;
+    println!("SIGNERS: {} {}", max_signers, min_signers);
 
     let secret_package = match state.dkg_state.get_round1_secret_package().await.unwrap() {
         Some(package) => package,
@@ -96,7 +90,8 @@ pub async fn build_round2_packages(
         .unwrap();
     log::debug!("Received round1 packages: {:?}", received_packages.len());
 
-    if received_packages.len() < max_min_signers.1 {
+    // We need at least min_signers to proceed
+    if received_packages.len() < min_signers {
         return Err(frost::Error::InvalidMinSigners);
     }
 

src/node/test_helpers.rs

@@ -22,9 +22,11 @@ pub(crate) mod support {
     #[mockall_double::double]
     use crate::node::reliable_sender::ReliableSenderHandle;
 
+    /// Builds a membership with the given number of nodes
+    /// Do not add the local node to the membership, therefore it loops from 1 to num
     pub(crate) async fn build_membership(num: usize) -> MembershipHandle {
         let membership_handle = MembershipHandle::start("localhost".to_string()).await;
-        for i in 0..num {
+        for i in 1..num {
             let mut mock_reliable_sender = ReliableSenderHandle::default();
             mock_reliable_sender.expect_clone().returning(|| {
                 let mut mock = ReliableSenderHandle::default();