Cleanup more tests

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

Author: jferrant

testnet/stacks-node/src/tests/signer/mod.rs

@@ -36,7 +36,7 @@ use stacks::net::api::postblock_proposal::{
     BlockValidateOk, BlockValidateReject, BlockValidateResponse,
 };
 use stacks::types::chainstate::{StacksAddress, StacksPublicKey};
-use stacks::types::{PrivateKey, PublicKey};
+use stacks::types::PrivateKey;
 use stacks::util::get_epoch_time_secs;
 use stacks::util::hash::MerkleHashFunc;
 use stacks::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
@@ -609,73 +609,6 @@ impl<S: Signer<T> + Send + 'static, T: SignerEventTrait + 'static> SignerTest<Sp
         }
     }
 
-    pub fn wait_for_block_acceptance(
-        &self,
-        timeout_secs: u64,
-        signer_signature_hash: &Sha512Trunc256Sum,
-        expected_signers: &[StacksPublicKey],
-    ) -> Result<(), String> {
-        // Make sure that at least 70% of signers accepted the block proposal
-        wait_for(timeout_secs, || {
-            let signatures = test_observer::get_stackerdb_chunks()
-                .into_iter()
-                .flat_map(|chunk| chunk.modified_slots)
-                .filter_map(|chunk| {
-                    let message = SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
-                        .expect("Failed to deserialize SignerMessage");
-                    if let SignerMessage::BlockResponse(BlockResponse::Accepted(accepted)) = message
-                    {
-                        if accepted.signer_signature_hash == *signer_signature_hash
-                            && expected_signers.iter().any(|pk| {
-                                pk.verify(
-                                    accepted.signer_signature_hash.bits(),
-                                    &accepted.signature,
-                                )
-                                .expect("Failed to verify signature")
-                            })
-                        {
-                            return Some(accepted.signature);
-                        }
-                    }
-                    None
-                })
-                .collect::<HashSet<_>>();
-            Ok(signatures.len() > expected_signers.len() * 7 / 10)
-        })
-    }
-
-    pub fn wait_for_block_rejections(
-        &self,
-        timeout_secs: u64,
-        expected_signers: &[StacksPublicKey],
-    ) -> Result<(), String> {
-        wait_for(timeout_secs, || {
-            let stackerdb_events = test_observer::get_stackerdb_chunks();
-            let block_rejections: HashSet<_> = stackerdb_events
-                .into_iter()
-                .flat_map(|chunk| chunk.modified_slots)
-                .filter_map(|chunk| {
-                    let message = SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
-                        .expect("Failed to deserialize SignerMessage");
-                    match message {
-                        SignerMessage::BlockResponse(BlockResponse::Rejected(rejection)) => {
-                            let rejected_pubkey = rejection
-                                .recover_public_key()
-                                .expect("Failed to recover public key from rejection");
-                            if expected_signers.contains(&rejected_pubkey) {
-                                Some(rejected_pubkey)
-                            } else {
-                                None
-                            }
-                        }
-                        _ => None,
-                    }
-                })
-                .collect::<HashSet<_>>();
-            Ok(block_rejections.len() == expected_signers.len())
-        })
-    }
-
     /// Get the latest block response from the given slot
     pub fn get_latest_block_response(&self, slot_id: u32) -> BlockResponse {
         let mut stackerdb = StackerDB::new_normal(