change membership to return peerconfig

contracts/rust/adapter/src/stake_table.rs

@@ -26,6 +26,7 @@ use hotshot_types::{
     signature_key::BLSPubKey,
     stake_table::StakeTableEntry,
     traits::signature_key::SignatureKey as _,
+    PeerConfig,
 };
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
@@ -216,6 +217,18 @@ impl From<NodeInfoJf> for StakeTableEntry<BLSPubKey> {
     }
 }
 
+impl From<NodeInfoJf> for PeerConfig<BLSPubKey> {
+    fn from(value: NodeInfoJf) -> Self {
+        Self {
+            stake_table_entry: StakeTableEntry {
+                stake_key: value.stake_table_key,
+                stake_amount: U256::from(1), // dummy stake amount
+            },
+            state_ver_key: value.state_ver_key,
+        }
+    }
+}
+
 impl From<NodeInfo> for NodeInfoJf {
     fn from(value: NodeInfo) -> Self {
         let NodeInfo {

hotshot-examples/infra/mod.rs

@@ -531,6 +531,7 @@ pub trait RunDa<
                 TYPES::View::genesis(),
                 genesis_epoch_from_version::<V, TYPES>(),
             )
+            .unwrap_or_default()
             .len();
         let consensus_lock = context.hotshot.consensus();
         let consensus_reader = consensus_lock.read().await;

hotshot-task-impls/src/consensus/handlers.rs

@@ -86,7 +86,8 @@ pub(crate) async fn handle_quorum_vote_recv<
             .membership
             .read()
             .await
-            .has_stake(&vote.signing_key(), Some(vote_epoch + 1));
+            .has_stake(&vote.signing_key(), Some(vote_epoch + 1))
+            .map_err(|_| error!("stake not found"))?;
         if has_stake {
             handle_vote(
                 &mut task_state.next_epoch_vote_collectors,
@@ -370,7 +371,8 @@ pub(crate) async fn handle_timeout<TYPES: NodeType, I: NodeImplementation<TYPES>
             .membership
             .read()
             .await
-            .has_stake(&task_state.public_key, epoch),
+            .has_stake(&task_state.public_key, epoch)
+            .map_err(|_| error!("stake not found"))?,
         debug!(
             "We were not chosen for the consensus committee for view {:?}",
             view_number

hotshot-task-impls/src/da.rs

@@ -169,15 +169,15 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
 
                 let membership_reader = self.membership.read().await;
                 ensure!(
-                    membership_reader.has_da_stake(&self.public_key, epoch_number),
+                    membership_reader.has_da_stake(&self.public_key, epoch_number)?,
                     debug!(
                         "We were not chosen for consensus committee for view {:?} in epoch {:?}",
                         view_number, epoch_number
                     )
                 );
-                let num_nodes = membership_reader.total_nodes(epoch_number);
+                let num_nodes = membership_reader.total_nodes(epoch_number)?;
                 let next_epoch_num_nodes =
-                    membership_reader.total_nodes(epoch_number.map(|e| e + 1));
+                    membership_reader.total_nodes(epoch_number.map(|e| e + 1))?;
                 drop(membership_reader);
 
                 let version = self.upgrade_lock.version_infallible(view_number).await;
@@ -273,9 +273,11 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> DaTaskState<TYP
                     let next_epoch = proposal_epoch.map(|epoch| epoch + 1);
 
                     let membership_reader = membership.read().await;
-                    let target_epoch = if membership_reader.has_stake(&public_key, proposal_epoch) {
+                    let target_epoch = if membership_reader
+                        .has_stake(&public_key, proposal_epoch)?
+                    {
                         proposal_epoch
-                    } else if membership_reader.has_stake(&public_key, next_epoch) {
+                    } else if membership_reader.has_stake(&public_key, next_epoch)? {
                         next_epoch
                     } else {
                         bail!("Not calculating VID, the node doesn't belong to the current epoch or the next epoch.");

hotshot-task-impls/src/helpers.rs

@@ -133,10 +133,15 @@ pub(crate) async fn fetch_proposal<TYPES: NodeType, V: Versions>(
     let justify_qc_epoch = justify_qc.data.epoch();
 
     let membership_reader = membership.read().await;
-    let membership_stake_table = membership_reader.stake_table(justify_qc_epoch);
-    let membership_success_threshold = membership_reader.success_threshold(justify_qc_epoch);
+    let membership_stake_table = membership_reader.stake_table(justify_qc_epoch)?;
+    let membership_success_threshold = membership_reader.success_threshold(justify_qc_epoch)?;
     drop(membership_reader);
 
+    let membership_stake_table = membership_stake_table
+        .into_iter()
+        .map(|config| config.stake_table_entry)
+        .collect::<Vec<_>>();
+
     justify_qc
         .is_valid_cert(
             membership_stake_table,
@@ -198,16 +203,6 @@ async fn decide_epoch_root<TYPES: NodeType>(
             // If we didn't get a write callback out of add_epoch_root, then don't bother locking and calling sync_l1
             return;
         }
-
-        let write_callback = {
-            let membership_reader = membership.read().await;
-            membership_reader.sync_l1().await
-        };
-
-        if let Some(write_callback) = write_callback {
-            let mut membership_writer = membership.write().await;
-            write_callback(&mut *membership_writer);
-        }
     }
 }
 
@@ -778,11 +773,16 @@ pub(crate) async fn validate_proposal_view_and_certs<
                 let timeout_cert_epoch = timeout_cert.data().epoch();
 
                 let membership_reader = validation_info.membership.read().await;
-                let membership_stake_table = membership_reader.stake_table(timeout_cert_epoch);
+                let membership_stake_table = membership_reader.stake_table(timeout_cert_epoch)?;
                 let membership_success_threshold =
-                    membership_reader.success_threshold(timeout_cert_epoch);
+                    membership_reader.success_threshold(timeout_cert_epoch)?;
                 drop(membership_reader);
 
+                let membership_stake_table = membership_stake_table
+                    .into_iter()
+                    .map(|config| config.stake_table_entry)
+                    .collect::<Vec<_>>();
+
                 timeout_cert
                     .is_valid_cert(
                         membership_stake_table,
@@ -808,11 +808,14 @@ pub(crate) async fn validate_proposal_view_and_certs<
                 let view_sync_cert_epoch = view_sync_cert.data().epoch();
 
                 let membership_reader = validation_info.membership.read().await;
-                let membership_stake_table = membership_reader.stake_table(view_sync_cert_epoch);
+                let membership_stake_table = membership_reader.stake_table(view_sync_cert_epoch)?;
                 let membership_success_threshold =
-                    membership_reader.success_threshold(view_sync_cert_epoch);
+                    membership_reader.success_threshold(view_sync_cert_epoch)?;
                 drop(membership_reader);
-
+                let membership_stake_table = membership_stake_table
+                    .into_iter()
+                    .map(|config| config.stake_table_entry)
+                    .collect::<Vec<_>>();
                 // View sync certs must also be valid.
                 view_sync_cert
                     .is_valid_cert(
@@ -937,10 +940,14 @@ pub async fn validate_qc_and_next_epoch_qc<TYPES: NodeType, V: Versions>(
     upgrade_lock: &UpgradeLock<TYPES, V>,
 ) -> Result<()> {
     let membership_reader = membership.read().await;
-    let membership_stake_table = membership_reader.stake_table(qc.data.epoch);
-    let membership_success_threshold = membership_reader.success_threshold(qc.data.epoch);
+    let membership_stake_table = membership_reader.stake_table(qc.data.epoch)?;
+    let membership_success_threshold = membership_reader.success_threshold(qc.data.epoch)?;
     drop(membership_reader);
 
+    let membership_stake_table = membership_stake_table
+        .into_iter()
+        .map(|config| config.stake_table_entry)
+        .collect::<Vec<_>>();
     {
         let consensus_reader = consensus.read().await;
         qc.is_valid_cert(
@@ -964,11 +971,16 @@ pub async fn validate_qc_and_next_epoch_qc<TYPES: NodeType, V: Versions>(
 
         let membership_reader = membership.read().await;
         let membership_next_stake_table =
-            membership_reader.stake_table(qc.data.epoch.map(|x| x + 1));
+            membership_reader.stake_table(qc.data.epoch.map(|x| x + 1))?;
         let membership_next_success_threshold =
-            membership_reader.success_threshold(qc.data.epoch.map(|x| x + 1));
+            membership_reader.success_threshold(qc.data.epoch.map(|x| x + 1))?;
         drop(membership_reader);
 
+        let membership_next_stake_table = membership_next_stake_table
+            .into_iter()
+            .map(|config| config.stake_table_entry)
+            .collect::<Vec<_>>();
+
         // Validate the next epoch qc as well
         next_epoch_qc
             .is_valid_cert(

hotshot-task-impls/src/network.rs

@@ -1149,7 +1149,8 @@ impl<
             .membership
             .read()
             .await
-            .da_committee_members(view_number, self.epoch);
+            .da_committee_members(view_number, self.epoch)
+            .unwrap();
         let network = Arc::clone(&self.network);
         let storage = Arc::clone(&self.storage);
         let consensus = OuterConsensus::new(Arc::clone(&self.consensus.inner_consensus));

hotshot-task-impls/src/quorum_proposal/handlers.rs

@@ -127,11 +127,16 @@ impl<TYPES: NodeType, V: Versions> ProposalDependencyHandle<TYPES, V> {
         while let Ok(event) = rx.recv_direct().await {
             if let HotShotEvent::HighQcRecv(qc, _sender) = event.as_ref() {
                 let membership_reader = self.membership.read().await;
-                let membership_stake_table = membership_reader.stake_table(qc.data.epoch);
+                let membership_stake_table = membership_reader.stake_table(qc.data.epoch).ok()?;
                 let membership_success_threshold =
-                    membership_reader.success_threshold(qc.data.epoch);
+                    membership_reader.success_threshold(qc.data.epoch).ok()?;
                 drop(membership_reader);
 
+                let membership_stake_table = membership_stake_table
+                    .iter()
+                    .map(|config| config.stake_table_entry.clone())
+                    .collect::<Vec<_>>();
+
                 if qc
                     .is_valid_cert(
                         membership_stake_table,

hotshot-task-impls/src/quorum_proposal/mod.rs

@@ -472,11 +472,26 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions>
                 let epoch_number = certificate.data.epoch;
 
                 let membership_reader = self.membership.read().await;
-                let membership_stake_table = membership_reader.stake_table(epoch_number);
-                let membership_success_threshold =
-                    membership_reader.success_threshold(epoch_number);
+                let membership_stake_table =
+                    membership_reader.stake_table(epoch_number).map_err(|_| {
+                        error!(format!(
+                            "stake table not found for epoch = {epoch_number:?}"
+                        ))
+                    })?;
+                let membership_success_threshold = membership_reader
+                    .success_threshold(epoch_number)
+                    .map_err(|_| {
+                        error!(format!(
+                            "success_threshold not found for epoch = {epoch_number:?}"
+                        ))
+                    })?;
                 drop(membership_reader);
 
+                let membership_stake_table = membership_stake_table
+                    .into_iter()
+                    .map(|config| config.stake_table_entry.clone())
+                    .collect::<Vec<_>>();
+
                 certificate
                     .is_valid_cert(
                         membership_stake_table,
@@ -557,11 +572,15 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions>
                 let cert_epoch_number = qc.data.epoch;
 
                 let membership_reader = self.membership.read().await;
-                let membership_stake_table = membership_reader.stake_table(cert_epoch_number);
+                let membership_stake_table = membership_reader.stake_table(cert_epoch_number)?;
                 let membership_success_threshold =
-                    membership_reader.success_threshold(cert_epoch_number);
+                    membership_reader.success_threshold(cert_epoch_number)?;
                 drop(membership_reader);
 
+                let membership_stake_table = membership_stake_table
+                    .into_iter()
+                    .map(|config| config.stake_table_entry.clone())
+                    .collect::<Vec<_>>();
                 qc.is_valid_cert(
                     membership_stake_table,
                     membership_success_threshold,

hotshot-task-impls/src/quorum_vote/handlers.rs

@@ -149,7 +149,7 @@ async fn verify_drb_result<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Ver
 
     if let Some(epoch_val) = epoch {
         let has_stake_current_epoch =
-            membership_reader.has_stake(&task_state.public_key, Some(epoch_val));
+            membership_reader.has_stake(&task_state.public_key, Some(epoch_val))?;
 
         drop(membership_reader);
 
@@ -189,6 +189,10 @@ async fn start_drb_task<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versio
         .read()
         .await
         .has_stake(&task_state.public_key, Some(current_epoch_number))
+        .unwrap_or_else(|_| {
+            tracing::error!("Failed to check if we have stake in the current epoch.");
+            false
+        })
     {
         let new_epoch_number = current_epoch_number + 1;
 
@@ -636,12 +640,13 @@ pub(crate) async fn submit_vote<TYPES: NodeType, I: NodeImplementation<TYPES>, V
     );
 
     let membership_reader = membership.read().await;
-    let committee_member_in_current_epoch = membership_reader.has_stake(&public_key, epoch_number);
+    let committee_member_in_current_epoch =
+        membership_reader.has_stake(&public_key, epoch_number)?;
     // If the proposed leaf is for the last block in the epoch and the node is part of the quorum committee
     // in the next epoch, the node should vote to achieve the double quorum.
     let committee_member_in_next_epoch = leaf.with_epoch
         && is_last_block_in_epoch(leaf.height(), epoch_height)
-        && membership_reader.has_stake(&public_key, epoch_number.map(|x| x + 1));
+        && membership_reader.has_stake(&public_key, epoch_number.map(|x| x + 1))?;
     drop(membership_reader);
 
     ensure!(

hotshot-task-impls/src/quorum_vote/mod.rs

@@ -546,11 +546,16 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> QuorumVoteTaskS
                 let cert_epoch = cert.data.epoch;
 
                 let membership_reader = self.membership.read().await;
-                let membership_da_stake_table = membership_reader.da_stake_table(cert_epoch);
+                let membership_da_stake_table = membership_reader.da_stake_table(cert_epoch)?;
                 let membership_da_success_threshold =
-                    membership_reader.da_success_threshold(cert_epoch);
+                    membership_reader.da_success_threshold(cert_epoch)?;
                 drop(membership_reader);
 
+                let membership_da_stake_table = membership_da_stake_table
+                    .into_iter()
+                    .map(|config| config.stake_table_entry)
+                    .collect::<Vec<_>>();
+
                 // Validate the DAC.
                 cert.is_valid_cert(
                     membership_da_stake_table,
@@ -602,13 +607,13 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> QuorumVoteTaskS
                 // ensure that the VID share was sent by a DA member OR the view leader
                 ensure!(
                     membership_reader
-                        .da_committee_members(view, vid_epoch)
+                        .da_committee_members(view, vid_epoch)?
                         .contains(sender)
                         || *sender == membership_reader.leader(view, vid_epoch)?,
                     "VID share was not sent by a DA member or the view leader."
                 );
 
-                let membership_total_nodes = membership_reader.total_nodes(target_epoch);
+                let membership_total_nodes = membership_reader.total_nodes(target_epoch)?;
                 drop(membership_reader);
 
                 if let Err(()) = share.data.verify_share(membership_total_nodes) {

hotshot-task-impls/src/request.rs

@@ -120,8 +120,8 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>> TaskState for NetworkRequest
                 // 1. we are part of the current epoch or
                 // 2. we are part of the next epoch and this is a proposal for the last block.
                 let membership_reader = self.membership.read().await;
-                if !membership_reader.has_stake(&self.public_key, prop_epoch)
-                    && (!membership_reader.has_stake(&self.public_key, next_epoch)
+                if !membership_reader.has_stake(&self.public_key, prop_epoch)?
+                    && (!membership_reader.has_stake(&self.public_key, next_epoch)?
                         || !is_last_block_in_epoch(
                             proposal.data.block_header().block_number(),
                             self.epoch_height,
@@ -214,14 +214,16 @@ impl<TYPES: NodeType, I: NodeImplementation<TYPES>> NetworkRequestState<TYPES, I
 
         // Get the committee members for the view and the leader, if applicable
         let membership_reader = self.membership.read().await;
-        let mut da_committee_for_view = membership_reader.da_committee_members(view, epoch);
+        let mut da_committee_for_view =
+            membership_reader.da_committee_members(view, epoch).unwrap();
         if let Ok(leader) = membership_reader.leader(view, epoch) {
             da_committee_for_view.insert(leader);
         }
 
         // Get committee members for view
         let mut recipients: Vec<TYPES::SignatureKey> = membership_reader
             .da_committee_members(view, epoch)
+            .unwrap()
             .into_iter()
             .collect();
         drop(membership_reader);

hotshot-task-impls/src/response.rs

@@ -210,7 +210,11 @@ impl<TYPES: NodeType, V: Versions> NetworkResponseState<TYPES, V> {
         sender: &TYPES::SignatureKey,
         epoch: Option<TYPES::Epoch>,
     ) -> bool {
-        self.membership.read().await.has_stake(sender, epoch)
+        self.membership
+            .read()
+            .await
+            .has_stake(sender, epoch)
+            .unwrap_or(false)
     }
 }