Precalculate the fee in era=1

Author: remagpie

core/src/consensus/solo/mod.rs

@@ -118,7 +118,7 @@ impl ConsensusEngine for Solo {
             self.machine.add_balance(block, &author, block_author_reward)?;
             return Ok(())
         }
-        stake::add_intermediate_rewards(block.state_mut(), author, block_author_reward)?;
+        stake::v0::add_intermediate_rewards(block.state_mut(), author, block_author_reward)?;
         let last_term_finished_block_num = {
             let header = block.header();
             let current_term_period = header.timestamp() / term_seconds;
@@ -128,8 +128,8 @@ impl ConsensusEngine for Solo {
             }
             header.number()
         };
-        stake::move_current_to_previous_intermediate_rewards(&mut block.state_mut())?;
-        let rewards = stake::drain_previous_rewards(&mut block.state_mut())?;
+        stake::v0::move_current_to_previous_intermediate_rewards(&mut block.state_mut())?;
+        let rewards = stake::v0::drain_previous_rewards(&mut block.state_mut())?;
         for (address, reward) in rewards {
             self.machine.add_balance(block, &address, reward)?;
         }

core/src/consensus/stake/action_data.rs

@@ -18,7 +18,6 @@ use std::cmp::Ordering;
 use std::collections::btree_map::{BTreeMap, Entry};
 use std::collections::btree_set::{self, BTreeSet};
 use std::collections::{btree_map, HashMap, HashSet};
-use std::mem;
 use std::ops::Deref;
 use std::vec;
 
@@ -408,51 +407,116 @@ impl IntoIterator for Validators {
     }
 }
 
