updates after rebase

Author: shannonwells

common/primitives/src/capacity.rs

@@ -4,8 +4,6 @@ use frame_support::traits::tokens::Balance;
 use scale_info::TypeInfo;
 use sp_api::Decode;
 use sp_runtime::DispatchError;
-use sp_runtime::traits::{AtLeast32BitUnsigned, MaybeDisplay};
-use crate::node::{AccountId, Era, Hash};
 
 /// A trait for checking that a target MSA can be staked to.
 pub trait TargetValidator {
@@ -67,35 +65,3 @@ pub enum StakingType {
 	/// and token for the account holder
 	ProviderBoost,
 }
-
-
-pub trait StakingRewardsProvider {
-	type Balance: Balance;
-	/// 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: Era) -> Self::Balance;
-
-	/// Return the total unclaimed reward in token for `accountId` for `fromEra` --> `toEra`, inclusive
-	/// Errors:
-	///     - NotAStakingAccount
-	///     - EraOutOfRange when fromEra or toEra are prior to the history retention limit, or greater than the current Era.
-	fn staking_reward_total(accountId: AccountId, fromEra: Era, toEra: Era);
-
-	/// Validate a payout claim for `accountId`, using `proof` and the provided `payload` StakingRewardClaim.
-	/// Returns whether the claim passes validation.  Accounts must first pass `payoutEligible` test.
-	/// Errors:
-	///     - NotAStakingAccount
-	///     - MaxUnlockingChunksExceeded
-	///     - All other conditions that would prevent a reward from being claimed return 'false'
-	fn validate_staking_reward_claim(accountId: AccountId, proof: Hash, payload: StakingRewardClaim) -> bool;
-
-	/// Return whether `accountId` can claim a reward. Staking accounts may not claim a reward more than once
-	/// per Era, may not claim rewards before a complete Era has been staked, and may not claim more rewards past
-	/// the number of `MaxUnlockingChunks`.
-	/// Errors:
-	///     - NotAStakingAccount
-	///     - MaxUnlockingChunksExceeded
-	///     - All other conditions that would prevent a reward from being claimed return 'false'
-	fn payout_eligible(accountId: AccountIdOf<T>) -> bool;
-}

pallets/capacity/src/lib.rs

@@ -70,22 +70,19 @@ 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::*;
 pub use weights::*;
+
 pub mod types;
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
 
 #[cfg(test)]
 mod tests;
-mod tests;
 
 pub mod weights;
 
@@ -96,9 +93,9 @@ const STAKING_ID: LockIdentifier = *b"netstkng";
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-    use codec::EncodeLike;
+	use codec::EncodeLike;
 
-	use common_primitives::capacity::{StakingType};
+	use common_primitives::capacity::StakingType;
 	use frame_support::{pallet_prelude::*, Twox64Concat};
 	use frame_system::pallet_prelude::*;
 	use sp_runtime::traits::{AtLeast32BitUnsigned, MaybeDisplay};
@@ -768,13 +765,6 @@ impl<T: Config> Pallet<T> {
 		}
 	}
 
