[WIP] chore: add logging to understand active validator set on read node

src/consensus/malachite/read_sync.rs

@@ -20,6 +20,7 @@ use informalsystems_malachitebft_engine::util::ticker::ticker;
 use informalsystems_malachitebft_engine::util::timers::{TimeoutElapsed, TimerScheduler};
 
 use crate::core::types::SnapchainValidatorContext;
+use crate::core::CommitsExt;
 use crate::proto::{self, Height};
 
 use super::read_host::{ReadHostMsg, ReadHostRef};
@@ -345,14 +346,18 @@ impl ReadSync {
                         let decided_value = value_response.value.as_ref().unwrap();
                         let value_bytes =
                             value_response.value.as_ref().unwrap().value_bytes.as_ref();
+
+                        let commits =
+                            proto::Commits::from_commit_certificate(&decided_value.certificate);
+
                         let value = if decided_value.certificate.value_id.shard_index == 0 {
-                            proto::decided_value::Value::Block(
-                                proto::Block::decode(value_bytes).unwrap(),
-                            )
+                            let mut block = proto::Block::decode(value_bytes).unwrap();
+                            block.commits = Some(commits);
+                            proto::decided_value::Value::Block(block)
                         } else {
-                            proto::decided_value::Value::Shard(
-                                proto::ShardChunk::decode(value_bytes).unwrap(),
-                            )
+                            let mut shard_chunk = proto::ShardChunk::decode(value_bytes).unwrap();
+                            shard_chunk.commits = Some(commits);
+                            proto::decided_value::Value::Shard(shard_chunk)
                         };
                         debug!(peer_id = %peer, height = %decided_value.certificate.height, "Received sync value response");
                         self.host.cast(ReadHostMsg::ProcessDecidedValue {

src/consensus/malachite/spawn_read_node.rs

@@ -30,10 +30,24 @@ pub async fn spawn_read_host(
     config: Config,
 ) -> Result<ReadHostRef, ractor::SpawnErr> {
     let validator_set_config = config.get_validator_set_config(shard_id);
-    let validator_sets = validator_set_config
+    let validator_sets: Vec<StoredValidatorSet> = validator_set_config
         .iter()
         .map(|config| StoredValidatorSet::new(ShardId::new(shard_id), &config))
         .collect();
+
+    tracing::info!(
+        shard_id,
+        validator_sets = ?validator_sets.iter().map(|vs| {
+            format!(
+                "effective_at: {}, validators: {:#?}, shard_ids: {:?}",
+                vs.effective_at,
+                vs.validators.validators.iter().map(|v| hex::encode(v.public_key.to_bytes())).collect::<Vec<_>>(),
+                vs.shard_ids
+            )
+        }).collect::<Vec<_>>(),
+        "Initializing read node with validator sets"
+    );
+
     let state = ReadHostState {
         validator: read_validator::ReadValidator {
             shard_id,

src/consensus/read_validator.rs

@@ -150,6 +150,7 @@ impl ReadValidator {
     }
 
     pub async fn process_decided_value(&mut self, value: DecidedValue) -> u64 {
+        info!("Processing decided value {:#?}", value);
         let height = Self::get_decided_value_height(&value);
         let verified = self.verify_signatures(&value);
         if !verified {

src/core/util.rs

@@ -5,7 +5,6 @@ use crate::consensus::validator::StoredValidatorSets;
 use crate::core::error::HubError;
 use crate::core::types::{CommitsExt, Vote, FARCASTER_EPOCH};
 use crate::proto::{self};
-use itertools::Itertools;
 use tracing::error;
 
 #[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
@@ -104,23 +103,39 @@ pub fn verify_signatures(commits: &proto::Commits, validator_sets: &StoredValida
 
     let validator_set = validator_sets.get_validator_set(certificate.height.as_u64());
 
-    let mut expected_pubkeys = validator_set
+    let expected_pubkeys: Vec<[u8; 32]> = validator_set
         .validators
         .iter()
-        .map(|validator| validator.public_key.to_bytes());
+        .map(|validator| validator.public_key.to_bytes())
+        .collect();
 
     if !ThresholdParams::default().quorum.is_met(
         certificate.aggregated_signature.signatures.len() as u64,
         expected_pubkeys.len() as u64,
     ) {
-        error!(%certificate.height, "Block did not have quorum");
+        error!(
+            %certificate.height,
+            num_signatures_in_commits = commits.signatures.len(),
+            num_signatures_in_certificate = certificate.aggregated_signature.signatures.len(),
+            num_validators = expected_pubkeys.len(),
+            expected_validators = ?expected_pubkeys.iter().map(|v| hex::encode(v)).collect::<Vec<_>>(),
+            actual_signers_in_commits = ?commits.signatures.iter().map(|s| hex::encode(&s.signer)).collect::<Vec<_>>(),
+            actual_signers_in_certificate = ?certificate.aggregated_signature.signatures.iter().map(|s| hex::encode(&s.address.0)).collect::<Vec<_>>(),
+            "Block did not have quorum"
+        );
         return false;
     }
 
-    for signature in certificate.aggregated_signature.signatures {
+    for signature in &certificate.aggregated_signature.signatures {
         let address_bytes = &signature.address.0;
         if !expected_pubkeys.contains(address_bytes) {
-            error!(%certificate.height, "Block contained signatures from unexpected signers");
+            error!(
+                %certificate.height,
+                unexpected_signer = hex::encode(address_bytes),
+                expected_validators = ?expected_pubkeys.iter().map(|v| hex::encode(v)).collect::<Vec<_>>(),
+                actual_signers = ?certificate.aggregated_signature.signatures.iter().map(|s| hex::encode(&s.address.0)).collect::<Vec<_>>(),
+                "Block contained signatures from unexpected signers"
+            );
             return false;
         }
 
@@ -133,7 +148,13 @@ pub fn verify_signatures(commits: &proto::Commits, validator_sets: &StoredValida
 
         let public_key = PublicKey::try_from_bytes(address_bytes).unwrap();
         if !public_key.verify(&vote.to_sign_bytes(), &signature.signature.0) {
-            error!(%certificate.height, "Block contained invalid signatures");
+            error!(
+                %certificate.height,
+                invalid_signer = hex::encode(address_bytes),
+                expected_validators = ?expected_pubkeys.iter().map(|v| hex::encode(v)).collect::<Vec<_>>(),
+                actual_signers = ?certificate.aggregated_signature.signatures.iter().map(|s| hex::encode(&s.address.0)).collect::<Vec<_>>(),
+                "Block contained invalid signatures"
+            );
             return false;
         }
     }