-#[derive(Default, Debug, PartialEq)]
-pub struct IntermediateRewards {
-    previous: BTreeMap<Address, u64>,
-    current: BTreeMap<Address, u64>,
-}
+pub mod v0 {
+    use std::mem;
 
-impl IntermediateRewards {
-    pub fn load_from_state(state: &TopLevelState) -> StateResult<Self> {
-        let key = get_intermediate_rewards_key();
-        let action_data = state.action_data(&key)?;
-        let (previous, current) = decode_map_tuple(action_data.as_ref());
+    use super::*;
 
-        Ok(Self {
-            previous,
-            current,
-        })
+    #[derive(Default, Debug, PartialEq)]
+    pub struct IntermediateRewards {
+        pub(super) previous: BTreeMap<Address, u64>,
+        pub(super) current: BTreeMap<Address, u64>,
     }
 
-    pub fn save_to_state(&self, state: &mut TopLevelState) -> StateResult<()> {
-        let key = get_intermediate_rewards_key();
-        if self.previous.is_empty() && self.current.is_empty() {
-            state.remove_action_data(&key);
-        } else {
-            let encoded = encode_map_tuple(&self.previous, &self.current);
-            state.update_action_data(&key, encoded)?;
+    impl IntermediateRewards {
+        pub fn load_from_state(state: &TopLevelState) -> StateResult<Self> {
+            let key = get_intermediate_rewards_key();
+            let action_data = state.action_data(&key)?;
+            let (previous, current) = decode_map_tuple(action_data.as_ref());
+
+            Ok(Self {
+                previous,
+                current,
+            })
         }
-        Ok(())
-    }
 
-    pub fn add_quantity(&mut self, address: Address, quantity: StakeQuantity) {
-        if quantity == 0 {
-            return
+        pub fn save_to_state(&self, state: &mut TopLevelState) -> StateResult<()> {
+            let key = get_intermediate_rewards_key();
+            if self.previous.is_empty() && self.current.is_empty() {
+                state.remove_action_data(&key);
+            } else {
+                let encoded = encode_map_tuple(&self.previous, &self.current);
+                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 drain_previous(&mut self) -> BTreeMap<Address, u64> {
+            let mut new = BTreeMap::new();
+            mem::swap(&mut new, &mut self.previous);
+            new
+        }
+
+        pub fn move_current_to_previous(&mut self) {
+            assert!(self.previous.is_empty());
+            mem::swap(&mut self.previous, &mut self.current);
         }
-        *self.current.entry(address).or_insert(0) += quantity;
     }
+}
+
+pub mod v1 {
+    use std::mem;
+
+    use super::*;
 
-    pub fn drain_previous(&mut self) -> BTreeMap<Address, u64> {
-        let mut new = BTreeMap::new();
-        mem::swap(&mut new, &mut self.previous);
-        new
+    #[derive(Default, Debug, PartialEq)]
+    pub struct IntermediateRewards {
+        pub(super) current: BTreeMap<Address, u64>,
+        pub(super) calculated: BTreeMap<Address, u64>,
     }
 
-    pub fn move_current_to_previous(&mut self) {
-        assert!(self.previous.is_empty());
-        mem::swap(&mut self.previous, &mut self.current);
+    impl IntermediateRewards {
+        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
+        }
     }
 }
 
@@ -1129,46 +1193,99 @@ 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 = v0::IntermediateRewards::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 = v0::IntermediateRewards::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 = v0::IntermediateRewards::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 = v0::IntermediateRewards::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 = v0::IntermediateRewards::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 = v0::IntermediateRewards::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 save_v0_and_load_v1_intermediate_rewards() {
+        let address1 = Address::random();
+        let address2 = Address::random();
+        let mut state = helpers::get_temp_state();
+        let mut origin_rewards = v0::IntermediateRewards::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 = v1::IntermediateRewards::load_from_state(&state).unwrap();
+        assert_eq!(origin_rewards.previous, recovered_rewards.current);
+        assert_eq!(origin_rewards.current, recovered_rewards.calculated);
+    }
+
+    #[test]
+    fn load_and_save_intermediate_rewards_v1() {
+        let mut state = helpers::get_temp_state();
+        let rewards = v1::IntermediateRewards::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 = v1::IntermediateRewards::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 = v1::IntermediateRewards::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 = v1::IntermediateRewards::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 = v1::IntermediateRewards::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 = v1::IntermediateRewards::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,7 @@ 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, Jail, ReleaseResult, StakeAccount, Stakeholders};
 pub use self::actions::Action;
 pub use self::distribute::fee_distribute;
 use super::ValidatorSet;
@@ -321,24 +321,61 @@ pub fn get_validators(state: &TopLevelState) -> StateResult<Validators> {
     Validators::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);
-    rewards.save_to_state(state)?;
-    Ok(())
-}
+pub mod v0 {
+    use super::action_data::v0::IntermediateRewards;
+    use super::*;
+
+    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)?;
+        Ok(())
+    }
+
+    pub fn drain_previous_rewards(state: &mut TopLevelState) -> StateResult<BTreeMap<Address, u64>> {
+        let mut rewards = IntermediateRewards::load_from_state(state)?;
+        let drained = rewards.drain_previous();
+        rewards.save_to_state(state)?;
+        Ok(drained)
+    }
 
-pub fn drain_previous_rewards(state: &mut TopLevelState) -> StateResult<BTreeMap<Address, u64>> {
-    let mut rewards = IntermediateRewards::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)?;
+        rewards.move_current_to_previous();
+        rewards.save_to_state(state)
+    }
 }
 
-pub fn move_current_to_previous_intermediate_rewards(state: &mut TopLevelState) -> StateResult<()> {
-    let mut rewards = IntermediateRewards::load_from_state(state)?;
-    rewards.move_current_to_previous();
-    rewards.save_to_state(state)
+pub mod v1 {
+    use super::action_data::v1::IntermediateRewards;
+    use super::*;
+
+    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)?;
+        Ok(())
+    }
+
+    pub fn drain_current_rewards(state: &mut TopLevelState) -> StateResult<BTreeMap<Address, u64>> {
+        let mut rewards = IntermediateRewards::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 = IntermediateRewards::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 = IntermediateRewards::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<()> {