feat: implemented BlockHeader (BFT-357)

.github/workflows/protobuf_conformance.yaml

@@ -18,13 +18,13 @@ jobs:
   conformance:
     runs-on: [ubuntu-22.04-github-hosted-16core]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           path: "this"
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           repository: "protocolbuffers/protobuf"
-          ref: "main"
+          ref: "v24.4"
           path: "protobuf"
       - uses: mozilla-actions/[email protected]
       - name: build test

node/Cranky.toml

@@ -41,4 +41,5 @@ warn = [
 allow = [
   # Produces too many false positives.
   "clippy::redundant_locals",
+  "clippy::needless_pass_by_ref_mut",
 ]

node/actors/consensus/src/leader/mod.rs

@@ -2,7 +2,6 @@
 //! and aggregates replica messages. It mainly acts as a central point of communication for the replicas. Note that
 //! our consensus node will perform both the replica and leader roles simultaneously.
 
-mod error;
 mod replica_commit;
 mod replica_prepare;
 mod state_machine;

node/actors/consensus/src/leader/replica_commit.rs

@@ -1,10 +1,35 @@
 use super::StateMachine;
-use crate::{inner::ConsensusInner, leader::error::Error, metrics};
+use crate::{inner::ConsensusInner, metrics};
 use concurrency::{ctx, metrics::LatencyHistogramExt as _};
 use network::io::{ConsensusInputMessage, Target};
 use roles::validator;
 use tracing::instrument;
 
+#[derive(thiserror::Error, Debug)]
+#[allow(clippy::missing_docs_in_private_items)]
+pub(crate) enum Error {
+    #[error("unexpected proposal")]
+    UnexpectedProposal,
+    #[error("past view/phase (current view: {current_view:?}, current phase: {current_phase:?})")]
+    Old {
+        current_view: validator::ViewNumber,
+        current_phase: validator::Phase,
+    },
+    #[error("we are not a leader for this message's view")]
+    NotLeaderInView,
+    #[error("duplicate message from a replica (existing message: {existing_message:?}")]
+    DuplicateMessage {
+        existing_message: validator::ReplicaCommit,
+    },
+    #[error("number of received messages is below threshold. waiting for more (received: {num_messages:?}, threshold: {threshold:?}")]
+    NumReceivedBelowThreshold {
+        num_messages: usize,
+        threshold: usize,
+    },
+    #[error("invalid signature: {0:#}")]
+    InvalidSignature(#[source] crypto::bls12_381::Error),
+}
+
 impl StateMachine {
     #[instrument(level = "trace", ret)]
     pub(crate) fn process_replica_commit(
@@ -21,15 +46,15 @@ impl StateMachine {
 
         // If the message is from the "past", we discard it.
         if (message.view, validator::Phase::Commit) < (self.view, self.phase) {
-            return Err(Error::ReplicaCommitOld {
+            return Err(Error::Old {
                 current_view: self.view,
                 current_phase: self.phase,
             });
         }
 
         // If the message is for a view when we are not a leader, we discard it.
         if consensus.view_leader(message.view) != consensus.secret_key.public() {
-            return Err(Error::ReplicaCommitWhenNotLeaderInView);
+            return Err(Error::NotLeaderInView);
         }
 
         // If we already have a message from the same validator and for the same view, we discard it.
@@ -38,24 +63,22 @@ impl StateMachine {
             .get(&message.view)
             .and_then(|x| x.get(author))
         {
-            return Err(Error::ReplicaCommitExists {
-                existing_message: format!("{:?}", existing_message),
+            return Err(Error::DuplicateMessage {
+                existing_message: existing_message.msg,
             });
         }
 
         // ----------- Checking the signed part of the message --------------
 
         // Check the signature on the message.
-        signed_message
-            .verify()
-            .map_err(Error::ReplicaCommitInvalidSignature)?;
+        signed_message.verify().map_err(Error::InvalidSignature)?;
 
         // ----------- Checking the contents of the message --------------
 
         // We only accept replica commit messages for proposals that we have cached. That's so
         // we don't need to store replica commit messages for different proposals.
-        if self.block_proposal_cache != Some(message) {
-            return Err(Error::ReplicaCommitMissingProposal);
+        if self.block_proposal_cache != Some(message.proposal) {
+            return Err(Error::UnexpectedProposal);
         }
 
         // ----------- All checks finished. Now we process the message. --------------
@@ -70,7 +93,7 @@ impl StateMachine {
         let num_messages = self.commit_message_cache.get(&message.view).unwrap().len();
 
         if num_messages < consensus.threshold() {
-            return Err(Error::ReplicaCommitNumReceivedBelowThreshold {
+            return Err(Error::NumReceivedBelowThreshold {
                 num_messages,
                 threshold: consensus.threshold(),
             });
@@ -110,7 +133,10 @@ impl StateMachine {
             message: consensus
                 .secret_key
                 .sign_msg(validator::ConsensusMsg::LeaderCommit(
-                    validator::LeaderCommit { justification },
+                    validator::LeaderCommit {
+                        protocol_version: validator::CURRENT_VERSION,
+                        justification,
+                    },
                 )),
             recipient: Target::Broadcast,
         };