refactor: early return for LATEST_MAX_CERTIFICATES where possible

Signed-off-by: ljedrz <ljedrz@users.noreply.github.com>

Author: ljedrz

node/bft/src/gateway.rs

@@ -154,7 +154,7 @@ impl<N: Network> Gateway<N> {
             (Some(ip), _) => ip,
         };
         // Initialize the TCP stack.
-        let tcp = Tcp::new(Config::new(ip, N::MAX_CERTIFICATES.last().unwrap().1));
+        let tcp = Tcp::new(Config::new(ip, N::LATEST_MAX_CERTIFICATES()?));
         // Return the gateway.
         Ok(Self {
             account,

node/bft/src/helpers/pending.rs

@@ -15,8 +15,12 @@
 
 use crate::MAX_FETCH_TIMEOUT_IN_MS;
 use snarkos_node_bft_ledger_service::LedgerService;
-use snarkvm::console::network::{Network, consensus_config_value};
+use snarkvm::{
+    console::network::{Network, consensus_config_value},
+    prelude::Result,
+};
 
+use anyhow::anyhow;
 use parking_lot::RwLock;
 use std::{
     collections::{HashMap, HashSet},
@@ -32,21 +36,21 @@ use tokio::sync::oneshot;
 pub(crate) const CALLBACK_EXPIRATION_IN_SECS: i64 = MAX_FETCH_TIMEOUT_IN_MS.div_ceil(1000) as i64;
 
 /// Returns the maximum number of redundant requests for the number of validators in the specified round.
-pub fn max_redundant_requests<N: Network>(ledger: Arc<dyn LedgerService<N>>, round: u64) -> usize {
+pub fn max_redundant_requests<N: Network>(ledger: Arc<dyn LedgerService<N>>, round: u64) -> Result<usize> {
     // Determine the number of validators in the committee lookback for the given round.
     let num_validators =
-        ledger.get_committee_lookback_for_round(round).map(|committee| committee.num_members()).ok().unwrap_or_else(
-            || {
-                let max_committee_size =
-                    consensus_config_value!(N, MAX_CERTIFICATES, ledger.latest_block_height()).unwrap();
-                max_committee_size as usize
-            },
-        );
+        if let Ok(n) = ledger.get_committee_lookback_for_round(round).map(|committee| committee.num_members()) {
+            n
+        } else {
+            let max_committee_size = consensus_config_value!(N, MAX_CERTIFICATES, ledger.latest_block_height())
+                .ok_or_else(|| anyhow!("Couldn't obtain MAX_CERTIFICATES"))?;
+            max_committee_size as usize
+        };
 
     // Note: It is adequate to set this value to the availability threshold,
     // as with high probability one will respond honestly (in the best and worst case
     // with stake spread across the validators evenly and unevenly, respectively).
-    1 + num_validators.saturating_div(3)
+    Ok(1 + num_validators.saturating_div(3))
 }
 
 #[derive(Debug)]

node/bft/src/helpers/proposal.rs

@@ -210,7 +210,7 @@ impl<N: Network> FromBytes for Proposal<N> {
         // Read the number of signatures.
         let num_signatures = u32::read_le(&mut reader)?;
         // Ensure the number of signatures is within bounds (this is an early safety check).
-        if num_signatures as usize > N::LATEST_MAX_CERTIFICATES().unwrap() as usize {
+        if num_signatures as usize > N::LATEST_MAX_CERTIFICATES().map_err(error)? as usize {
             return Err(error("Invalid number of signatures in the proposal"));
         }
         // Read the signatures.

node/bft/src/sync/mod.rs

@@ -607,7 +607,7 @@ impl<N: Network> Sync<N> {
         // Determine if we've already sent a request to the peer.
         let contains_peer_with_sent_request = self.pending.contains_peer_with_sent_request(certificate_id, peer_ip);
         // Determine the maximum number of redundant requests.
-        let num_redundant_requests = max_redundant_requests(self.ledger.clone(), self.storage.current_round());
+        let num_redundant_requests = max_redundant_requests(self.ledger.clone(), self.storage.current_round())?;
         // Determine if we should send a certificate request to the peer.
         // We send at most `num_redundant_requests` requests and each peer can only receive one request at a time.
         let should_send_request = num_sent_requests < num_redundant_requests && !contains_peer_with_sent_request;

node/bft/src/worker.rs

@@ -446,7 +446,7 @@ impl<N: Network> Worker<N> {
         // Determine if we've already sent a request to the peer.
         let contains_peer_with_sent_request = self.pending.contains_peer_with_sent_request(transmission_id, peer_ip);
         // Determine the maximum number of redundant requests.
-        let num_redundant_requests = max_redundant_requests(self.ledger.clone(), self.storage.current_round());
+        let num_redundant_requests = max_redundant_requests(self.ledger.clone(), self.storage.current_round())?;
         // Determine if we should send a transmission request to the peer.
         // We send at most `num_redundant_requests` requests and each peer can only receive one request at a time.
         let should_send_request = num_sent_requests < num_redundant_requests && !contains_peer_with_sent_request;
@@ -623,7 +623,7 @@ mod tests {
         let ledger: Arc<dyn LedgerService<CurrentNetwork>> = Arc::new(mock_ledger);
 
         // Ensure the maximum number of redundant requests is correct and consistent across iterations.
-        assert_eq!(max_redundant_requests(ledger, 0), 6, "Update me if the formula changes");
+        assert_eq!(max_redundant_requests(ledger, 0).unwrap(), 6, "Update me if the formula changes");
     }
 
     #[tokio::test]
@@ -881,7 +881,8 @@ mod tests {
         let transmission_id = TransmissionID::Transaction(transaction_id, checksum);
 
         // Determine the number of redundant requests are sent.
-        let num_redundant_requests = max_redundant_requests(worker.ledger.clone(), worker.storage.current_round());
+        let num_redundant_requests =
+            max_redundant_requests(worker.ledger.clone(), worker.storage.current_round()).unwrap();
         let num_flood_requests = num_redundant_requests * 10;
         let mut peer_ips =
             (0..num_flood_requests).map(|i| SocketAddr::from(([127, 0, 0, 1], 1234 + i as u16))).collect_vec();

node/bft/tests/components/pending.rs

@@ -28,5 +28,5 @@ fn test_max_redundant_requests() {
     // Sample a ledger.
     let ledger = sample_ledger(&accounts, &committee, &mut rng);
     // Ensure the maximum number of redundant requests is correct and consistent across iterations.
-    assert_eq!(max_redundant_requests(ledger, 0), 6, "Update me if the formula changes");
+    assert_eq!(max_redundant_requests(ledger, 0).unwrap(), 6, "Update me if the formula changes");
 }

node/bft/tests/components/worker.rs

@@ -41,7 +41,7 @@ async fn test_resend_transmission_request() {
     let worker = sample_worker(0, accounts[0].clone(), ledger.clone());
 
     // Determine the maximum number of redundant requests.
-    let max_redundancy = max_redundant_requests(ledger.clone(), 0);
+    let max_redundancy = max_redundant_requests(ledger.clone(), 0).unwrap();
     assert_eq!(max_redundancy, 6, "Update me if the formula changes");
 
     // Prepare peer ips.
@@ -123,7 +123,7 @@ async fn test_flood_transmission_requests() {
     let worker = sample_worker(0, accounts[0].clone(), ledger.clone());
 
     // Determine the maximum number of redundant requests.
-    let max_redundancy = max_redundant_requests(ledger.clone(), 0);
+    let max_redundancy = max_redundant_requests(ledger.clone(), 0).unwrap();
     assert_eq!(max_redundancy, 6, "Update me if the formula changes");
 
     // Prepare peer ips.