Add tests for determine_global_state and determine_global_burn_view

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stacks-signer/src/v0/signer_state.rs

@@ -115,7 +115,9 @@ impl GlobalStateEvaluator {
                 ..
             } = update.content;
 
-            let entry = burn_blocks.entry(burn_block).or_insert_with(|| 0);
+            let entry = burn_blocks
+                .entry((burn_block, burn_block_height))
+                .or_insert_with(|| 0);
             *entry += weight;
             if self.reached_agreement(*entry) {
                 return Some((burn_block, burn_block_height));
@@ -160,38 +162,6 @@ impl GlobalStateEvaluator {
         None
     }
 
-    /// Check if there is an agreed upon global current miner viewpoint
-    pub fn determine_global_current_miner(
-        &mut self,
-        local_address: StacksAddress,
-        local_update: StateMachineUpdateMessage,
-    ) -> Option<StateMachineUpdateMinerState> {
-        let (global_burn_block, _) =
-            self.determine_global_burn_view(local_address, local_update)?;
-        let mut miner_views = HashMap::new();
-        for (address, update) in &self.address_updates {
-            let Some(weight) = self.address_weights.get(address) else {
-                continue;
-            };
-            let StateMachineUpdateContent::V0 {
-                burn_block,
-                current_miner,
-                ..
-            } = &update.content;
-
-            if *burn_block != global_burn_block {
-                continue;
-            }
-
-            let entry = miner_views.entry(current_miner).or_insert_with(|| 0);
-            *entry += weight;
-            if self.reached_agreement(*entry) {
-                return Some(current_miner.clone());
-            }
-        }
-        None
-    }
-
     /// Determines whether a signer with the `local_address` and `local_update` should
     /// should capitulate its current miner view to a new state. This is not necessarily the same as the current global view
     /// of the miner as it is up to signers to capitulate before this becomes the finalized view.
@@ -856,30 +826,12 @@ mod tests {
 
     use super::*;
 
-    fn generate_random_address_with_equal_weights(
-        num_addresses: u32,
-    ) -> HashMap<StacksAddress, u32> {
-        let mut address_weights = HashMap::new();
-        for _ in 0..num_addresses {
-            let stacks_address = StacksAddress::p2pkh(
-                false,
-                &StacksPublicKey::from_private(&StacksPrivateKey::random()),
-            );
-            address_weights.insert(stacks_address, 10);
-        }
-        address_weights
-    }
-
-    #[test]
-    fn determine_latest_supported_signer_protocol_versions() {
-        let address_weights = generate_random_address_with_equal_weights(5);
+    fn generate_global_state_evaluator(num_addresses: u32) -> GlobalStateEvaluator {
+        let address_weights = generate_random_address_with_equal_weights(num_addresses);
         let active_protocol_version = 0;
         let local_supported_signer_protocol_version = 1;
 
-        let addresses: Vec<_> = address_weights.keys().cloned().collect();
-        let local_address = addresses[0];
-
-        let local_update = StateMachineUpdateMessage::new(
+        let update = StateMachineUpdateMessage::new(
             active_protocol_version,
             local_supported_signer_protocol_version,
             StateMachineUpdateContent::V0 {
@@ -897,37 +849,74 @@ mod tests {
         .unwrap();
 
         let mut address_updates = HashMap::new();
-        for address in &addresses {
-            address_updates.insert(*address, local_update.clone());
+        for address in address_weights.keys() {
+            address_updates.insert(*address, update.clone());
         }
+        GlobalStateEvaluator::new(address_updates, address_weights)
+    }
 
-        let mut global_eval = GlobalStateEvaluator::new(address_updates, address_weights);
+    fn generate_random_address_with_equal_weights(
+        num_addresses: u32,
+    ) -> HashMap<StacksAddress, u32> {
+        let mut address_weights = HashMap::new();
+        for _ in 0..num_addresses {
+            let stacks_address = StacksAddress::p2pkh(
+                false,
+                &StacksPublicKey::from_private(&StacksPrivateKey::random()),
+            );
+            address_weights.insert(stacks_address, 10);
+        }
+        address_weights
+    }
+
+    #[test]
+    fn determine_latest_supported_signer_protocol_versions() {
+        let mut global_eval = generate_global_state_evaluator(5);
+
+        let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
+        let local_address = addresses[0];
+
+        let local_update = global_eval
+            .address_updates
+            .get(&local_address)
+            .unwrap()
+            .clone();
         assert_eq!(
             global_eval
                 .determine_latest_supported_signer_protocol_version(
                     local_address,
-                    local_update.clone()
+                    global_eval
+                        .address_updates
+                        .get(&local_address)
+                        .unwrap()
+                        .clone(),
                 )
                 .unwrap(),
-            local_supported_signer_protocol_version
+            local_update.local_supported_signer_protocol_version
         );
 
+        let StateMachineUpdateMessage {
+            active_signer_protocol_version,
+            local_supported_signer_protocol_version,
+            content:
+                StateMachineUpdateContent::V0 {
+                    burn_block,
+                    burn_block_height,
+                    current_miner,
+                },
+            ..
+        } = local_update.clone();
+
         // Let's update 3 signers (60 percent) to support seperate but greater protocol versions
         for (i, address) in addresses.into_iter().skip(1).take(3).enumerate() {
-            let new_version = local_supported_signer_protocol_version + i as u64 + 1;
+            let new_version = local_update.local_supported_signer_protocol_version + i as u64 + 1;
             let new_update = StateMachineUpdateMessage::new(
-                0,
+                active_signer_protocol_version,
                 new_version,
                 StateMachineUpdateContent::V0 {
-                    burn_block: ConsensusHash([0x55; 20]),
-                    burn_block_height: 100,
-                    current_miner: StateMachineUpdateMinerState::ActiveMiner {
-                        current_miner_pkh: Hash160([0xab; 20]),
-                        tenure_id: ConsensusHash([0x44; 20]),
-                        parent_tenure_id: ConsensusHash([0x22; 20]),
-                        parent_tenure_last_block: StacksBlockId([0x33; 32]),
-                        parent_tenure_last_block_height: 1,
-                    },
+                    burn_block,
+                    burn_block_height,
+                    current_miner: current_miner.clone(),
                 },
             )
             .unwrap();
@@ -944,18 +933,12 @@ mod tests {
         // Let's tip the scales over to version number 2 by updating the local signer's version...
         // i.e. > 70% will have version 2 or higher in their map
         let local_update = StateMachineUpdateMessage::new(
-            active_protocol_version,
+            active_signer_protocol_version,
             3,
             StateMachineUpdateContent::V0 {
-                burn_block: ConsensusHash([0x55; 20]),
-                burn_block_height: 100,
-                current_miner: StateMachineUpdateMinerState::ActiveMiner {
-                    current_miner_pkh: Hash160([0xab; 20]),
-                    tenure_id: ConsensusHash([0x44; 20]),
-                    parent_tenure_id: ConsensusHash([0x22; 20]),
-                    parent_tenure_last_block: StacksBlockId([0x33; 32]),
-                    parent_tenure_last_block_height: 1,
-                },
+                burn_block,
+                burn_block_height,
+                current_miner,
             },
         )
         .unwrap();
@@ -967,4 +950,148 @@ mod tests {
             local_supported_signer_protocol_version + 1
         );
     }
+
+    #[test]
+    fn determine_global_burn_views() {
+        let mut global_eval = generate_global_state_evaluator(5);
+
+        let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
+        let local_address = addresses[0];
+        let local_update = global_eval
+            .address_updates
+            .get(&local_address)
+            .unwrap()
+            .clone();
+        let StateMachineUpdateMessage {
+            active_signer_protocol_version,
+            local_supported_signer_protocol_version,
+            content:
+                StateMachineUpdateContent::V0 {
+                    burn_block,
+                    burn_block_height,
+                    current_miner,
+                },
+            ..
+        } = local_update.clone();
+
+        assert_eq!(
+            global_eval
+                .determine_global_burn_view(local_address, local_update.clone(),)
+                .unwrap(),
+            (burn_block, burn_block_height)
+        );
+
+        // Let's update 3 signers (60 percent) to support a new burn block view
+        let new_update = StateMachineUpdateMessage::new(
+            active_signer_protocol_version,
+            local_supported_signer_protocol_version,
+            StateMachineUpdateContent::V0 {
+                burn_block,
+                burn_block_height: burn_block_height.wrapping_add(1),
+                current_miner: current_miner.clone(),
+            },
+        )
+        .unwrap();
+        for address in addresses.into_iter().skip(1).take(3) {
+            global_eval.insert_update(address, new_update.clone());
+        }
+
+        assert!(
+            global_eval
+                .determine_global_burn_view(local_address, local_update,)
+                .is_none(),
+            "We should not have reached agreement on the burn block height"
+        );
+
+        // Let's tip the scales over to burn block height + 1
+        assert_eq!(
+            global_eval
+                .determine_global_burn_view(local_address, new_update,)
+                .unwrap(),
+            (burn_block, burn_block_height.wrapping_add(1))
+        );
+    }
+
+    #[test]
+    fn determine_global_states() {
+        let mut global_eval = generate_global_state_evaluator(5);
+
+        let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
+        let local_address = addresses[0];
+        let local_update = global_eval
+            .address_updates
+            .get(&local_address)
+            .unwrap()
+            .clone();
+        let StateMachineUpdateMessage {
+            active_signer_protocol_version,
+            local_supported_signer_protocol_version,
+            content:
+                StateMachineUpdateContent::V0 {
+                    burn_block,
+                    burn_block_height,
+                    current_miner,
+                },
+            ..
+        } = local_update.clone();
+
+        let state_machine = SignerStateMachine {
+            burn_block,
+            burn_block_height,
+            current_miner: (&current_miner).into(),
+            active_signer_protocol_version: local_supported_signer_protocol_version, // a majority of signers are saying they support version the same local_supported_signer_protocol_version, so update it here...
+        };
+
+        assert_eq!(
+            global_eval
+                .determine_global_state(local_address, local_update.clone(),)
+                .unwrap(),
+            state_machine
+        );
+        let new_miner = StateMachineUpdateMinerState::ActiveMiner {
+            current_miner_pkh: Hash160([0x00; 20]),
+            tenure_id: ConsensusHash([0x44; 20]),
+            parent_tenure_id: ConsensusHash([0x22; 20]),
+            parent_tenure_last_block: StacksBlockId([0x33; 32]),
+            parent_tenure_last_block_height: 1,
+        };
+
+        let new_update = StateMachineUpdateMessage::new(
+            active_signer_protocol_version,
+            local_supported_signer_protocol_version,
+            StateMachineUpdateContent::V0 {
+                burn_block,
+                burn_block_height,
+                current_miner: new_miner.clone(),
+            },
+        )
+        .unwrap();
+
+        // Let's update 3 signers to some new miner key (60 percent)
+        for address in addresses.into_iter().skip(1).take(3) {
+            global_eval.insert_update(address, new_update.clone());
+        }
+
+        assert!(
+            global_eval
+                .determine_global_state(local_address, local_update,)
+                .is_none(),
+            "We should have a disagreement about the current miner"
+        );
+
+        let state_machine = SignerStateMachine {
+            burn_block,
+            burn_block_height,
+            current_miner: (&new_miner).into(),
+            active_signer_protocol_version: local_supported_signer_protocol_version, // a majority of signers are saying they support version the same local_supported_signer_protocol_version, so update it here...
+        };
+
+        // Let's tip the scales over to a different miner
+        assert_eq!(
+            global_eval
+                .determine_global_state(local_address, new_update,)
+                .unwrap(),
+            state_machine
+        )
+    }
 }