Add bls signature and rank to vote (#87)

* Rename BlsMessage to BLSMessage to be consistent.

* We need pubkey and signature for all BLS messages.

* Add serialize and deserialize.

Author: wen-coding

program/src/bls_message.rs

@@ -13,21 +13,47 @@ use {
     solana_program::clock::Slot,
 };
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Copy, Debug, PartialEq)]
+/// BLS message vote data, we need rank to look up pubkey
+pub struct BLSMessageVoteData {
+    /// The vote
+    pub vote: Vote,
+    /// The rank of the validator
+    pub rank: u16,
+}
+
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, PartialEq)]
 #[allow(clippy::large_enum_variant)]
-/// BLS message type in Alpenglow
-pub enum BLSMessage {
-    /// Vote message
-    Vote(Vote),
+/// BLS message data in Alpenglow
+pub enum BLSMessageData {
+    /// Vote message, with the vote and the rank of the validator.
+    Vote(BLSMessageVoteData),
     /// Certificate message
     Certificate(Certificate),
 }
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Debug, PartialEq)]
+/// BLS message to be sent all to all in Alpenglow
+pub struct BLSMessage {
+    /// The message data
+    pub message_data: BLSMessageData,
+    /// The signature of the message
+    pub signature: BLSSignature,
+}
+
 impl BLSMessage {
     /// Create a new vote message
-    pub fn new_vote(vote: Vote) -> Self {
-        Self::Vote(vote)
+    pub fn new_vote(vote: Vote, my_rank: u16, signature: BLSSignature) -> Self {
+        Self {
+            message_data: BLSMessageData::Vote(BLSMessageVoteData {
+                vote,
+                rank: my_rank,
+            }),
+            signature,
+        }
     }
 
     /// Create a new certificate message
@@ -36,16 +62,30 @@ impl BLSMessage {
         slot: Slot,
         block_id: Option<Hash>,
         replayed_bank_hash: Option<Hash>,
-        signature: BLSSignature,
         bitmap: BitVec<u8, Lsb0>,
+        signature: BLSSignature,
     ) -> Self {
-        Self::Certificate(Certificate {
-            certificate_type,
-            slot,
-            block_id,
-            replayed_bank_hash,
+        Self {
+            message_data: BLSMessageData::Certificate(Certificate {
+                certificate_type,
+                slot,
+                block_id,
+                replayed_bank_hash,
+                bitmap,
+            }),
             signature,
-            bitmap,
-        })
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    /// Deserialize a BLS message from bytes
+    pub fn deserialize(bls_message_in_bytes: &[u8]) -> Self {
+        bincode::deserialize(bls_message_in_bytes).unwrap()
+    }
+
+    #[cfg(feature = "serde")]
+    /// Serialize a BLS message to bytes
+    pub fn serialize(&self) -> Vec<u8> {
+        bincode::serialize(self).unwrap()
     }
 }

program/src/certificate.rs

@@ -2,10 +2,7 @@
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use {
-    bitvec::prelude::*, solana_bls::Signature as BLSSignature, solana_hash::Hash,
-    solana_program::clock::Slot,
-};
+use {bitvec::prelude::*, solana_hash::Hash, solana_program::clock::Slot};
 
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -35,8 +32,6 @@ pub struct Certificate {
     pub block_id: Option<Hash>,
     /// The bank hash of the block
     pub replayed_bank_hash: Option<Hash>,
-    /// The signature
-    pub signature: BLSSignature,
     /// The bitmap for validators, little endian byte order
     pub bitmap: BitVec<u8, Lsb0>,
 }