[consensus] Remove all the warnings (#14178)

Many devs have missed these warnings, and it properly deletes or
moves code to test only code.

consensus/src/block_storage/block_store.rs

@@ -513,6 +513,7 @@ impl BlockReader for BlockStore {
         self.inner.read().path_from_commit_root(block_id)
     }
 
+    #[cfg(test)]
     fn highest_certified_block(&self) -> Arc<PipelinedBlock> {
         self.inner.read().highest_certified_block()
     }

consensus/src/block_storage/mod.rs

@@ -48,6 +48,7 @@ pub trait BlockReader: Send + Sync {
     fn path_from_commit_root(&self, block_id: HashValue) -> Option<Vec<Arc<PipelinedBlock>>>;
 
     /// Return the certified block with the highest round.
+    #[cfg(test)]
     fn highest_certified_block(&self) -> Arc<PipelinedBlock>;
 
     /// Return the quorum certificate with the highest round

consensus/src/epoch_manager.rs

@@ -1798,7 +1798,7 @@ fn load_dkg_decrypt_key(
 }
 
 #[derive(Debug)]
-enum NoRandomnessReason {
+pub enum NoRandomnessReason {
     VTxnDisabled,
     FeatureDisabled,
     DKGStateResourceMissing(anyhow::Error),
@@ -1813,4 +1813,5 @@ enum NoRandomnessReason {
     KeyPairDeserializationError(bcs::Error),
     KeyPairSerializationError(bcs::Error),
     KeyPairPersistError(anyhow::Error),
+    // Test only reasons
 }

consensus/src/network.rs

@@ -170,17 +170,13 @@ pub struct NetworkReceivers {
 
 #[async_trait::async_trait]
 pub trait QuorumStoreSender: Send + Clone {
-    async fn send_batch_request(&self, request: BatchRequest, recipients: Vec<Author>);
-
     async fn request_batch(
         &self,
         request: BatchRequest,
         recipient: Author,
         timeout: Duration,
     ) -> anyhow::Result<BatchResponse>;
 
-    async fn send_batch(&self, batch: Batch, recipients: Vec<Author>);
-
     async fn send_signed_batch_info_msg(
         &self,
         signed_batch_infos: Vec<SignedBatchInfo>,
@@ -474,12 +470,6 @@ impl NetworkSender {
 
 #[async_trait::async_trait]
 impl QuorumStoreSender for NetworkSender {
-    async fn send_batch_request(&self, request: BatchRequest, recipients: Vec<Author>) {
-        fail_point!("consensus::send::batch_request", |_| ());
-        let msg = ConsensusMsg::BatchRequestMsg(Box::new(request));
-        self.send(msg, recipients).await
-    }
-
     async fn request_batch(
         &self,
         request: BatchRequest,
@@ -506,12 +496,6 @@ impl QuorumStoreSender for NetworkSender {
         }
     }
 
-    async fn send_batch(&self, batch: Batch, recipients: Vec<Author>) {
-        fail_point!("consensus::send::batch", |_| ());
-        let msg = ConsensusMsg::BatchResponse(Box::new(batch));
-        self.send(msg, recipients).await
-    }
-
     async fn send_signed_batch_info_msg(
         &self,
         signed_batch_infos: Vec<SignedBatchInfo>,

consensus/src/payload_client/mod.rs

@@ -30,6 +30,4 @@ pub trait PayloadClient: Send + Sync {
         recent_max_fill_fraction: f32,
         block_timestamp: Duration,
     ) -> anyhow::Result<(Vec<ValidatorTransaction>, Payload), QuorumStoreError>;
-
-    fn trace_payloads(&self) {}
 }

consensus/src/quorum_store/quorum_store_db.rs

@@ -122,41 +122,53 @@ impl QuorumStoreStorage for QuorumStoreDB {
     }
 }
 
-pub(crate) struct MockQuorumStoreDB {}
+#[cfg(test)]
+pub(crate) use mock::MockQuorumStoreDB;
 
-impl MockQuorumStoreDB {
-    #[cfg(test)]
-    pub fn new() -> Self {
-        Self {}
-    }
-}
+#[cfg(test)]
+pub mod mock {
+    use super::*;
+    pub struct MockQuorumStoreDB {}
 
-impl QuorumStoreStorage for MockQuorumStoreDB {
-    fn delete_batches(&self, _: Vec<HashValue>) -> Result<(), DbError> {
-        Ok(())
+    impl MockQuorumStoreDB {
+        pub fn new() -> Self {
+            Self {}
+        }
     }
 
-    fn get_all_batches(&self) -> Result<HashMap<HashValue, PersistedValue>> {
-        Ok(HashMap::new())
+    impl Default for MockQuorumStoreDB {
+        fn default() -> Self {
+            Self::new()
+        }
     }
 
-    fn save_batch(&self, _: PersistedValue) -> Result<(), DbError> {
-        Ok(())
-    }
+    impl QuorumStoreStorage for MockQuorumStoreDB {
+        fn delete_batches(&self, _: Vec<HashValue>) -> Result<(), DbError> {
+            Ok(())
+        }
 
-    fn get_batch(&self, _: &HashValue) -> Result<Option<PersistedValue>, DbError> {
-        Ok(None)
-    }
+        fn get_all_batches(&self) -> Result<HashMap<HashValue, PersistedValue>> {
+            Ok(HashMap::new())
+        }
 
-    fn delete_batch_id(&self, _: u64) -> Result<(), DbError> {
-        Ok(())
-    }
+        fn save_batch(&self, _: PersistedValue) -> Result<(), DbError> {
+            Ok(())
+        }
 
-    fn clean_and_get_batch_id(&self, _: u64) -> Result<Option<BatchId>, DbError> {
-        Ok(Some(BatchId::new_for_test(0)))
-    }
+        fn get_batch(&self, _: &HashValue) -> Result<Option<PersistedValue>, DbError> {
+            Ok(None)
+        }
 
-    fn save_batch_id(&self, _: u64, _: BatchId) -> Result<(), DbError> {
-        Ok(())
+        fn delete_batch_id(&self, _: u64) -> Result<(), DbError> {
+            Ok(())
+        }
+
+        fn clean_and_get_batch_id(&self, _: u64) -> Result<Option<BatchId>, DbError> {
+            Ok(Some(BatchId::new_for_test(0)))
+        }
+
+        fn save_batch_id(&self, _: u64, _: BatchId) -> Result<(), DbError> {
+            Ok(())
+        }
     }
 }

consensus/src/quorum_store/tests/batch_requester_test.rs

@@ -37,10 +37,6 @@ impl MockBatchRequester {
 
 #[async_trait::async_trait]
 impl QuorumStoreSender for MockBatchRequester {
-    async fn send_batch_request(&self, _request: BatchRequest, _recipients: Vec<Author>) {
-        unimplemented!()
-    }
-
     async fn request_batch(
         &self,
         _request: BatchRequest,
@@ -50,10 +46,6 @@ impl QuorumStoreSender for MockBatchRequester {
         Ok(self.return_value.clone())
     }
 
-    async fn send_batch(&self, _batch: Batch, _recipients: Vec<Author>) {
-        unimplemented!()
-    }
-
     async fn send_signed_batch_info_msg(
         &self,
         _signed_batch_infos: Vec<SignedBatchInfo>,

consensus/src/quorum_store/utils.rs

@@ -256,6 +256,7 @@ impl ProofQueue {
         }
     }
 
+    #[cfg(test)]
     pub(crate) fn batch_summaries_len(&self) -> usize {
         self.batch_summaries.len()
     }

consensus/src/state_replication.rs

@@ -3,11 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    error::StateSyncError,
-    payload_manager::TPayloadManager,
-    state_computer::{PipelineExecutionResult, StateComputeResultFut},
-    transaction_deduper::TransactionDeduper,
-    transaction_shuffler::TransactionShuffler,
+    error::StateSyncError, payload_manager::TPayloadManager, state_computer::StateComputeResultFut,
+    transaction_deduper::TransactionDeduper, transaction_shuffler::TransactionShuffler,
 };
 use anyhow::Result;
 use aptos_consensus_types::{block::Block, pipelined_block::PipelinedBlock};
@@ -27,22 +24,6 @@ pub type StateComputerCommitCallBackType =
 /// StateComputer is using proposed block ids for identifying the transactions.
 #[async_trait::async_trait]
 pub trait StateComputer: Send + Sync {
-    /// How to execute a sequence of transactions and obtain the next state. While some of the
-    /// transactions succeed, some of them can fail.
-    /// In case all the transactions are failed, new_state_id is equal to the previous state id.
-    async fn compute(
-        &self,
-        // The block that will be computed.
-        block: &Block,
-        // The parent block root hash.
-        parent_block_id: HashValue,
-        randomness: Option<Randomness>,
-    ) -> ExecutorResult<PipelineExecutionResult> {
-        self.schedule_compute(block, parent_block_id, randomness)
-            .await
-            .await
-    }
-
     async fn schedule_compute(
         &self,
         // The block that will be computed.

consensus/src/test_utils/mock_quorum_store_sender.rs

@@ -26,13 +26,6 @@ impl MockQuorumStoreSender {
 
 #[async_trait::async_trait]
 impl QuorumStoreSender for MockQuorumStoreSender {
-    async fn send_batch_request(&self, request: BatchRequest, recipients: Vec<Author>) {
-        self.tx
-            .send((ConsensusMsg::BatchRequestMsg(Box::new(request)), recipients))
-            .await
-            .expect("could not send");
-    }
-
     async fn request_batch(
         &self,
         _request: BatchRequest,
@@ -42,13 +35,6 @@ impl QuorumStoreSender for MockQuorumStoreSender {
         unimplemented!();
     }
 
-    async fn send_batch(&self, batch: Batch, recipients: Vec<Author>) {
-        self.tx
-            .send((ConsensusMsg::BatchResponse(Box::new(batch)), recipients))
-            .await
-            .expect("could not send");
-    }
-
     async fn send_signed_batch_info_msg(
         &self,
         signed_batch_infos: Vec<SignedBatchInfo>,

consensus/src/test_utils/mock_state_computer.rs

@@ -36,19 +36,6 @@ impl EmptyStateComputer {
 
 #[async_trait::async_trait]
 impl StateComputer for EmptyStateComputer {
-    async fn compute(
-        &self,
-        _block: &Block,
-        _parent_block_id: HashValue,
-        _randomness: Option<Randomness>,
-    ) -> ExecutorResult<PipelineExecutionResult> {
-        Ok(PipelineExecutionResult::new(
-            vec![],
-            StateComputeResult::new_dummy(),
-            Duration::from_secs(0),
-        ))
-    }
-
     async fn commit(
         &self,
         blocks: &[Arc<PipelinedBlock>],