Fix tendermint to use CurrentValidators

CurrentValidators was introduced to tendermint, but it wasn't
used by some part of our implementation. This patch doesn't fix
all of them, but important parts are filled in.

Author: remagpie

core/src/consensus/stake/action_data.rs

@@ -433,6 +433,10 @@ 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()
+    }
 }
 
 impl Deref for CurrentValidators {
@@ -482,6 +486,12 @@ impl Deref for PreviousValidators {
     }
 }
 
+impl From<PreviousValidators> for Vec<Validator> {
+    fn from(val: PreviousValidators) -> Self {
+        val.0
+    }
+}
+
 #[derive(Default, Debug, PartialEq)]
 pub struct IntermediateRewards {
     current: BTreeMap<Address, u64>,

core/src/consensus/tendermint/engine.rs

@@ -400,20 +400,21 @@ fn aggregate_work_info(
         end_of_the_last_term + 1
     };
     let mut header = start_of_the_next_term_header;
-    let mut parent_validators = validators.current_addresses(&header.parent_hash());
     while start_of_the_current_term != header.number() {
+        let parent = chain.block_header(&header.parent_hash().into()).unwrap();
+        let current_validators = validators.current_addresses(&parent.hash());
+        let previous_validators = validators.previous_addresses(&parent.hash());
         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");
+            let signer = *current_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 = validators.current_addresses(&header.parent_hash());
-
-        let author = header.author();
+        let author = parent.author();
         let info = work_info.entry(author).or_default();
         info.proposed += 1;
-        info.missed += parent_validators.len() - TendermintSealView::new(&header.seal()).bitset()?.count();
+        info.missed += previous_validators.len() - TendermintSealView::new(&header.seal()).bitset()?.count();
+
+        header = parent;
     }
 
     Ok(work_info)

core/src/consensus/tendermint/worker.rs

@@ -1248,13 +1248,14 @@ 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_hash = header.parent_hash();
+        let grand_parent_hash =
+            self.client().block_header(&(*parent_hash).into()).expect("The parent block must exist").parent_hash();
         for (bitset_index, signature) in seal_view.signatures()? {
-            let public = self.validators.get(&grand_parent_hash, bitset_index);
+            let public = match self.validators.get_current(header.parent_hash(), bitset_index) {
+                Some(p) => p,
+                None => self.validators.get(&grand_parent_hash, bitset_index),
+            };
             if !verify_schnorr(&public, &signature, &precommit_vote_on.hash())? {
                 let address = public_to_address(&public);
                 return Err(EngineError::BlockNotAuthorized(address.to_owned()).into())
@@ -1267,7 +1268,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_current(&parent_hash, &voted_validators)?;
         Ok(())
     }
 

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::{CurrentValidators, NextValidators, Validator};
+use crate::consensus::stake::{CurrentValidators, NextValidators, PreviousValidators, Validator};
 use crate::consensus::EngineError;
 
 /// Validator set containing a known set of public keys.
@@ -87,6 +87,29 @@ impl DynamicValidator {
         }
     }
 
+    fn previous_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 = PreviousValidators::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())
     }
@@ -95,6 +118,10 @@ impl DynamicValidator {
         self.current_validators(hash).map(|validators| validators.into_iter().map(|val| *val.pubkey()).collect())
     }
 
+    fn previous_validators_pubkey(&self, hash: BlockHash) -> Option<Vec<Public>> {
+        self.previous_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.next_validators(parent) {
             let num_validators = validators.len();
@@ -104,6 +131,44 @@ impl DynamicValidator {
             (prev_proposer_index + proposed_view + 1) % num_validators
         }
     }
+
+    pub fn get_current(&self, hash: &BlockHash, index: usize) -> Option<Public> {
+        let validators = self.current_validators_pubkey(*hash)?;
+        let n_validators = validators.len();
+        Some(*validators.get(index % n_validators).unwrap())
+    }
+
+    pub fn check_enough_votes_with_current(&self, hash: &BlockHash, votes: &BitSet) -> Result<(), EngineError> {
+        if let Some(validators) = self.current_validators(*hash) {
+            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,
+                }))
+            }
+        } else {
+            let client = self.client.read().as_ref().and_then(Weak::upgrade).expect("Client is not initialized");
+            let header = client.block_header(&(*hash).into()).unwrap();
+            self.check_enough_votes(&header.parent_hash(), votes)
+        }
+    }
 }
 
 impl ValidatorSet for DynamicValidator {
@@ -208,6 +273,14 @@ impl ValidatorSet for DynamicValidator {
         *client_lock = Some(client);
     }
 
+    fn previous_addresses(&self, hash: &BlockHash) -> Vec<Address> {
+        if let Some(validators) = self.previous_validators_pubkey(*hash) {
+            validators.iter().map(public_to_address).collect()
+        } else {
+            self.initial_list.previous_addresses(hash)
+        }
+    }
+
     fn current_addresses(&self, hash: &BlockHash) -> Vec<Address> {
         if let Some(validators) = self.current_validators_pubkey(*hash) {
             validators.iter().map(public_to_address).collect()

core/src/consensus/validator_set/mod.rs

@@ -57,6 +57,8 @@ pub trait ValidatorSet: Send + Sync {
     /// Allows blockchain state access.
     fn register_client(&self, _client: Weak<dyn ConsensusClient>) {}
 
+    fn previous_addresses(&self, _hash: &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,6 +105,10 @@ impl ValidatorSet for RoundRobinValidator {
         *self.client.write() = Some(client);
     }
 
+    fn previous_addresses(&self, _hash: &BlockHash) -> Vec<Address> {
+        self.validators.iter().map(public_to_address).collect()
+    }
+
     fn current_addresses(&self, _hash: &BlockHash) -> Vec<Address> {
         self.validators.iter().map(public_to_address).collect()
     }