Stateless QBFT consensus message semantic validation

anchor/client/src/lib.rs

@@ -10,7 +10,7 @@ use beacon_node_fallback::{
 };
 pub use cli::Anchor;
 use config::Config;
-use database::NetworkDatabase;
+use database::{NetworkDatabase, WatchableNetworkState};
 use eth2::reqwest::{Certificate, ClientBuilder};
 use eth2::{BeaconNodeHttpClient, Timeouts};
 use message_sender::NetworkMessageSender;
@@ -366,7 +366,11 @@ impl Client {
         )?;
 
         let (results_tx, results_rx) = mpsc::channel::<message_validator::Outcome>(9000);
-        let message_validator = Validator::new(processor_senders.clone(), results_tx);
+        let message_validator = Validator::new(
+            processor_senders.clone(),
+            results_tx,
+            Arc::new(WatchableNetworkState::new(database.watch())),
+        );
 
         // Start the p2p network
         let network = Network::try_new(

anchor/common/qbft/src/lib.rs

@@ -213,12 +213,6 @@ where
         &self,
         wrapped_msg: &WrappedQbftMessage,
     ) -> Option<(Option<ValidData<D>>, OperatorId)> {
-        // Validate the qbft message
-        if !wrapped_msg.qbft_message.validate() {
-            warn!("Invalid qbft_message");
-            return None;
-        }
-
         // Ensure that this message is for the correct round
         let current_round = self.current_round.get();
         if (wrapped_msg.qbft_message.round < current_round as u64)
@@ -250,22 +244,11 @@ where
         }
 
         // The rest of the verification only pertains to messages with one signature
-        if wrapped_msg.signed_message.operator_ids().len() != 1 {
-            // If there is more than one signer, we also have to check if this is a decided message.
-            if matches!(
-                wrapped_msg.qbft_message.qbft_message_type,
-                QbftMessageType::Commit
-            ) {
-                // Do not care about data here, just that we had a success
-                let valid_data = Some(ValidData::new(None, wrapped_msg.qbft_message.root));
-                return Some((valid_data, OperatorId::from(0)));
-            }
-            // Otherwise, this is invalid data
-            warn!(
-                num_signers = wrapped_msg.signed_message.operator_ids().len(),
-                "Message only allows one signer"
-            );
-            return None;
+        if wrapped_msg.signed_message.operator_ids().len() > 1 {
+            // The message validator already checked this is a decided message (a commit message with > 1 signers).
+            // Do not care about data here, just that we had a success
+            let valid_data = Some(ValidData::new(None, wrapped_msg.qbft_message.root));
+            return Some((valid_data, OperatorId::from(0)));
         }
 
         // Message is not a decide message, we know there is only one signer
@@ -431,12 +414,6 @@ where
             return;
         }
 
-        // Verify that the data root matches what was in the message
-        if valid_data.hash != wrapped_msg.qbft_message.root {
-            warn!(from = ?operator_id, self=?self.config.operator_id(), "Data roots do not match");
-            return;
-        }
-
         // Fulldata is included in propose messages
         let data = match valid_data.data {
             Some(data) => data,

anchor/common/ssv_types/src/consensus.rs

@@ -1,5 +1,5 @@
 use crate::message::*;
-use crate::msgid::MessageId;
+use crate::msgid::{MessageId, Role};
 use crate::ValidatorIndex;
 use sha2::{Digest, Sha256};
 use ssz::{Decode, DecodeError, Encode};
@@ -60,12 +60,12 @@ pub struct QbftMessage {
 }
 
 impl QbftMessage {
-    /// Do QBFTMessage specific validation
-    pub fn validate(&self) -> bool {
-        if self.qbft_message_type > QbftMessageType::RoundChange {
-            return false;
-        }
-        true
+    pub fn max_round(&self) -> Option<u64> {
+        self.identifier.role().and_then(|role| match role {
+            Role::Committee | Role::Aggregator => Some(12),
+            Role::Proposer | Role::SyncCommittee => Some(6),
+            _ => None,
+        })
     }
 }
 

anchor/common/ssv_types/src/lib.rs

@@ -14,4 +14,6 @@ mod share;
 mod sql_conversions;
 mod util;
 
+pub use indexmap::IndexSet;
 pub use share::ENCRYPTED_KEY_LENGTH;
+pub use types::Slot;

anchor/database/src/cluster_operations.rs

@@ -58,27 +58,30 @@ impl NetworkDatabase {
 
                 // Save the keyshare
                 state.multi_state.shares.insert(
-                    &validator.public_key, // The validator this keyshare belongs to
-                    &cluster.cluster_id,   // The id of the cluster
-                    &cluster.owner,        // The owner of the cluster
-                    share.to_owned(),      // The keyshare itself
+                    &validator.public_key,   // The validator this keyshare belongs to
+                    &cluster.cluster_id,     // The id of the cluster
+                    &cluster.owner,          // The owner of the cluster
+                    &cluster.committee_id(), // The committee id of the cluster
+                    share.to_owned(),        // The keyshare itself
                 );
             }
 
             // Save all cluster related information
             state.multi_state.clusters.insert(
-                &cluster.cluster_id,   // The id of the cluster
-                &validator.public_key, // The public key of validator added to the cluster
-                &cluster.owner,        // Owner of the cluster
-                cluster.to_owned(),    // The Cluster and all containing information
+                &cluster.cluster_id,     // The id of the cluster
+                &validator.public_key,   // The public key of validator added to the cluster
+                &cluster.owner,          // Owner of the cluster
+                &cluster.committee_id(), // The committee id of the cluster
+                cluster.to_owned(),      // The Cluster and all containing information
             );
 
             // Save the metadata for the validators
             state.multi_state.validator_metadata.insert(
-                &validator.public_key, // The public key of the validator
-                &cluster.cluster_id,   // The id of the cluster the validator belongs to
-                &cluster.owner,        // The owner of the cluster
-                validator.to_owned(),  // The metadata of the validator
+                &validator.public_key,   // The public key of the validator
+                &cluster.cluster_id,     // The id of the cluster the validator belongs to
+                &cluster.owner,          // The owner of the cluster
+                &cluster.committee_id(), // The committee id of the cluster
+                validator.to_owned(),    // The metadata of the validator
             );
         });
 

