Introduce CurrentValidators

CurrentValidators represent the list of validators for the current
block. Its value is the same as the NextValidators of the previous
block's state.

Author: remagpie

core/src/client/test_client.rs

@@ -58,7 +58,7 @@ use crate::client::{
     AccountData, BlockChainClient, BlockChainTrait, BlockProducer, BlockStatus, ConsensusClient, EngineInfo,
     ImportBlock, ImportResult, MiningBlockChainClient, StateInfo, StateOrBlock, TermInfo,
 };
-use crate::consensus::stake::{Validator, Validators};
+use crate::consensus::stake::{NextValidators, Validator};
 use crate::consensus::EngineError;
 use crate::db::{COL_STATE, NUM_COLUMNS};
 use crate::encoded;
@@ -105,7 +105,7 @@ pub struct TestBlockChainClient {
     /// Fixed validator keys
     pub validator_keys: RwLock<HashMap<Public, Private>>,
     /// Fixed validators
-    pub validators: Validators,
+    pub validators: NextValidators,
 }
 
 impl Default for TestBlockChainClient {
@@ -159,7 +159,7 @@ impl TestBlockChainClient {
             history: RwLock::new(None),
             term_id: Some(1),
             validator_keys: RwLock::new(HashMap::new()),
-            validators: Validators::from_vector_to_test(vec![]),
+            validators: NextValidators::from_vector_to_test(vec![]),
         };
 
         // insert genesis hash.
@@ -324,14 +324,14 @@ impl TestBlockChainClient {
             self.validator_keys.write().insert(*key_pair.public(), *key_pair.private());
             pubkeys.push(*key_pair.public());
         }
-        let fixed_validators: Validators = Validators::from_vector_to_test(
+        let fixed_validators: NextValidators = NextValidators::from_vector_to_test(
             pubkeys.into_iter().map(|pubkey| Validator::new_for_test(0, 0, pubkey)).collect(),
         );
 
         self.validators = fixed_validators;
     }
 
-    pub fn get_validators(&self) -> &Validators {
+    pub fn get_validators(&self) -> &NextValidators {
         &self.validators
     }
 }

core/src/consensus/stake/action_data.rs

@@ -42,8 +42,10 @@ lazy_static! {
     pub static ref JAIL_KEY: H256 = ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"Jail").into_key();
     pub static ref BANNED_KEY: H256 =
         ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"Banned").into_key();
-    pub static ref VALIDATORS_KEY: H256 =
+    pub static ref NEXT_VALIDATORS_KEY: H256 =
         ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"Validators").into_key();
