Merge branch 'main' into bn254

# Conflicts:
#	node/actors/consensus/src/leader/error.rs
#	node/actors/consensus/src/replica/error.rs

.github/CODEOWNERS

@@ -0,0 +1,9 @@
+CODEOWNERS @brunoffranca
+
+/node/actors/consensus/ @brunoffranca
+/node/actors/executor/ @brunoffranca @pompon0
+/node/actors/network/ @pompon0
+/node/actors/sync_blocks/ @slowli
+
+/node/libs/concurrency/ @pompon0
+/node/libs/crypto/ @brunoffranca

.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

README.md

@@ -33,4 +33,4 @@ at your option.
 - [ZK Credo](https://github.com/zksync/credo)
 - [Twitter](https://twitter.com/zksync)
 - [Twitter for Devs](https://twitter.com/zkSyncDevs)
-- [Discord](https://discord.gg/nMaPGrDDwk)
+- [Discord](https://join.zksync.dev/)

node/Cranky.toml

@@ -37,3 +37,9 @@ warn = [
   # cargo group
   "clippy::wildcard_dependencies",
 ]
+
+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,49 @@
 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;
 
+/// Errors that can occur when processing a "replica commit" message.
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum Error {
+    /// Unexpected proposal.
+    #[error("unexpected proposal")]
+    UnexpectedProposal,
+    /// Past view or phase.
+    #[error("past view/phase (current view: {current_view:?}, current phase: {current_phase:?})")]
+    Old {
+        /// Current view.
+        current_view: validator::ViewNumber,
+        /// Current phase.
+        current_phase: validator::Phase,
+    },
+    /// The processing node is not a lead for this message's view.
+    #[error("we are not a leader for this message's view")]
+    NotLeaderInView,
+    /// Duplicate message from a replica.
+    #[error("duplicate message from a replica (existing message: {existing_message:?}")]
+    DuplicateMessage {
+        /// Existing message from the same replica.
+        existing_message: validator::ReplicaCommit,
+    },
+    /// Number of received messages is below threshold.
+    #[error(
+        "number of received messages is below threshold. waiting for more (received: {num_messages:?}, \
+         threshold: {threshold:?}"
+    )]
+    NumReceivedBelowThreshold {
+        /// Number of received messages.
+        num_messages: usize,
+        /// Threshold for message count.
+        threshold: usize,
+    },
+    /// Invalid message signature.
+    #[error("invalid signature: {0:#}")]
+    InvalidSignature(#[source] crypto::bls12_381::Error),
+}
+
 impl StateMachine {
     #[instrument(level = "trace", ret)]
     pub(crate) fn process_replica_commit(
@@ -21,15 +60,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 +77,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 +107,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 +147,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,
         };