Implement Staking Reward Eras basics (#1589)

Implement the basic functionality of tracking and rotating Reward Era. Closes #1567
Does not include anything to do with the Reward Pool.

- [x] Chain spec updated
- [x] Design doc(s) updated
- [x] Tests added

Author: shannonwells

pallets/capacity/src/lib.rs

@@ -70,7 +70,7 @@ pub use common_primitives::{
 
 #[cfg(feature = "runtime-benchmarks")]
 use common_primitives::benchmarks::RegisterProviderBenchmarkHelper;
-use common_primitives::{capacity::StakingType, node::RewardEra};
+use common_primitives::capacity::StakingType;
 
 pub use pallet::*;
 pub use types::*;
@@ -231,6 +231,12 @@ pub mod pallet {
 	pub type EpochLength<T: Config> =
 		StorageValue<_, T::BlockNumber, ValueQuery, EpochLengthDefault<T>>;
 
+	/// Information for the current era
+	#[pallet::storage]
+	#[pallet::getter(fn get_current_era)]
+	pub type CurrentEraInfo<T: Config> =
+		StorageValue<_, RewardEraInfo<T::RewardEra, T::BlockNumber>, ValueQuery>;
+
 	// Simple declaration of the `Pallet` type. It is placeholder we use to implement traits and
 	// method.
 	#[pallet::pallet]
@@ -325,6 +331,7 @@ pub mod pallet {
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(current: T::BlockNumber) -> Weight {
 			Self::start_new_epoch_if_needed(current)
+				.saturating_add(Self::start_new_reward_era_if_needed(current))
 		}
 	}
 
@@ -631,7 +638,23 @@ impl<T: Config> Pallet<T> {
 				.saturating_add(T::DbWeight::get().writes(2))
 		} else {
 			// 1 for get_current_epoch_info, 1 for get_epoch_length
-			T::DbWeight::get().reads(2u64).saturating_add(RocksDbWeight::get().writes(1))
+			T::DbWeight::get().reads(2).saturating_add(RocksDbWeight::get().writes(1))
+		}
+	}
+
+	fn start_new_reward_era_if_needed(current_block: T::BlockNumber) -> Weight {
+		let current_era_info: RewardEraInfo<T::RewardEra, T::BlockNumber> = Self::get_current_era();
+		if current_block.saturating_sub(current_era_info.era_start) >= T::EraLength::get().into() {
+			CurrentEraInfo::<T>::set(RewardEraInfo {
+				current_era: current_era_info.current_era.saturating_add(1u8.into()),
+				era_start: current_block,
+			});
+			// TODO: modify reads/writes as needed when RewardPoolInfo stuff is added
+			T::WeightInfo::on_initialize()
+				.saturating_add(T::DbWeight::get().reads(1))
+				.saturating_add(T::DbWeight::get().writes(1))
+		} else {
+			T::DbWeight::get().reads(2).saturating_add(RocksDbWeight::get().writes(1))
 		}
 	}
 

pallets/capacity/src/tests/eras_tests.rs

@@ -0,0 +1,25 @@
+use super::mock::*;
+use crate::{
+	tests::testing_utils::{run_to_block, system_run_to_block},
+	Config, CurrentEraInfo, Error, Event, RewardEraInfo,
+};
+
+use frame_support::traits::Get;
+
+#[test]
+fn start_new_era_if_needed() {
+	new_test_ext().execute_with(|| {
+		CurrentEraInfo::<Test>::set(RewardEraInfo { current_era: 1, era_start: 0 });
+		system_run_to_block(9);
+		run_to_block(10);
+		let mut current_era_info = CurrentEraInfo::<Test>::get();
+		assert_eq!(current_era_info.current_era, 2u32);
+		assert_eq!(current_era_info.era_start, 10u32);
+
+		system_run_to_block(19);
+		run_to_block(20);
+		current_era_info = CurrentEraInfo::<Test>::get();
+		assert_eq!(current_era_info.current_era, 3u32);
+		assert_eq!(current_era_info.era_start, 20u32);
+	})
+}

pallets/capacity/src/tests/mod.rs

@@ -1,5 +1,6 @@
 pub mod capacity_details_tests;
 pub mod epochs_tests;
+mod eras_tests;
 pub mod mock;
 pub mod other_tests;
 pub mod replenishment_tests;

pallets/capacity/src/types.rs

@@ -29,10 +29,10 @@ pub struct StakingAccountDetails<T: Config> {
 	/// What type of staking this account is doing
 	pub staking_type: StakingType,
 	/// The None or Some(number): never, or the last RewardEra that this account's rewards were claimed.
-	pub last_rewards_claimed_at: Option<RewardEra>,
+	pub last_rewards_claimed_at: Option<T::RewardEra>,
 	/// Chunks that have been retargeted within T::UnstakingThawPeriod
 	pub stake_change_unlocking:
-		BoundedVec<UnlockChunk<BalanceOf<T>, RewardEra>, T::MaxUnlockingChunks>,
+		BoundedVec<UnlockChunk<BalanceOf<T>, T::RewardEra>, T::MaxUnlockingChunks>,
 }
 
 /// The type that is used to record a single request for a number of tokens to be unlocked.
@@ -260,25 +260,25 @@ pub struct StakingRewardClaim<T: Config> {
 	/// The end state of the staking account if the operations are valid
 	pub staking_account_end_state: StakingAccountDetails<T>,
 	/// The starting era for the claimed reward period, inclusive
-	pub from_era: RewardEra,
+	pub from_era: T::RewardEra,
 	/// The ending era for the claimed reward period, inclusive
-	pub to_era: RewardEra,
+	pub to_era: T::RewardEra,
 }
 
 /// A trait that provides the Economic Model for Provider Boosting.
 pub trait StakingRewardsProvider<T: Config> {
 	/// Return the size of the reward pool for the given era, in token
 	/// Errors:
 	///     - EraOutOfRange when `era` is prior to the history retention limit, or greater than the current Era.
-	fn reward_pool_size(era: RewardEra) -> BalanceOf<T>;
+	fn reward_pool_size(era: T::RewardEra) -> BalanceOf<T>;
 
 	/// Return the total unclaimed reward in token for `accountId` for `from_era` --> `to_era`, inclusive
 	/// Errors:
 	///     - EraOutOfRange when from_era or to_era are prior to the history retention limit, or greater than the current Era.
 	fn staking_reward_total(
-		account_id: AccountId,
-		from_era: RewardEra,
-		to_era: RewardEra,
+		account_id: T::AccountId,
+		from_era: T::RewardEra,
+		to_era: T::RewardEra,
 	) -> BalanceOf<T>;
 
 	/// Validate a payout claim for `accountId`, using `proof` and the provided `payload` StakingRewardClaim.
@@ -303,5 +303,16 @@ pub trait StakingRewardsProvider<T: Config> {
 	fn payout_eligible(account_id: AccountId) -> bool;
 }
 
+/// The information needed to track a Reward Era
+#[derive(
+	PartialEq, Eq, Clone, Default, PartialOrd, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen,
+)]
+pub struct RewardEraInfo<RewardEra, BlockNumber> {
+	/// the index of this era
+	pub current_era: RewardEra,
+	/// the starting block of this era
+	pub era_start: BlockNumber,
+}
+
 /// Needed data about a RewardPool for a given RewardEra.
 pub struct RewardPoolInfo {}