anchor/database/src/lib.rs

@@ -1,7 +1,7 @@
 use openssl::{pkey::Public, rsa::Rsa};
 use r2d2_sqlite::SqliteConnectionManager;
 use rusqlite::params;
-use ssv_types::{Cluster, ClusterId, Operator, OperatorId, Share, ValidatorMetadata};
+use ssv_types::{Cluster, ClusterId, CommitteeId, Operator, OperatorId, Share, ValidatorMetadata};
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::path::Path;
@@ -13,6 +13,7 @@ use types::{Address, PublicKeyBytes};
 pub use crate::error::DatabaseError;
 pub use crate::multi_index::{MultiIndexMap, *};
 use crate::sql_operations::{SqlStatement, SQL};
+pub use crate::state::{NetworkStateService, WatchableNetworkState};
 
 mod cluster_operations;
 mod error;
@@ -36,8 +37,16 @@ type PoolConn = r2d2::PooledConnection<SqliteConnectionManager>;
 /// Primary: public key of validator. uniquely identifies share
 /// Secondary: cluster id. corresponds to a list of shares
 /// Tertiary: owner of the cluster. corresponds to a list of shares
-pub(crate) type ShareMultiIndexMap =
-    MultiIndexMap<PublicKeyBytes, ClusterId, Address, Share, NonUniqueTag, NonUniqueTag>;
+pub(crate) type ShareMultiIndexMap = MultiIndexMap<
+    PublicKeyBytes,
+    ClusterId,
+    Address,
+    CommitteeId,
+    Share,
+    NonUniqueTag,
+    NonUniqueTag,
+    NonUniqueTag,
+>;
 /// Metadata for all validators in the network
 /// Primary: public key of the validator. uniquely identifies the metadata
 /// Secondary: cluster id. corresponds to list of metadata for all validators
@@ -46,23 +55,34 @@ pub(crate) type MetadataMultiIndexMap = MultiIndexMap<
     PublicKeyBytes,
     ClusterId,
     Address,
+    CommitteeId,
     ValidatorMetadata,
     NonUniqueTag,
     NonUniqueTag,
+    NonUniqueTag,
 >;
 /// All of the clusters in the network
 /// Primary: cluster id. uniquely identifies a cluster
 /// Secondary: public key of the validator. uniquely identifies a cluster
 /// Tertiary: owner of the cluster. uniquely identifies a cluster
-pub(crate) type ClusterMultiIndexMap =
-    MultiIndexMap<ClusterId, PublicKeyBytes, Address, Cluster, UniqueTag, UniqueTag>;
+pub(crate) type ClusterMultiIndexMap = MultiIndexMap<
+    ClusterId,
+    PublicKeyBytes,
+    Address,
+    CommitteeId,
+    Cluster,
+    UniqueTag,
+    UniqueTag,
+    NonUniqueTag,
+>;
 
 // Information that needs to be accessed via multiple different indicies
 #[derive(Debug)]
 struct MultiState {
     shares: ShareMultiIndexMap,
     validator_metadata: MetadataMultiIndexMap,
     clusters: ClusterMultiIndexMap,
+    // Be careful when adding new maps here. If you really must to, it must be updated in the operations files
 }
 
 // General information that can be single index access