Precalculate the fee in era=1

Author: remagpie

core/src/consensus/stake/action_data.rs

@@ -409,12 +409,12 @@ impl IntoIterator for Validators {
 }
 
 #[derive(Default, Debug, PartialEq)]
-pub struct IntermediateRewards {
+pub struct IntermediateRewardsV0 {
     previous: BTreeMap<Address, u64>,
     current: BTreeMap<Address, u64>,
 }
 
-impl IntermediateRewards {
+impl IntermediateRewardsV0 {
     pub fn load_from_state(state: &TopLevelState) -> StateResult<Self> {
         let key = get_intermediate_rewards_key();
         let action_data = state.action_data(&key)?;
@@ -456,6 +456,59 @@ impl IntermediateRewards {
     }
 }
 
+#[derive(Default, Debug, PartialEq)]
+pub struct IntermediateRewardsV1 {
+    current: BTreeMap<Address, u64>,
+    calculated: BTreeMap<Address, u64>,
+}
+
+impl IntermediateRewardsV1 {
+    pub fn load_from_state(state: &TopLevelState) -> StateResult<Self> {
+        let key = get_intermediate_rewards_key();
+        let action_data = state.action_data(&key)?;
+        let (current, calculated) = decode_map_tuple(action_data.as_ref());
+
+        Ok(Self {
+            current,
+            calculated,
+        })
+    }
+
+    pub fn save_to_state(&self, state: &mut TopLevelState) -> StateResult<()> {
+        let key = get_intermediate_rewards_key();
+        if self.current.is_empty() && self.calculated.is_empty() {
+            state.remove_action_data(&key);
+        } else {
+            let encoded = encode_map_tuple(&self.current, &self.calculated);
+            state.update_action_data(&key, encoded)?;
+        }
+        Ok(())
+    }
+
+    pub fn add_quantity(&mut self, address: Address, quantity: StakeQuantity) {
+        if quantity == 0 {
+            return
+        }
+        *self.current.entry(address).or_insert(0) += quantity;
+    }
+
+    pub fn update_calculated(&mut self, rewards: BTreeMap<Address, u64>) {
+        self.calculated = rewards;
+    }
+
+    pub fn drain_current(&mut self) -> BTreeMap<Address, u64> {
+        let mut new = BTreeMap::new();
+        mem::swap(&mut new, &mut self.current);
+        new
+    }
+
+    pub fn drain_calculated(&mut self) -> BTreeMap<Address, u64> {
+        let mut new = BTreeMap::new();
+        mem::swap(&mut new, &mut self.calculated);
+        new
+    }
+}
+
 pub struct Candidates(Vec<Candidate>);
 #[derive(Clone, Debug, Eq, PartialEq, RlpEncodable, RlpDecodable)]
 pub struct Candidate {
@@ -1129,46 +1182,85 @@ mod tests {
     }
 
     #[test]
-    fn load_and_save_intermediate_rewards() {
+    fn load_and_save_intermediate_rewards_v0() {
         let mut state = helpers::get_temp_state();
-        let rewards = IntermediateRewards::load_from_state(&state).unwrap();
+        let rewards = IntermediateRewardsV0::load_from_state(&state).unwrap();
         rewards.save_to_state(&mut state).unwrap();
     }
 
     #[test]
-    fn add_quantity() {
+    fn add_quantity_v0() {
         let address1 = Address::random();
         let address2 = Address::random();
         let mut state = helpers::get_temp_state();
-        let mut origin_rewards = IntermediateRewards::load_from_state(&state).unwrap();
+        let mut origin_rewards = IntermediateRewardsV0::load_from_state(&state).unwrap();
         origin_rewards.add_quantity(address1, 1);
         origin_rewards.add_quantity(address2, 2);
         origin_rewards.save_to_state(&mut state).unwrap();
-        let recovered_rewards = IntermediateRewards::load_from_state(&state).unwrap();
+        let recovered_rewards = IntermediateRewardsV0::load_from_state(&state).unwrap();
         assert_eq!(origin_rewards, recovered_rewards);
     }
 
     #[test]
-    fn drain() {
+    fn drain_v0() {
         let address1 = Address::random();
         let address2 = Address::random();
         let mut state = helpers::get_temp_state();
-        let mut origin_rewards = IntermediateRewards::load_from_state(&state).unwrap();
+        let mut origin_rewards = IntermediateRewardsV0::load_from_state(&state).unwrap();
         origin_rewards.add_quantity(address1, 1);
         origin_rewards.add_quantity(address2, 2);
         origin_rewards.save_to_state(&mut state).unwrap();
-        let mut recovered_rewards = IntermediateRewards::load_from_state(&state).unwrap();
+        let mut recovered_rewards = IntermediateRewardsV0::load_from_state(&state).unwrap();
         assert_eq!(origin_rewards, recovered_rewards);
         let _drained = recovered_rewards.drain_previous();
         recovered_rewards.save_to_state(&mut state).unwrap();
-        let mut final_rewards = IntermediateRewards::load_from_state(&state).unwrap();
+        let mut final_rewards = IntermediateRewardsV0::load_from_state(&state).unwrap();
         assert_eq!(BTreeMap::new(), final_rewards.previous);
         let current = final_rewards.current.clone();
         final_rewards.move_current_to_previous();
         assert_eq!(BTreeMap::new(), final_rewards.current);
         assert_eq!(current, final_rewards.previous);
     }
 
+    #[test]
+    fn load_and_save_intermediate_rewards_v1() {
+        let mut state = helpers::get_temp_state();
+        let rewards = IntermediateRewardsV1::load_from_state(&state).unwrap();
+        rewards.save_to_state(&mut state).unwrap();
+    }
+
+    #[test]
+    fn add_quantity_v1() {
+        let address1 = Address::random();
+        let address2 = Address::random();
+        let mut state = helpers::get_temp_state();
+        let mut origin_rewards = IntermediateRewardsV1::load_from_state(&state).unwrap();
+        origin_rewards.add_quantity(address1, 1);
+        origin_rewards.add_quantity(address2, 2);
+        origin_rewards.save_to_state(&mut state).unwrap();
+        let recovered_rewards = IntermediateRewardsV1::load_from_state(&state).unwrap();
+        assert_eq!(origin_rewards, recovered_rewards);
+    }
+
+    #[test]
+    fn drain_v1() {
+        let address1 = Address::random();
+        let address2 = Address::random();
+        let mut state = helpers::get_temp_state();
+        let mut origin_rewards = IntermediateRewardsV1::load_from_state(&state).unwrap();
+        origin_rewards.add_quantity(address1, 1);
+        origin_rewards.add_quantity(address2, 2);
+        origin_rewards.save_to_state(&mut state).unwrap();
+        let mut recovered_rewards = IntermediateRewardsV1::load_from_state(&state).unwrap();
+        assert_eq!(origin_rewards, recovered_rewards);
+        recovered_rewards.drain_current();
+        recovered_rewards.save_to_state(&mut state).unwrap();
+        let mut final_rewards = IntermediateRewardsV1::load_from_state(&state).unwrap();
+        assert_eq!(BTreeMap::new(), final_rewards.current);
+        final_rewards.drain_calculated();
+        assert_eq!(BTreeMap::new(), final_rewards.calculated);
+    }
+
     #[test]
     fn candidates_deposit_add() {
         let mut state = helpers::get_temp_state();

core/src/consensus/stake/mod.rs

@@ -34,7 +34,10 @@ use primitives::{Bytes, H256};
 use rlp::{Decodable, Rlp};
 
 pub use self::action_data::{Banned, Validator, Validators};
-use self::action_data::{Candidates, Delegation, IntermediateRewards, Jail, ReleaseResult, StakeAccount, Stakeholders};
+use self::action_data::{
+    Candidates, Delegation, IntermediateRewardsV0, IntermediateRewardsV1, Jail, ReleaseResult, StakeAccount,
+    Stakeholders,
+};
 pub use self::actions::Action;
 pub use self::distribute::fee_distribute;
 use super::ValidatorSet;
@@ -322,25 +325,57 @@ pub fn get_validators(state: &TopLevelState) -> StateResult<Validators> {
 }
 
 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);
-    rewards.save_to_state(state)?;
+    let metadata = state.metadata()?.expect("The metadata must exist");
+    let era = metadata.term_params().map_or(0, |p| p.era());
+    match era {
+        0 => {
+            let mut rewards = IntermediateRewardsV0::load_from_state(state)?;
+            rewards.add_quantity(address, reward);
+            rewards.save_to_state(state)?;
+        }
+        1 => {
+            let mut rewards = IntermediateRewardsV1::load_from_state(state)?;
+            rewards.add_quantity(address, reward);
+            rewards.save_to_state(state)?;
+        }
+        _ => unimplemented!(),
+    }
     Ok(())
 }
 
 pub fn drain_previous_rewards(state: &mut TopLevelState) -> StateResult<BTreeMap<Address, u64>> {
-    let mut rewards = IntermediateRewards::load_from_state(state)?;
+    let mut rewards = IntermediateRewardsV0::load_from_state(state)?;
     let drained = rewards.drain_previous();
     rewards.save_to_state(state)?;
     Ok(drained)
 }
 
 pub fn move_current_to_previous_intermediate_rewards(state: &mut TopLevelState) -> StateResult<()> {
-    let mut rewards = IntermediateRewards::load_from_state(state)?;
+    let mut rewards = IntermediateRewardsV0::load_from_state(state)?;
     rewards.move_current_to_previous();
     rewards.save_to_state(state)
 }
 
+pub fn drain_current_rewards(state: &mut TopLevelState) -> StateResult<BTreeMap<Address, u64>> {
+    let mut rewards = IntermediateRewardsV1::load_from_state(state)?;
+    let drained = rewards.drain_current();
+    rewards.save_to_state(state)?;
+    Ok(drained)
+}
+
+pub fn update_calculated_rewards(state: &mut TopLevelState, values: HashMap<Address, u64>) -> StateResult<()> {
+    let mut rewards = IntermediateRewardsV1::load_from_state(state)?;
+    rewards.update_calculated(values.into_iter().collect());
+    rewards.save_to_state(state)
+}
+
+pub fn drain_calculated_rewards(state: &mut TopLevelState) -> StateResult<BTreeMap<Address, u64>> {
+    let mut rewards = IntermediateRewardsV1::load_from_state(state)?;
+    let drained = rewards.drain_calculated();
+    rewards.save_to_state(state)?;
+    Ok(drained)
+}
+
 pub fn update_validator_weights(state: &mut TopLevelState, block_author: &Address) -> StateResult<()> {
     let mut validators = Validators::load_from_state(state)?;
     validators.update_weight(block_author);

core/src/consensus/tendermint/engine.rs

@@ -136,9 +136,43 @@ impl ConsensusEngine for Tendermint {
 
     /// Block transformation functions, before the transactions.
     fn on_open_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
+        let client = self.client().ok_or(EngineError::CannotOpenBlock)?;
+
+        let block_number = block.header().number();
+        let era = client.term_common_params(block_number.into()).map_or(0, |p| p.era());
         let metadata = block.state().metadata()?.expect("Metadata must exist");
-        if block.header().number() == metadata.last_term_finished_block_num() + 1 {
-            // FIXME: on_term_open
+        if block_number == metadata.last_term_finished_block_num() + 1 {
+            match era {
+                0 => {}
+                1 => {
+                    let rewards = stake::drain_current_rewards(block.state_mut())?;
+                    let start_of_the_current_term = block_number;
+                    let start_of_the_previous_term = {
+                        let end_of_the_two_level_previous_term = client
+                            .last_term_finished_block_num((metadata.last_term_finished_block_num() - 1).into())
+                            .unwrap();
+
+                        end_of_the_two_level_previous_term + 1
+                    };
+
+                    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());
+
+                    let pending_rewards = calculate_pending_rewards_of_the_previous_term(
+                        &*client,
+                        &*self.validators,
+                        rewards,
+                        start_of_the_current_term,
+                        start_of_the_current_term_header,
+                        start_of_the_previous_term,
+                        &banned,
+                    )?;
+
+                    stake::update_calculated_rewards(block.state_mut(), pending_rewards)?;
+                }
+                _ => unimplemented!(),
+            }
         }
         Ok(())
     }
@@ -174,6 +208,7 @@ impl ConsensusEngine for Tendermint {
 
         let block_author_reward = total_reward - total_min_fee + distributor.remaining_fee();
 
+        let era = term_common_params.map_or(0, |p| p.era());
         let metadata = block.state().metadata()?.expect("Metadata must exist");
         let term = metadata.current_term_id();
         let term_seconds = match term {
@@ -195,9 +230,9 @@ impl ConsensusEngine for Tendermint {
             return Ok(())
         }
 
-        let inactive_validators = match term {
-            0 => Vec::new(),
-            _ => {
+        let inactive_validators = match (era, term) {
+            (0, 0) => Vec::new(),
+            (0, _) => {
                 let rewards = stake::drain_previous_rewards(block.state_mut())?;
                 let start_of_the_current_term = metadata.last_term_finished_block_num() + 1;
 
@@ -240,13 +275,26 @@ impl ConsensusEngine for Tendermint {
                     .collect();
                 inactive_validators(&*client, start_of_the_current_term, block.header(), validators)
             }
+            (1, _) => {
+                for (address, reward) in stake::drain_calculated_rewards(block.state_mut())? {
+                    self.machine.add_balance(block, &address, reward)?;
+                }
+
+                let start_of_the_current_term = metadata.last_term_finished_block_num() + 1;
+                let validators = stake::Validators::load_from_state(block.state())?
+                    .into_iter()
+                    .map(|val| public_to_address(val.pubkey()))
+                    .collect();
+                inactive_validators(&*client, start_of_the_current_term, block.header(), validators)
+            }
+            _ => unimplemented!(),
         };
 
         stake::on_term_close(block.state_mut(), block_number, &inactive_validators)?;
 
         match term {
             0 => {}
-            _ => match term_common_params.expect("Term common params should exist").era() {
+            _ => match era {
                 0 => {}
                 1 => block.state_mut().snapshot_term_params()?,
                 _ => unimplemented!("It is not decided how we handle this"),