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.

core/src/client/test_client.rs

@@ -59,7 +59,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;
@@ -106,7 +106,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 {
@@ -160,7 +160,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.
@@ -325,14 +325,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

@@ -41,8 +41,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 {
@@ -274,17 +276,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> {
@@ -335,7 +337,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 {
@@ -384,21 +386,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>;
 
@@ -407,6 +409,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
+    }
+}
+
 pub mod v0 {
     use std::mem;
 
@@ -603,7 +638,7 @@ impl Candidates {
 
     pub fn renew_candidates(
         &mut self,
-        validators: &Validators,
+        validators: &NextValidators,
         nomination_ends_at: u64,
         inactive_validators: &[Address],
         banned: &Banned,
@@ -1868,7 +1903,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, 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 mod v0 {
@@ -379,7 +379,7 @@ pub mod v1 {
 }
 
 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)
 }
@@ -451,7 +451,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)?;
@@ -469,7 +469,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);
@@ -519,7 +519,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

@@ -142,6 +142,17 @@ impl ConsensusEngine for Tendermint {
         let block_number = block.header().number();
         let metadata = block.state().metadata()?.expect("Metadata must exist");
         let era = metadata.term_params().map_or(0, |p| p.era());
+
+        match era {
+            0 => {}
+            1 => {
+                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())?;
+            }
+            _ => unimplemented!(),
+        }
+
         if block_number == metadata.last_term_finished_block_num() + 1 {
             match era {
                 0 => {}
@@ -274,7 +285,7 @@ impl ConsensusEngine for Tendermint {
 
                 stake::v0::move_current_to_previous_intermediate_rewards(block.state_mut())?;
 
-                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();
@@ -286,7 +297,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();