use u32 for block_rejection_timeout_steps keys

Author: rdeioris

stackslib/src/config/mod.rs

@@ -2156,7 +2156,7 @@ pub struct MinerConfig {
     /// Duration to wait before attempting to issue a tenure extend
     pub tenure_timeout: Duration,
     /// Define the timeout to apply while waiting for signers responses, based on the amount of rejections
-    pub block_rejection_timeout_steps: HashMap<u64, Duration>,
+    pub block_rejection_timeout_steps: HashMap<u32, Duration>,
 }
 
 impl Default for MinerConfig {
@@ -2196,7 +2196,7 @@ impl Default for MinerConfig {
             tenure_extend_poll_secs: Duration::from_secs(DEFAULT_TENURE_EXTEND_POLL_SECS),
             tenure_timeout: Duration::from_secs(DEFAULT_TENURE_TIMEOUT_SECS),
             block_rejection_timeout_steps: {
-                let mut rejections_timeouts_default_map = HashMap::<u64, Duration>::new();
+                let mut rejections_timeouts_default_map = HashMap::<u32, Duration>::new();
                 rejections_timeouts_default_map.insert(0, Duration::from_secs(600));
                 rejections_timeouts_default_map.insert(10, Duration::from_secs(300));
                 rejections_timeouts_default_map.insert(20, Duration::from_secs(150));
@@ -2744,9 +2744,9 @@ impl MinerConfigFile {
             tenure_timeout: self.tenure_timeout_secs.map(Duration::from_secs).unwrap_or(miner_default_config.tenure_timeout),
             block_rejection_timeout_steps: {
                 if let Some(block_rejection_timeout_items) = self.block_rejection_timeout_steps {
-                    let mut rejection_timeout_durations = HashMap::<u64, Duration>::new();
+                    let mut rejection_timeout_durations = HashMap::<u32, Duration>::new();
                     for (slice, seconds) in block_rejection_timeout_items.iter() {
-                        match slice.parse::<u64>() {
+                        match slice.parse::<u32>() {
                             Ok(slice_slot) => rejection_timeout_durations.insert(slice_slot, Duration::from_secs(*seconds)),
                             Err(e) => panic!("block_rejection_timeout_steps keys must be unsigned integers: {}", e)
                         };

testnet/stacks-node/src/nakamoto_node/signer_coordinator.rs

@@ -72,7 +72,7 @@ pub struct SignerCoordinator {
     ///  burn block has arrived since this thread started.
     burn_tip_at_start: ConsensusHash,
     /// The timeout configuration based on the percentage of rejections
-    block_rejection_timeout_steps: HashMap<u64, Duration>,
+    block_rejection_timeout_steps: HashMap<u32, Duration>,
 }
 
 impl SignerCoordinator {
@@ -305,21 +305,21 @@ impl SignerCoordinator {
         let mut block_rejection_timeout_steps = BTreeMap::<u64, Duration>::new();
         for (percentage, duration) in self.block_rejection_timeout_steps.iter() {
             let rejections_amount =
-                ((self.total_weight as f64 / 100.0) * *percentage as f64) as u64;
+                ((f64::from(self.total_weight) / 100.0) * f64::from(*percentage)) as u64;
             block_rejection_timeout_steps.insert(rejections_amount, *duration);
         }
 
         // the amount of current rejections (used to eventually modify the timeout)
         let mut rejections: u64 = 0;
         // default timeout (the 0 entry must be always present)
-        let mut rejections_timeout = self
-            .block_rejection_timeout_steps
-            .get(&rejections)
-            .ok_or_else(|| {
-                NakamotoNodeError::SigningCoordinatorFailure(
-                    "Invalid rejection timeout step function definition".into(),
-                )
-            })?;
+        let mut rejections_timeout =
+            block_rejection_timeout_steps
+                .get(&rejections)
+                .ok_or_else(|| {
+                    NakamotoNodeError::SigningCoordinatorFailure(
+                        "Invalid rejection timeout step function definition".into(),
+                    )
+                })?;
         // this is used for comparing block_status to identify if it has been changed from the previous event
         let mut block_status_tracker = BlockStatus::default();