Get tendermint validators with CurrentValidators

Author: remagpie

core/src/consensus/simple_poa/mod.rs

@@ -149,7 +149,7 @@ impl ConsensusEngine for SimplePoA {
     fn possible_authors(&self, _block_number: Option<u64>) -> Result<Option<Vec<Address>>, EngineError> {
         // TODO: It works because the round robin validator doesn't use the parent hash.
         let parent = H256::from(0).into();
-        Ok(Some(self.validators.addresses(&parent)))
+        Ok(Some(self.validators.next_addresses(&parent)))
     }
 }
 

core/src/consensus/stake/action_data.rs

@@ -443,6 +443,12 @@ impl Deref for CurrentValidators {
     }
 }
 
+impl From<CurrentValidators> for Vec<Validator> {
+    fn from(val: CurrentValidators) -> Self {
+        val.0
+    }
+}
+
 #[derive(Default, Debug, PartialEq)]
 pub struct IntermediateRewards {
     pub(super) current: BTreeMap<Address, u64>,

core/src/consensus/stake/mod.rs

@@ -317,10 +317,6 @@ pub fn get_stakes(state: &TopLevelState) -> StateResult<HashMap<Address, u64>> {
     Ok(result)
 }
 
-pub fn get_validators(state: &TopLevelState) -> StateResult<NextValidators> {
-    NextValidators::load_from_state(state)
-}
-
 pub fn add_intermediate_rewards(state: &mut TopLevelState, address: Address, reward: u64) -> StateResult<()> {
     let mut rewards = IntermediateRewards::load_from_state(state)?;
     rewards.add_quantity(address, reward);

core/src/consensus/tendermint/engine.rs

@@ -342,7 +342,7 @@ impl ConsensusEngine for Tendermint {
                 client.block_header(&(block_number - 1).into()).ok_or(EngineError::CannotOpenBlock)?.hash() // the parent of the given block number
             }
         };
-        Ok(Some(self.validators.addresses(&block_hash)))
+        Ok(Some(self.validators.next_addresses(&block_hash)))
     }
 }
 
@@ -389,23 +389,15 @@ fn aggregate_work_info(
         end_of_the_last_term + 1
     };
     let mut header = start_of_the_next_term_header;
-    let mut parent_validators = {
-        let parent_header = chain.block_header(&header.parent_hash().into()).unwrap();
-        validators.addresses(&parent_header.parent_hash())
-    };
+    let mut parent_validators = validators.current_addresses(&header.parent_hash());
     while start_of_the_current_term != header.number() {
         for index in TendermintSealView::new(&header.seal()).bitset()?.true_index_iter() {
             let signer = *parent_validators.get(index).expect("The seal must be the signature of the validator");
             work_info.entry(signer).or_default().signed += 1;
         }
 
         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 parent_header = chain.block_header(&header.parent_hash().into()).unwrap();
-            validators.addresses(&parent_header.parent_hash())
-        };
+        parent_validators = validators.current_addresses(&header.parent_hash());
 
         let author = header.author();
         let info = work_info.entry(author).or_default();

core/src/consensus/validator_set/dynamic_validator.rs

@@ -24,7 +24,7 @@ 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::{CurrentValidators, NextValidators, Validator};
 use crate::consensus::EngineError;
 
 /// Validator set containing a known set of public keys.
@@ -41,10 +41,10 @@ impl DynamicValidator {
         }
     }
 
-    fn validators(&self, parent: BlockHash) -> Option<Vec<Validator>> {
+    fn next_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 = parent.into();
+        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.
@@ -54,7 +54,7 @@ impl DynamicValidator {
             return None
         }
         let state = client.state_at(block_id)?;
-        let validators = get_validators(&state).unwrap();
+        let validators = NextValidators::load_from_state(&state).unwrap();
         if validators.is_empty() {
             None
         } else {
@@ -64,12 +64,39 @@ impl DynamicValidator {
         }
     }
 
-    fn validators_pubkey(&self, parent: BlockHash) -> Option<Vec<Public>> {
-        self.validators(parent).map(|validators| validators.into_iter().map(|val| *val.pubkey()).collect())
+    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.into();
+            validators.reverse();
+            Some(validators)
+        }
+    }
+
+    fn validators_pubkey(&self, hash: BlockHash) -> Option<Vec<Public>> {
+        self.next_validators(hash).map(|validators| validators.into_iter().map(|val| *val.pubkey()).collect())
+    }
+
+    fn current_validators_pubkey(&self, hash: BlockHash) -> Option<Vec<Public>> {
+        self.current_validators(hash).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 {
@@ -136,15 +163,15 @@ 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) {
+        if let Some(validators) = self.next_validators(*parent) {
             let mut voted_delegation = 0u64;
             let n_validators = validators.len();
             for index in votes.true_index_iter() {
@@ -181,11 +208,19 @@ impl ValidatorSet for DynamicValidator {
         *client_lock = Some(client);
     }
 
-    fn addresses(&self, parent: &BlockHash) -> Vec<Address> {
-        if let Some(validators) = self.validators_pubkey(*parent) {
+    fn current_addresses(&self, hash: &BlockHash) -> Vec<Address> {
+        if let Some(validators) = self.current_validators_pubkey(*hash) {
+            validators.iter().map(public_to_address).collect()
+        } else {
+            self.initial_list.next_addresses(hash)
+        }
+    }
+
+    fn next_addresses(&self, hash: &BlockHash) -> Vec<Address> {
+        if let Some(validators) = self.validators_pubkey(*hash) {
             validators.iter().map(public_to_address).collect()
         } else {
-            self.initial_list.addresses(parent)
+            self.initial_list.next_addresses(hash)
         }
     }
 }

core/src/consensus/validator_set/mod.rs

@@ -57,5 +57,7 @@ pub trait ValidatorSet: Send + Sync {
     /// Allows blockchain state access.
     fn register_client(&self, _client: Weak<dyn ConsensusClient>) {}
 
-    fn addresses(&self, _parent: &BlockHash) -> Vec<Address>;
+    fn current_addresses(&self, _hash: &BlockHash) -> Vec<Address>;
+
+    fn next_addresses(&self, _hash: &BlockHash) -> Vec<Address>;
 }

core/src/consensus/validator_set/validator_list.rs

@@ -105,7 +105,11 @@ impl ValidatorSet for RoundRobinValidator {
         *self.client.write() = Some(client);
     }
 
-    fn addresses(&self, _parent: &BlockHash) -> Vec<Address> {
+    fn current_addresses(&self, _hash: &BlockHash) -> Vec<Address> {
+        self.validators.iter().map(public_to_address).collect()
+    }
+
+    fn next_addresses(&self, _hash: &BlockHash) -> Vec<Address> {
         self.validators.iter().map(public_to_address).collect()
     }
 }