Get tendermint validators with CurrentValidators

Author: remagpie

core/src/consensus/stake/action_data.rs

@@ -432,6 +432,16 @@ impl CurrentValidators {
     pub fn update(&mut self, validators: Vec<Validator>) {
         self.0 = validators;
     }
+
+    pub fn addresses(&self) -> Vec<Address> {
+        self.0.iter().rev().map(|v| public_to_address(&v.pubkey)).collect()
+    }
+
+    pub fn get_validator(&self, index: usize) -> &Validator {
+        let len = self.0.len();
+        // NOTE: validator list is reversed when reading a validator by index
+        self.0.iter().nth_back(index % len).unwrap()
+    }
 }
 
 impl Deref for CurrentValidators {

core/src/consensus/tendermint/engine.rs

@@ -459,10 +459,30 @@ fn calculate_pending_rewards_of_the_previous_term(
     let mut missed_signatures = HashMap::<Address, (usize, usize)>::with_capacity(MAX_NUM_OF_VALIDATORS);
     let mut signed_blocks = HashMap::<Address, usize>::with_capacity(MAX_NUM_OF_VALIDATORS);
 
+    let era = {
+        let end_of_the_current_term_header = chain
+            .block_header(&start_of_the_current_term_header.parent_hash().into())
+            .expect("The parent of the term end block must exist");
+        let state = chain
+            .state_at(end_of_the_current_term_header.parent_hash().into())
+            .expect("The state at parent of the term end block must exist");
+        let metadata = state.metadata()?.expect("Metadata of the term end block should exist");
+        metadata.term_params().map_or(0, |p| p.era())
+    };
+
     let mut header = start_of_the_current_term_header;
     let mut parent_validators = {
-        let grand_parent_header = chain.block_header(&header.parent_hash().into()).unwrap();
-        validators.addresses(&grand_parent_header.parent_hash())
+        match era {
+            0 => {
+                let grand_parent_header = chain.block_header(&header.parent_hash().into()).unwrap();
+                validators.addresses(&grand_parent_header.parent_hash())
+            }
+            1 => {
+                let state = chain.state_at(header.parent_hash().into()).expect("The block's state must exist");
+                stake::CurrentValidators::load_from_state(&state)?.addresses()
+            }
+            _ => unimplemented!(),
+        }
     };
     while start_of_the_previous_term != header.number() {
         for index in TendermintSealView::new(&header.seal()).bitset()?.true_index_iter() {
@@ -472,10 +492,17 @@ fn calculate_pending_rewards_of_the_previous_term(
 
         header = chain.block_header(&header.parent_hash().into()).unwrap();
         parent_validators = {
-            // The seal of the current block has the signatures of the parent block.
-            // It needs the hash of the grand parent block to find the validators of the parent block.
-            let grand_parent_header = chain.block_header(&header.parent_hash().into()).unwrap();
-            validators.addresses(&grand_parent_header.parent_hash())
+            match era {
+                0 => {
+                    let grand_parent_header = chain.block_header(&header.parent_hash().into()).unwrap();
+                    validators.addresses(&grand_parent_header.parent_hash())
+                }
+                1 => {
+                    let state = chain.state_at(header.hash().into()).expect("The block's state must exist");
+                    stake::CurrentValidators::load_from_state(&state)?.addresses()
+                }
+                _ => unimplemented!(),
+            }
         };
 
         let author = header.author();

core/src/consensus/tendermint/worker.rs

@@ -35,7 +35,7 @@ use super::backup::{backup, restore, BackupView};
 use super::message::*;
 use super::network;
 use super::params::TimeGapParams;
-use super::stake::CUSTOM_ACTION_HANDLER_ID;
+use super::stake::{CurrentValidators, CUSTOM_ACTION_HANDLER_ID};
 use super::types::{Height, Proposal, Step, TendermintSealView, TendermintState, TwoThirdsMajority, View};
 use super::vote_collector::{DoubleVote, VoteCollector};
 use super::vote_regression_checker::VoteRegressionChecker;
@@ -1244,13 +1244,19 @@ impl Worker {
         };
 
         let mut voted_validators = BitSet::new();
-        let grand_parent_hash = self
-            .client()
-            .block_header(&(*header.parent_hash()).into())
-            .expect("The parent block must exist")
-            .parent_hash();
+        let parent = self.client().block_header(&(*header.parent_hash()).into()).expect("The parent block must exist");
+        let grand_parent_hash = parent.parent_hash();
         for (bitset_index, signature) in seal_view.signatures()? {
-            let public = self.validators.get(&grand_parent_hash, bitset_index);
+            let public = {
+                let state = self.client().state_at(parent.hash().into()).expect("The parent state must exist");
+                let validators = CurrentValidators::load_from_state(&state)?;
+                // This happens when era == 0
+                if validators.is_empty() {
+                    self.validators.get(&grand_parent_hash, bitset_index)
+                } else {
+                    *validators.get_validator(bitset_index).pubkey()
+                }
+            };
             if !verify_schnorr(&public, &signature, &precommit_vote_on.hash())? {
                 let address = public_to_address(&public);
                 return Err(EngineError::BlockNotAuthorized(address.to_owned()).into())
@@ -1263,7 +1269,7 @@ impl Worker {
         if header.number() == 1 {
             return Ok(())
         }
-        self.validators.check_enough_votes(&grand_parent_hash, &voted_validators)?;
+        self.validators.check_enough_votes_with_header(&parent.decode(), &voted_validators)?;
         Ok(())
     }
 

core/src/consensus/validator_set/dynamic_validator.rs

@@ -18,13 +18,13 @@ use std::sync::{Arc, Weak};
 
 use ckey::{public_to_address, Address, Public};
 use ctypes::util::unexpected::OutOfBounds;
-use ctypes::BlockHash;
+use ctypes::{BlockHash, Header};
 use parking_lot::RwLock;
 
 use super::{RoundRobinValidator, ValidatorSet};
 use crate::client::ConsensusClient;
 use crate::consensus::bit_set::BitSet;
-use crate::consensus::stake::{get_validators, Validator};
+use crate::consensus::stake::{get_validators, CurrentValidators, Validator};
 use crate::consensus::EngineError;
 
 /// Validator set containing a known set of public keys.
@@ -41,7 +41,7 @@ impl DynamicValidator {
         }
     }
 
-    fn validators(&self, parent: BlockHash) -> Option<Vec<Validator>> {
+    fn next_validators(&self, parent: BlockHash) -> Option<Vec<Validator>> {
         let client: Arc<dyn ConsensusClient> =
             self.client.read().as_ref().and_then(Weak::upgrade).expect("Client is not initialized");
         let block_id = parent.into();
@@ -64,19 +64,84 @@ impl DynamicValidator {
         }
     }
 
+    fn current_validators(&self, hash: BlockHash) -> Option<Vec<Validator>> {
+        let client: Arc<dyn ConsensusClient> =
+            self.client.read().as_ref().and_then(Weak::upgrade).expect("Client is not initialized");
+        let block_id = hash.into();
+        let term_id = client.current_term_id(block_id).expect(
+            "valdators() is called when creating a block or verifying a block.
+            Minor creates a block only when the parent block is imported.
+            The n'th block is verified only when the parent block is imported.",
+        );
+        if term_id == 0 {
+            return None
+        }
+        let state = client.state_at(block_id)?;
+        let validators = CurrentValidators::load_from_state(&state).unwrap();
+        if validators.is_empty() {
+            None
+        } else {
+            let mut validators: Vec<_> = (*validators).clone();
+            validators.reverse();
+            Some(validators)
+        }
+    }
+
     fn validators_pubkey(&self, parent: BlockHash) -> Option<Vec<Public>> {
-        self.validators(parent).map(|validators| validators.into_iter().map(|val| *val.pubkey()).collect())
+        self.next_validators(parent).map(|validators| validators.into_iter().map(|val| *val.pubkey()).collect())
     }
 
     pub fn proposer_index(&self, parent: BlockHash, prev_proposer_index: usize, proposed_view: usize) -> usize {
-        if let Some(validators) = self.validators(parent) {
+        if let Some(validators) = self.next_validators(parent) {
             let num_validators = validators.len();
             proposed_view % num_validators
         } else {
             let num_validators = self.initial_list.count(&parent);
             (prev_proposer_index + proposed_view + 1) % num_validators
         }
     }
+
+    pub fn check_enough_votes_with_validators(
+        &self,
+        validators: &[Validator],
+        votes: &BitSet,
+    ) -> Result<(), EngineError> {
+        let mut voted_delegation = 0u64;
+        let n_validators = validators.len();
+        for index in votes.true_index_iter() {
+            assert!(index < n_validators);
+            let validator = validators.get(index).ok_or_else(|| {
+                EngineError::ValidatorNotExist {
+                    height: 0, // FIXME
+                    index,
+                }
+            })?;
+            voted_delegation += validator.delegation();
+        }
+        let total_delegation: u64 = validators.iter().map(Validator::delegation).sum();
+        if voted_delegation * 3 > total_delegation * 2 {
+            Ok(())
+        } else {
+            let threshold = total_delegation as usize * 2 / 3;
+            Err(EngineError::BadSealFieldSize(OutOfBounds {
+                min: Some(threshold),
+                max: Some(total_delegation as usize),
+                found: voted_delegation as usize,
+            }))
+        }
+    }
+
+    pub fn check_enough_votes_with_header(&self, header: &Header, votes: &BitSet) -> Result<(), EngineError> {
+        let hash = header.hash();
+        let parent = *header.parent_hash();
+        let validators = self.current_validators(hash).or_else(move || self.next_validators(parent));
+
+        if let Some(validators) = validators {
+            self.check_enough_votes_with_validators(&validators, votes)
+        } else {
+            self.initial_list.check_enough_votes(header.parent_hash(), votes)
+        }
+    }
 }
 
 impl ValidatorSet for DynamicValidator {
@@ -136,38 +201,16 @@ impl ValidatorSet for DynamicValidator {
     }
 
     fn count(&self, parent: &BlockHash) -> usize {
-        if let Some(validators) = self.validators(*parent) {
+        if let Some(validators) = self.next_validators(*parent) {
             validators.len()
         } else {
             self.initial_list.count(parent)
         }
     }
 
     fn check_enough_votes(&self, parent: &BlockHash, votes: &BitSet) -> Result<(), EngineError> {
-        if let Some(validators) = self.validators(*parent) {
-            let mut voted_delegation = 0u64;
-            let n_validators = validators.len();
-            for index in votes.true_index_iter() {
-                assert!(index < n_validators);
-                let validator = validators.get(index).ok_or_else(|| {
-                    EngineError::ValidatorNotExist {
-                        height: 0, // FIXME
-                        index,
-                    }
-                })?;
-                voted_delegation += validator.delegation();
-            }
-            let total_delegation: u64 = validators.iter().map(Validator::delegation).sum();
-            if voted_delegation * 3 > total_delegation * 2 {
-                Ok(())
-            } else {
-                let threshold = total_delegation as usize * 2 / 3;
-                Err(EngineError::BadSealFieldSize(OutOfBounds {
-                    min: Some(threshold),
-                    max: Some(total_delegation as usize),
-                    found: voted_delegation as usize,
-                }))
-            }
+        if let Some(validators) = self.next_validators(*parent) {
+            self.check_enough_votes_with_validators(&validators, votes)
         } else {
             self.initial_list.check_enough_votes(parent, votes)
         }