Unlimited number of nominators eligible for Rewards payout

frame/fast-unstake/src/lib.rs

@@ -147,6 +147,8 @@ pub mod pallet {
 	/// The map of all accounts wishing to be unstaked.
 	///
 	/// Keeps track of `AccountId` wishing to unstake and it's corresponding deposit.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
 	#[pallet::storage]
 	pub type Queue<T: Config> = CountedStorageMap<_, Twox64Concat, T::AccountId, BalanceOf<T>>;
 

frame/nomination-pools/src/lib.rs

@@ -1277,6 +1277,8 @@ pub mod pallet {
 	pub type MaxPoolMembersPerPool<T: Config> = StorageValue<_, u32, OptionQuery>;
 
 	/// Active members.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
 	#[pallet::storage]
 	pub type PoolMembers<T: Config> =
 		CountedStorageMap<_, Twox64Concat, T::AccountId, PoolMember<T>>;

frame/staking/src/lib.rs

@@ -318,6 +318,7 @@ use sp_staking::{
 use sp_std::{collections::btree_map::BTreeMap, prelude::*};
 pub use weights::WeightInfo;
 
+use frame_support::traits::ConstU32;
 pub use pallet::{pallet::*, *};
 
 pub(crate) const LOG_TARGET: &str = "runtime::staking";
@@ -732,6 +733,40 @@ impl<AccountId, Balance: Default + HasCompact> Default for Exposure<AccountId, B
 	}
 }
 
+impl<AccountId: Clone, Balance: HasCompact + AtLeast32BitUnsigned + Copy>
+	Exposure<AccountId, Balance>
+{
+	fn in_chunks_of(&self, page_size: usize) -> Vec<Self> {
+		let individual_chunks = self.others.chunks(page_size);
+		let mut paged_exposure: Vec<Self> = Vec::with_capacity(individual_chunks.len());
+
+		// own balance that has not been accounted for in the paged exposure
+		let mut own_left = self.own;
+
+		for chunk in individual_chunks {
+			let own = own_left;
+			let mut total = own;
+			for individual in chunk.iter() {
+				total = total.saturating_add(individual.value);
+			}
+
+			paged_exposure.push(Exposure {
+				total,
+				own,
+				others: chunk
+					.iter()
+					.map(|c| IndividualExposure { who: c.who.clone(), value: c.value })
+					.collect(),
+			});
+
+			// subtract own that has been accounted
+			own_left = own_left.saturating_sub(own);
+		}
+
+		paged_exposure
+	}
+}
+
 /// A pending slash record. The value of the slash has been computed but not applied yet,
 /// rather deferred for several eras.
 #[derive(Encode, Decode, RuntimeDebug, TypeInfo)]
@@ -955,6 +990,6 @@ pub struct TestBenchmarkingConfig;
 
 #[cfg(feature = "std")]
 impl BenchmarkingConfig for TestBenchmarkingConfig {
-	type MaxValidators = frame_support::traits::ConstU32<100>;
-	type MaxNominators = frame_support::traits::ConstU32<100>;
+	type MaxValidators = ConstU32<100>;
+	type MaxNominators = ConstU32<100>;
 }

frame/staking/src/mock.rs

@@ -299,6 +299,7 @@ impl crate::pallet::pallet::Config for Test {
 	type EraPayout = ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
 	type MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type ExposurePageSize = ConstU32<10>;
 	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;

frame/staking/src/pallet/impls.rs

@@ -26,20 +26,18 @@ use frame_support::{
 	pallet_prelude::*,
 	traits::{
 		Currency, CurrencyToVote, Defensive, DefensiveResult, EstimateNextNewSession, Get,
-		Imbalance, LockableCurrency, OnUnbalanced, TryCollect, UnixTime, WithdrawReasons,
+		Imbalance, Len, LockableCurrency, OnUnbalanced, TryCollect, UnixTime, WithdrawReasons,
 	},
 	weights::Weight,
 };
 use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
 use pallet_session::historical;
 use sp_runtime::{
+	generic::Era,
 	traits::{Bounded, Convert, One, SaturatedConversion, Saturating, StaticLookup, Zero},
 	Perbill,
 };
-use sp_staking::{
-	offence::{DisableStrategy, OffenceDetails, OnOffenceHandler},
-	EraIndex, SessionIndex, Stake, StakingInterface,
-};
+use sp_staking::{offence::{DisableStrategy, OffenceDetails, OnOffenceHandler}, EraIndex, SessionIndex, Stake, StakingInterface, PageIndex};
 use sp_std::prelude::*;
 
 use crate::{
@@ -134,6 +132,7 @@ impl<T: Config> Pallet<T> {
 	pub(super) fn do_payout_stakers(
 		validator_stash: T::AccountId,
 		era: EraIndex,
+		page: PageIndex,
 	) -> DispatchResultWithPostInfo {
 		// Validate input data
 		let current_era = CurrentEra::<T>::get().ok_or_else(|| {
@@ -159,36 +158,45 @@ impl<T: Config> Pallet<T> {
 		})?;
 		let mut ledger = <Ledger<T>>::get(&controller).ok_or(Error::<T>::NotController)?;
 
+		// clean up older claimed rewards
 		ledger
 			.claimed_rewards
 			.retain(|&x| x >= current_era.saturating_sub(history_depth));
+		<Ledger<T>>::insert(&controller, &ledger);
 
-		match ledger.claimed_rewards.binary_search(&era) {
-			Ok(_) =>
-				return Err(Error::<T>::AlreadyClaimed
-					.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))),
-			Err(pos) => ledger
-				.claimed_rewards
-				.try_insert(pos, era)
-				// Since we retain era entries in `claimed_rewards` only upto
-				// `HistoryDepth`, following bound is always expected to be
-				// satisfied.
-				.defensive_map_err(|_| Error::<T>::BoundNotMet)?,
+		// todo(ank4n): remove
+		// match ledger.claimed_rewards.binary_search(&era) {
+		// 	Ok(_) =>
+		// 		return Err(Error::<T>::AlreadyClaimed
+		// 			.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))),
+		// 	Err(pos) => ledger
+		// 		.claimed_rewards
+		// 		.try_insert(pos, era)
+		// 		// Since we retain era entries in `claimed_rewards` only upto
+		// 		// `HistoryDepth`, following bound is always expected to be
+		// 		// satisfied.
+		// 		.defensive_map_err(|_| Error::<T>::BoundNotMet)?,
+		// }
+
+		if EraInfo::<T>::temp_is_rewards_claimed(era, &ledger, &ledger.stash, page) {
+			return Err(Error::<T>::AlreadyClaimed
+				.with_weight(T::WeightInfo::payout_stakers_alive_staked(0)))
+		} else {
+			EraInfo::<T>::set_rewards_as_claimed(era, &ledger.stash, page);
 		}
 
-		let exposure = <ErasStakersClipped<T>>::get(&era, &ledger.stash);
-
 		// Input data seems good, no errors allowed after this point
 
-		<Ledger<T>>::insert(&controller, &ledger);
-
 		// Get Era reward points. It has TOTAL and INDIVIDUAL
 		// Find the fraction of the era reward that belongs to the validator
 		// Take that fraction of the eras rewards to split to nominator and validator
 		//
 		// Then look at the validator, figure out the proportion of their reward
 		// which goes to them and each of their nominators.
 
+		let exposure = EraInfo::<T>::get_validator_exposure(era, &ledger.stash, page);
+		// let exposure = EraInfo::<T>::get_validator_exposure(&era, &ledger.stash, page);
+
 		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
 		let total_reward_points = era_reward_points.total;
 		let validator_reward_points = era_reward_points
@@ -561,31 +569,24 @@ impl<T: Config> Pallet<T> {
 		>,
 		new_planned_era: EraIndex,
 	) -> BoundedVec<T::AccountId, MaxWinnersOf<T>> {
-		let elected_stashes: BoundedVec<_, MaxWinnersOf<T>> = exposures
-			.iter()
-			.cloned()
-			.map(|(x, _)| x)
-			.collect::<Vec<_>>()
-			.try_into()
-			.expect("since we only map through exposures, size of elected_stashes is always same as exposures; qed");
-
-		// Populate stakers, exposures, and the snapshot of validator prefs.
+		// Populate elected stash, stakers, exposures, and the snapshot of validator prefs.
 		let mut total_stake: BalanceOf<T> = Zero::zero();
+		let mut elected_stashes = Vec::with_capacity(exposures.len());
+
 		exposures.into_iter().for_each(|(stash, exposure)| {
+			// build elected stash
+			elected_stashes.push(stash.clone());
+			// accumulate total stake
 			total_stake = total_stake.saturating_add(exposure.total);
-			<ErasStakers<T>>::insert(new_planned_era, &stash, &exposure);
-
-			let mut exposure_clipped = exposure;
-			let clipped_max_len = T::MaxNominatorRewardedPerValidator::get() as usize;
-			if exposure_clipped.others.len() > clipped_max_len {
-				exposure_clipped.others.sort_by(|a, b| a.value.cmp(&b.value).reverse());
-				exposure_clipped.others.truncate(clipped_max_len);
-			}
-			<ErasStakersClipped<T>>::insert(&new_planned_era, &stash, exposure_clipped);
+			// store staker exposure for this era
+			EraInfo::<T>::set_validator_exposure(new_planned_era, &stash, exposure);
 		});
 
-		// Insert current era staking information
-		<ErasTotalStake<T>>::insert(&new_planned_era, total_stake);
+		let elected_stashes: BoundedVec<_, MaxWinnersOf<T>> = elected_stashes
+			.try_into()
+			.expect("elected_stashes.len() always equal to exposures.len(); qed");
+
+		EraInfo::<T>::set_total_stake(new_planned_era, total_stake);
 
 		// Collect the pref of all winners.
 		for stash in &elected_stashes {