+    pub static ref CURRENT_VALIDATORS_KEY: H256 =
+        ActionDataKeyBuilder::new(CUSTOM_ACTION_HANDLER_ID, 1).append(&"CurrentValidators").into_key();
 }
 
 pub fn get_delegation_key(address: &Address) -> H256 {
@@ -275,17 +277,17 @@ impl Validator {
 }
 
 #[derive(Debug)]
-pub struct Validators(Vec<Validator>);
-impl Validators {
+pub struct NextValidators(Vec<Validator>);
+impl NextValidators {
     pub fn from_vector_to_test(vec: Vec<Validator>) -> Self {
-        Validators(vec)
+        Self(vec)
     }
 
     pub fn load_from_state(state: &TopLevelState) -> StateResult<Self> {
-        let key = &*VALIDATORS_KEY;
+        let key = &*NEXT_VALIDATORS_KEY;
         let validators = state.action_data(&key)?.map(|data| decode_list(&data)).unwrap_or_default();
 
-        Ok(Validators(validators))
+        Ok(Self(validators))
     }
 
     pub fn elect(state: &TopLevelState) -> StateResult<Self> {
@@ -336,7 +338,7 @@ impl Validators {
 
 
     pub fn save_to_state(&self, state: &mut TopLevelState) -> StateResult<()> {
-        let key = &*VALIDATORS_KEY;
+        let key = &*NEXT_VALIDATORS_KEY;
         if !self.is_empty() {
             state.update_action_data(&key, encode_list(&self.0).to_vec())?;
         } else {
@@ -385,21 +387,21 @@ impl Validators {
     }
 }
 
-impl Deref for Validators {
+impl Deref for NextValidators {
     type Target = Vec<Validator>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl From<Validators> for Vec<Validator> {
-    fn from(val: Validators) -> Self {
+impl From<NextValidators> for Vec<Validator> {
+    fn from(val: NextValidators) -> Self {
         val.0
     }
 }
 
-impl IntoIterator for Validators {
+impl IntoIterator for NextValidators {
     type Item = Validator;
     type IntoIter = vec::IntoIter<Self::Item>;
 
@@ -408,6 +410,39 @@ impl IntoIterator for Validators {
     }
 }
 
+#[derive(Debug)]
+pub struct CurrentValidators(Vec<Validator>);
+impl CurrentValidators {
+    pub fn load_from_state(state: &TopLevelState) -> StateResult<Self> {
+        let key = &*CURRENT_VALIDATORS_KEY;
+        let validators = state.action_data(&key)?.map(|data| decode_list(&data)).unwrap_or_default();
+
+        Ok(Self(validators))
+    }
+
+    pub fn save_to_state(&self, state: &mut TopLevelState) -> StateResult<()> {
+        let key = &*CURRENT_VALIDATORS_KEY;
+        if !self.is_empty() {
+            state.update_action_data(&key, encode_list(&self.0).to_vec())?;
+        } else {
+            state.remove_action_data(&key);
+        }
+        Ok(())
+    }
+
+    pub fn update(&mut self, validators: Vec<Validator>) {
+        self.0 = validators;
+    }
+}
+
+impl Deref for CurrentValidators {
+    type Target = Vec<Validator>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 #[derive(Default, Debug, PartialEq)]
 pub struct IntermediateRewards {
     pub(super) current: BTreeMap<Address, u64>,
@@ -544,7 +579,7 @@ impl Candidates {
 
     pub fn renew_candidates(
         &mut self,
-        validators: &Validators,
+        validators: &NextValidators,
         nomination_ends_at: u64,
         inactive_validators: &[Address],
         banned: &Banned,
@@ -1754,7 +1789,7 @@ mod tests {
         }
         candidates.save_to_state(&mut state).unwrap();
 
-        let dummy_validators = Validators(
+        let dummy_validators = NextValidators(
             pubkeys[0..5]
                 .iter()
                 .map(|pubkey| Validator {

core/src/consensus/stake/mod.rs

@@ -33,7 +33,7 @@ use parking_lot::RwLock;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, Rlp};
 
-pub use self::action_data::{Banned, Validator, Validators};
+pub use self::action_data::{Banned, CurrentValidators, NextValidators, Validator};
 use self::action_data::{Candidates, Delegation, IntermediateRewards, Jail, ReleaseResult, StakeAccount, Stakeholders};
 pub use self::actions::Action;
 pub use self::distribute::fee_distribute;
@@ -317,8 +317,8 @@ pub fn get_stakes(state: &TopLevelState) -> StateResult<HashMap<Address, u64>> {
     Ok(result)
 }
 
-pub fn get_validators(state: &TopLevelState) -> StateResult<Validators> {
-    Validators::load_from_state(state)
+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<()> {
@@ -349,7 +349,7 @@ pub fn drain_calculated_rewards(state: &mut TopLevelState) -> StateResult<BTreeM
 }
 
 pub fn update_validator_weights(state: &mut TopLevelState, block_author: &Address) -> StateResult<()> {
-    let mut validators = Validators::load_from_state(state)?;
+    let mut validators = NextValidators::load_from_state(state)?;
     validators.update_weight(block_author);
     validators.save_to_state(state)
 }
@@ -421,7 +421,7 @@ pub fn on_term_close(
 
     jail(state, inactive_validators, custody_until, kick_at)?;
 
-    let validators = Validators::elect(state)?;
+    let validators = NextValidators::elect(state)?;
     validators.save_to_state(state)?;
 
     state.increase_term_id(last_term_finished_block_num)?;
@@ -439,7 +439,7 @@ fn update_candidates(
     let mut candidates = Candidates::load_from_state(state)?;
     let nomination_ends_at = current_term + nomination_expiration;
 
-    let current_validators = Validators::load_from_state(state)?;
+    let current_validators = NextValidators::load_from_state(state)?;
     candidates.renew_candidates(&current_validators, nomination_ends_at, &inactive_validators, &banned);
 
     let expired = candidates.drain_expired_candidates(current_term);
@@ -489,7 +489,7 @@ pub fn ban(state: &mut TopLevelState, informant: &Public, criminal: Address) ->
 
     let mut candidates = Candidates::load_from_state(state)?;
     let mut jailed = Jail::load_from_state(state)?;
-    let mut validators = Validators::load_from_state(state)?;
+    let mut validators = NextValidators::load_from_state(state)?;
 
     let deposit = match (candidates.remove(&criminal), jailed.remove(&criminal)) {
         (Some(_), Some(_)) => unreachable!("A candidate that are jailed cannot exist"),

core/src/consensus/tendermint/engine.rs

@@ -147,14 +147,25 @@ impl ConsensusEngine for Tendermint {
 
         let block_number = block.header().number();
         let metadata = block.state().metadata()?.expect("Metadata must exist");
+        let term = metadata.current_term_id();
+
+        match term {
+            0 => {}
+            _ => {
+                let mut validators = stake::CurrentValidators::load_from_state(block.state())?;
+                validators.update(stake::NextValidators::load_from_state(block.state())?.clone());
+                validators.save_to_state(block.state_mut())?;
+            }
+        }
+
         if block_number == metadata.last_term_finished_block_num() + 1 {
-            match metadata.current_term_id() {
-                0 => {},
+            match term {
+                0 => {}
                 _ => {
                     let rewards = stake::drain_current_rewards(block.state_mut())?;
                     let banned = stake::Banned::load_from_state(block.state())?;
                     let start_of_the_current_term_header =
-                    encoded::Header::new(block.header().clone().rlp_bytes().to_vec());
+                        encoded::Header::new(block.header().clone().rlp_bytes().to_vec());
 
                     let pending_rewards = calculate_pending_rewards_of_the_term(
                         &*client,
@@ -231,7 +242,7 @@ impl ConsensusEngine for Tendermint {
                 }
 
                 let start_of_the_current_term = metadata.last_term_finished_block_num() + 1;
-                let validators = stake::Validators::load_from_state(block.state())?
+                let validators = stake::NextValidators::load_from_state(block.state())?
                     .into_iter()
                     .map(|val| public_to_address(val.pubkey()))
                     .collect();