-	/// Returns whether `account_id` may claim and and be paid token rewards.
-	pub fn payout_eligible(account_id: T::AccountId) -> bool {
-		let _staking_account =
-			Self::get_staking_account_for(account_id).ok_or(Error::<T>::StakingAccountNotFound);
-		false
-	}
-
 	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(); // 1r
 		if current_block.saturating_sub(current_era_info.started_at) >= T::EraLength::get().into() {

pallets/capacity/src/tests/eras_tests.rs

@@ -1,16 +1,51 @@
-use super::{mock::*,
-			testing_utils::{run_to_block, system_run_to_block, setup_provider}};
-use crate::{CurrentEraInfo, RewardEraInfo, StakingRewardPool, RewardPoolInfo};
+use super::{
+	mock::*,
+	testing_utils::{run_to_block, system_run_to_block},
+};
+use crate::{Config, CurrentEraInfo, RewardEraInfo, RewardPoolInfo, StakingRewardPool};
+use sp_core::Get;
 
 #[test]
-fn start_new_era_if_needed_updates_reward_pool_and_era_info() {
+fn start_new_era_if_needed_updates_era_info_and_limits_reward_pool_size() {
 	new_test_ext().execute_with(|| {
 		CurrentEraInfo::<Test>::set(RewardEraInfo { era_index: 1, started_at: 0 });
-		StakingRewardPool::<Test>::insert(1, RewardPoolInfo {
-			total_staked_token: 10_000,
-			total_reward_pool: 1_000,
-			unclaimed_balance: 1_000,
-		});
+		StakingRewardPool::<Test>::insert(
+			1,
+			RewardPoolInfo {
+				total_staked_token: 10_000,
+				total_reward_pool: 1_000,
+				unclaimed_balance: 1_000,
+			},
+		);
+		system_run_to_block(9);
+		for i in 1..4 {
+			let block_decade = i * 10;
+			run_to_block(block_decade);
+
+			let current_era_info = CurrentEraInfo::<Test>::get();
+
+			let expected_era = i + 1;
+			assert_eq!(current_era_info.era_index, expected_era);
+			assert_eq!(current_era_info.started_at, block_decade);
+			let past_eras_max: u32 = <Test as Config>::StakingRewardsPastErasMax::get();
+			assert!(StakingRewardPool::<Test>::count().le(&past_eras_max));
+			system_run_to_block(block_decade + 9);
+		}
+	})
+}
+
+#[test]
+fn start_new_era_if_needed_updates_reward_pool() {
+	new_test_ext().execute_with(|| {
+		CurrentEraInfo::<Test>::set(RewardEraInfo { era_index: 1, started_at: 0 });
+		StakingRewardPool::<Test>::insert(
+			1,
+			RewardPoolInfo {
+				total_staked_token: 10_000,
+				total_reward_pool: 1_000,
+				unclaimed_balance: 1_000,
+			},
+		);
 		system_run_to_block(8);
 
 		// TODO: Provider boost, after staking updates reward pool info
@@ -21,22 +56,19 @@ fn start_new_era_if_needed_updates_reward_pool_and_era_info() {
 
 		system_run_to_block(9);
 		run_to_block(10);
-		let mut current_era_info = CurrentEraInfo::<Test>::get();
-		assert_eq!(current_era_info.era_index, 2u32);
-		assert_eq!(current_era_info.started_at, 10u32);
-
 		assert_eq!(StakingRewardPool::<Test>::count(), 2);
 		let current_reward_pool_info = StakingRewardPool::<Test>::get(2).unwrap();
-		assert_eq!(current_reward_pool_info, RewardPoolInfo {
-			total_staked_token: 10_000,
-			total_reward_pool: 1_000,
-			unclaimed_balance: 1_000,
-		});
+		assert_eq!(
+			current_reward_pool_info,
+			RewardPoolInfo {
+				total_staked_token: 10_000,
+				total_reward_pool: 1_000,
+				unclaimed_balance: 1_000,
+			}
+		);
 
-		system_run_to_block(19);
-		run_to_block(20);
-		current_era_info = CurrentEraInfo::<Test>::get();
-        assert_eq!(current_era_info.era_index, 3u32);
-		assert_eq!(current_era_info.started_at, 20u32);
-	})
+		// TODO: after staking updates reward pool info
+		// system_run_to_block(19);
+		// run_to_block(20);
+	});
 }

pallets/capacity/src/tests/stake_and_deposit_tests.rs

@@ -2,7 +2,7 @@ use super::{mock::*, testing_utils::*};
 use crate::{BalanceOf, CapacityDetails, Error, Event, StakingAccountDetails};
 use common_primitives::{
 	capacity::{
-		Nontransferable,
+		Nontransferable, StakingType,
 		StakingType::{MaximumCapacity, ProviderBoost},
 	},
 	msa::MessageSourceId,
@@ -389,7 +389,7 @@ fn increase_stake_and_issue_capacity_errors_with_overflow() {
 				&mut staking_account,
 				&target,
 				&overflow_amount,
-				&StakingType::ProviderBoost,
+				&ProviderBoost,
 			),
 			ArithmeticError::Overflow
 		);
@@ -479,8 +479,8 @@ fn assert_successful_increase_stake_with_type(
 fn increase_stake_and_issue_capacity_happy_path() {
 	new_test_ext().execute_with(|| {
 		assert_successful_increase_stake_with_type(1, MaximumCapacity, 550, 550, 55);
-		assert_successful_increase_stake_with_type(2, StakingType::ProviderBoost, 550, 550, 3);
-		assert_successful_increase_stake_with_type(2, StakingType::ProviderBoost, 6666, 7216, 36);
+		assert_successful_increase_stake_with_type(2, ProviderBoost, 550, 550, 3);
+		assert_successful_increase_stake_with_type(2, ProviderBoost, 6666, 7216, 36);
 	});
 }
 

pallets/capacity/src/types.rs

@@ -1,16 +1,15 @@
 //! Types for the Capacity Pallet
 use super::*;
-use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::{
 	log::warn, BoundedVec, EqNoBound, PartialEqNoBound, RuntimeDebug, RuntimeDebugNoBound,
 };
 use scale_info::TypeInfo;
-use sp_runtime::traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedSub, Saturating, Zero};
+use sp_runtime::traits::{CheckedAdd, CheckedSub, Saturating, Zero};
 
 use common_primitives::capacity::StakingType;
 #[cfg(any(feature = "runtime-benchmarks", test))]
 use sp_std::vec::Vec;
-use common_primitives::node::{AccountId, Hash};
 
 /// The type used for storing information about staking details.
 #[derive(
@@ -372,27 +371,13 @@ pub trait StakingRewardsProvider<T: Config> {
 	TypeInfo,
 	MaxEncodedLen,
 )]
-pub struct RewardEraInfo<RewardEra, BlockNumber>
-where
-	RewardEra: AtLeast32BitUnsigned + EncodeLike,
-{
+pub struct RewardEraInfo<RewardEra, BlockNumber> {
 	/// the index of this era
 	pub era_index: RewardEra,
 	/// the starting block of this era
 	pub started_at: BlockNumber,
 }
 
-/// 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.
 /// The total_reward_pool balance for the previous era is set when a new era starts,
 /// based on total staked token at the end of the previous era, and remains unchanged.

runtime/frequency/src/lib.rs

@@ -78,7 +78,6 @@ pub use common_runtime::{
 };
 use frame_support::traits::Contains;
 
-use common_primitives::capacity::StakingRewardsProvider;
 #[cfg(feature = "try-runtime")]
 use frame_support::traits::TryStateSelect;
 
@@ -740,7 +739,7 @@ use pallet_frequency_tx_payment::Call as FrequencyPaymentCall;
 use pallet_handles::Call as HandlesCall;
 use pallet_messages::Call as MessagesCall;
 use pallet_msa::Call as MsaCall;
-use pallet_stateful_storage::{types::ItemAction::Delete, Call as StatefulStorageCall};
+use pallet_stateful_storage::Call as StatefulStorageCall;
 
 pub struct CapacityEligibleCalls;
 impl GetStableWeight<RuntimeCall, Weight> for CapacityEligibleCalls {