feat(consensus): add an error type for consensus and utlize in Single…

…HeightConsensus

crates/sequencing/papyrus_consensus/Cargo.toml

@@ -12,6 +12,7 @@ async-trait.workspace = true
 futures.workspace = true
 starknet_api.workspace = true
 tokio = { workspace = true, features = ["full"] }
+thiserror.workspace = true
 
 [dev-dependencies]
 mockall.workspace = true

crates/sequencing/papyrus_consensus/src/single_height_consensus.rs

@@ -11,6 +11,7 @@ use starknet_api::block::BlockNumber;
 use crate::types::{
     ConsensusBlock,
     ConsensusContext,
+    ConsensusError,
     NodeId,
     PeeringConsensusMessage,
     ProposalInit,
@@ -43,30 +44,33 @@ where
         Self { height, context, validators, id, to_peering_sender, from_peering_receiver }
     }
 
-    pub(crate) async fn run(mut self) -> BlockT {
+    pub(crate) async fn run(mut self) -> Result<BlockT, ConsensusError> {
         // TODO(matan): In the future this logic will be encapsulated in the state machine, and SHC
         // will await a signal from SHC to propose.
         let proposer_id = self.context.proposer(&self.validators, self.height);
         if proposer_id == self.id { self.propose().await } else { self.validate(proposer_id).await }
     }
 
-    async fn propose(&mut self) -> BlockT {
+    async fn propose(&mut self) -> Result<BlockT, ConsensusError> {
         let (content_receiver, block_receiver) = self.context.build_proposal(self.height).await;
         let (fin_sender, fin_receiver) = oneshot::channel();
         let init = ProposalInit { height: self.height, proposer: self.id };
         self.to_peering_sender
             .send(PeeringConsensusMessage::Proposal((init, content_receiver, fin_receiver)))
-            .await
-            .expect("failed to send proposal to peering");
-        let block = block_receiver.await.expect("failed to build block");
+            .await?;
+        let block = block_receiver.await?;
         // TODO: Switch this to the Proposal signature.
-        fin_sender.send(block.id()).expect("failed to send block hash");
-        block
+        fin_sender.send(block.id()).map_err(|_| {
+            ConsensusError::Other("Failed to send block hash to Peering".to_owned())
+        })?;
+        Ok(block)
     }
 
-    async fn validate(&mut self, proposer_id: NodeId) -> BlockT {
+    async fn validate(&mut self, proposer_id: NodeId) -> Result<BlockT, ConsensusError> {
         let Some(msg) = self.from_peering_receiver.next().await else {
-            panic!("Peering component disconnected from SingleHeightConsensus");
+            return Err(ConsensusError::Other(
+                "Peering component disconnected from SingleHeightConsensus".to_owned(),
+            ));
         };
 
         let (init, content_receiver, fin_receiver) = match msg {
@@ -77,10 +81,12 @@ where
         assert_eq!(init.height, self.height);
         assert_eq!(init.proposer, proposer_id);
         let block_receiver = self.context.validate_proposal(self.height, content_receiver).await;
-        let block = block_receiver.await.expect("failed to build block");
-        let fin = fin_receiver.await.expect("failed to receive block hash");
+        let block = block_receiver.await?;
+        let fin = fin_receiver.await.map_err(|_| {
+            ConsensusError::Other("Failed to receiver block hash to Peering".to_owned())
+        })?;
         // TODO Switch to signature validation.
         assert_eq!(block.id(), fin);
-        block
+        Ok(block)
     }
 }

crates/sequencing/papyrus_consensus/src/single_height_consensus_test.rs

@@ -87,7 +87,7 @@ async fn propose() {
     let (shc, mut shc_to_peering_receiver, _) = test_fields.new_shc(BlockNumber(0), node_id).await;
 
     // This calls to `context.proposer` and `context.build_proposal`.
-    let block = shc.run().await;
+    let block = shc.run().await.unwrap();
     assert_eq!(block.id(), block_id);
 
     // Check what was sent to peering. We don't check the content stream as that is filled by
@@ -136,5 +136,5 @@ async fn validate() {
     fin_sender.send(block_id).unwrap();
 
     // This calls to `context.proposer` and `context.build_proposal`.
-    assert_eq!(shc.run().await.id(), block_id);
+    assert_eq!(shc.run().await.unwrap().id(), block_id);
 }

crates/sequencing/papyrus_consensus/src/types.rs

@@ -168,3 +168,13 @@ pub(crate) enum PeeringConsensusMessage<ProposalChunkT> {
     // TODO: Switch the oneshot channel to be a Signature when we add.
     Proposal((ProposalInit, mpsc::Receiver<ProposalChunkT>, oneshot::Receiver<BlockHash>)),
 }
+
+#[derive(thiserror::Error, Debug)]
+pub enum ConsensusError {
+    #[error(transparent)]
+    Send(#[from] mpsc::SendError),
+    #[error(transparent)]
+    Canceled(#[from] oneshot::Canceled),
+    #[error("{0}")]
+    Other(String),
+}