feat(consensus): add Vote message to proto

crates/papyrus_protobuf/src/consensus.rs

@@ -10,7 +10,22 @@ pub struct Proposal {
     pub block_hash: BlockHash,
 }
 
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum VoteType {
+    Prevote,
+    Precommit,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Vote {
+    pub vote_type: VoteType,
+    pub height: u64,
+    pub block_hash: BlockHash,
+    pub voter: ContractAddress,
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum ConsensusMessage {
     Proposal(Proposal),
+    Vote(Vote),
 }

crates/papyrus_protobuf/src/converters/consensus.rs

@@ -5,7 +5,7 @@ use starknet_api::block::BlockHash;
 use starknet_api::hash::StarkHash;
 use starknet_api::transaction::Transaction;
 
-use crate::consensus::{ConsensusMessage, Proposal};
+use crate::consensus::{ConsensusMessage, Proposal, Vote, VoteType};
 use crate::converters::ProtobufConversionError;
 use crate::{auto_impl_into_and_try_from_vec_u8, protobuf};
 
@@ -20,7 +20,7 @@ impl TryFrom<protobuf::Proposal> for Proposal {
             .collect::<Result<Vec<Transaction>, ProtobufConversionError>>()?;
 
         let height = value.height;
-        let contract_address = value
+        let proposer = value
             .proposer
             .ok_or(ProtobufConversionError::MissingField { field_description: "proposer" })?
             .try_into()?;
@@ -30,7 +30,7 @@ impl TryFrom<protobuf::Proposal> for Proposal {
             .try_into()?;
         let block_hash = BlockHash(block_hash);
 
-        Ok(Proposal { height, proposer: contract_address, transactions, block_hash })
+        Ok(Proposal { height, proposer, transactions, block_hash })
     }
 }
 
@@ -47,6 +47,63 @@ impl From<Proposal> for protobuf::Proposal {
     }
 }
 
+impl TryFrom<protobuf::vote::VoteType> for VoteType {
+    type Error = ProtobufConversionError;
+
+    fn try_from(value: protobuf::vote::VoteType) -> Result<Self, Self::Error> {
+        match value {
+            protobuf::vote::VoteType::Prevote => Ok(VoteType::Prevote),
+            protobuf::vote::VoteType::Precommit => Ok(VoteType::Precommit),
+        }
+    }
+}
+
+impl From<VoteType> for protobuf::vote::VoteType {
+    fn from(value: VoteType) -> Self {
+        match value {
+            VoteType::Prevote => protobuf::vote::VoteType::Prevote,
+            VoteType::Precommit => protobuf::vote::VoteType::Precommit,
+        }
+    }
+}
+
+impl TryFrom<protobuf::Vote> for Vote {
+    type Error = ProtobufConversionError;
+
+    fn try_from(value: protobuf::Vote) -> Result<Self, Self::Error> {
+        let vote_type = protobuf::vote::VoteType::try_from(value.vote_type)?.try_into()?;
+
+        let height = value.height;
+        let block_hash: StarkHash = value
+            .block_hash
+            .ok_or(ProtobufConversionError::MissingField { field_description: "block_hash" })?
+            .try_into()?;
+        let block_hash = BlockHash(block_hash);
+        let voter = value
+            .voter
+            .ok_or(ProtobufConversionError::MissingField { field_description: "voter" })?
+            .try_into()?;
+
+        Ok(Vote { vote_type, height, block_hash, voter })
+    }
+}
+
+impl From<Vote> for protobuf::Vote {
+    fn from(value: Vote) -> Self {
+        let vote_type = match value.vote_type {
+            VoteType::Prevote => protobuf::vote::VoteType::Prevote,
+            VoteType::Precommit => protobuf::vote::VoteType::Precommit,
+        };
+
+        protobuf::Vote {
+            vote_type: vote_type as i32,
+            height: value.height,
+            block_hash: Some(value.block_hash.0.into()),
+            voter: Some(value.voter.into()),
+        }
+    }
+}
+
 impl TryFrom<protobuf::ConsensusMessage> for ConsensusMessage {
     type Error = ProtobufConversionError;
 
@@ -59,6 +116,7 @@ impl TryFrom<protobuf::ConsensusMessage> for ConsensusMessage {
 
         match message {
             Message::Proposal(proposal) => Ok(ConsensusMessage::Proposal(proposal.try_into()?)),
+            Message::Vote(vote) => Ok(ConsensusMessage::Vote(vote.try_into()?)),
         }
     }
 }
@@ -69,6 +127,9 @@ impl From<ConsensusMessage> for protobuf::ConsensusMessage {
             ConsensusMessage::Proposal(proposal) => protobuf::ConsensusMessage {
                 message: Some(protobuf::consensus_message::Message::Proposal(proposal.into())),
             },
+            ConsensusMessage::Vote(vote) => protobuf::ConsensusMessage {
+                message: Some(protobuf::consensus_message::Message::Vote(vote.into())),
+            },
         }
     }
 }

crates/papyrus_protobuf/src/proto/p2p/proto/consensus.proto

@@ -3,14 +3,31 @@ import "p2p/proto/transaction.proto";
 import "p2p/proto/common.proto";
 
 message Proposal {
-    uint64 height = 1;
-    Address proposer = 2;
+    uint64               height       = 1;
+    Address              proposer     = 2;
     repeated Transaction transactions = 3;
-    Hash block_hash = 4;
+    Hash                 block_hash   = 4;
+}
+
+message Vote {
+    enum  VoteType {
+        Prevote   = 0;
+        Precommit = 1;
+    };
+
+    // We use a type field to distinguish between prevotes and precommits instead of different
+    // messages, to make sure the data, and therefore the signatures, are unambiguous between
+    // Prevote and Precommit.
+    VoteType      vote_type  = 2;
+    uint64        height     = 3;
+    // This is optional since a vote can be NIL.
+    optional Hash block_hash = 4;
+    Address       voter      = 5;
 }
 
 message ConsensusMessage {
     oneof message {
         Proposal proposal = 1;
+        Vote     vote     = 2;
     }
 }

crates/sequencing/papyrus_consensus/src/lib.rs

@@ -55,7 +55,10 @@ where
                 .await
                 .expect("Failed to receive a message from network")
                 .0
-                .expect("Network receiver closed unexpectedly");
+                .expect("Network receiver closed unexpectedly")
+            else {
+                todo!("Handle votes");
+            };
             let (proposal_init, content_receiver, fin_receiver) = ProposalWrapper(proposal).into();
 
             shc.handle_proposal(proposal_init, content_receiver, fin_receiver)