[NPoS] Implements dynamic number of nominators

frame/babe/src/mock.rs

@@ -179,8 +179,8 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type DataProvider = Staking;
 	type WeightInfo = ();
 	type MaxWinners = ConstU32<100>;
-	type VotersBound = ConstU32<{ u32::MAX }>;
-	type TargetsBound = ConstU32<{ u32::MAX }>;
+	type VotersBounds = ElectionBounds::new_unbounded();
+	type TargetsBounds = ElectionBounds::new_unbounded();
 }
 
 impl pallet_staking::Config for Test {

frame/election-provider-multi-phase/src/lib.rs

@@ -231,8 +231,8 @@
 
 use codec::{Decode, Encode};
 use frame_election_provider_support::{
-	BoundedSupportsOf, ElectionDataProvider, ElectionProvider, ElectionProviderBase,
-	InstantElectionProvider, NposSolution,
+	BoundedSupportsOf, ElectionBounds, ElectionBoundsBuilder, ElectionDataProvider,
+	ElectionProvider, ElectionProviderBase, InstantElectionProvider, NposSolution,
 };
 use frame_support::{
 	dispatch::DispatchClass,
@@ -671,6 +671,14 @@ pub mod pallet {
 		#[pallet::constant]
 		type MaxWinners: Get<u32>;
 
+		// The limits of targets to include in the snapshot per block.
+		#[pallet::constant]
+		type TargetsBounds: Get<ElectionBounds>;
+
+		// The limits of voters to include in the snapshot per block.
+		#[pallet::constant]
+		type VotersBounds: Get<ElectionBounds>;
+
 		/// Handler for the slashed deposits.
 		type SlashHandler: OnUnbalanced<NegativeImbalanceOf<Self>>;
 
@@ -1078,14 +1086,13 @@ pub mod pallet {
 		) -> DispatchResult {
 			T::ForceOrigin::ensure_origin(origin)?;
 			ensure!(Self::current_phase().is_emergency(), <Error<T>>::CallNotAllowed);
-
-			let supports =
-				T::GovernanceFallback::instant_elect(maybe_max_voters, maybe_max_targets).map_err(
-					|e| {
-						log!(error, "GovernanceFallback failed: {:?}", e);
-						Error::<T>::FallbackFailed
-					},
-				)?;
+			let voters_bounds = ElectionBoundsBuilder::new().count(maybe_max_voters).build();
+			let targets_bounds = ElectionBoundsBuilder::new().count(maybe_max_voters).build();
+			let supports = T::GovernanceFallback::instant_elect(voters_bounds, targets_bounds)
+				.map_err(|e| {
+					log!(error, "GovernanceFallback failed: {:?}", e);
+					Error::<T>::FallbackFailed
+				})?;
 
 			// transform BoundedVec<_, T::GovernanceFallback::MaxWinners> into
 			// `BoundedVec<_, T::MaxWinners>`
@@ -1401,15 +1408,19 @@ impl<T: Config> Pallet<T> {
 	/// Extracted for easier weight calculation.
 	fn create_snapshot_external(
 	) -> Result<(Vec<T::AccountId>, Vec<VoterOf<T>>, u32), ElectionError<T>> {
+		// TODO: do we need T::MaxElect* limits now or can we rely on T::*Bounds?
 		let target_limit = T::MaxElectableTargets::get().saturated_into::<usize>();
 		let voter_limit = T::MaxElectingVoters::get().saturated_into::<usize>();
 
-		let targets = T::DataProvider::electable_targets(Some(target_limit))
-			.map_err(ElectionError::DataProvider)?;
+		let targets_bounds = T::TargetsBounds::get();
+		let voters_bounds = T::VotersBounds::get();
 
-		let voters = T::DataProvider::electing_voters(Some(voter_limit))
+		let targets = T::DataProvider::electable_targets(targets_bounds)
 			.map_err(ElectionError::DataProvider)?;
 
+		let voters =
+			T::DataProvider::electing_voters(voters_bounds).map_err(ElectionError::DataProvider)?;
+
 		if targets.len() > target_limit || voters.len() > voter_limit {
 			return Err(ElectionError::DataProvider("Snapshot too big for submission."))
 		}
@@ -1589,15 +1600,18 @@ impl<T: Config> Pallet<T> {
 		<QueuedSolution<T>>::take()
 			.ok_or(ElectionError::<T>::NothingQueued)
 			.or_else(|_| {
-				T::Fallback::instant_elect(None, None)
-					.map_err(|fe| ElectionError::Fallback(fe))
-					.and_then(|supports| {
-						Ok(ReadySolution {
-							supports,
-							score: Default::default(),
-							compute: ElectionCompute::Fallback,
-						})
+				T::Fallback::instant_elect(
+					ElectionBounds::new_unbounded(),
+					ElectionBounds::new_unbounded(),
+				)
+				.map_err(|fe| ElectionError::Fallback(fe))
+				.and_then(|supports| {
+					Ok(ReadySolution {
+						supports,
+						score: Default::default(),
+						compute: ElectionCompute::Fallback,
 					})
+				})
 			})
 			.map(|ReadySolution { compute, score, supports }| {
 				Self::deposit_event(Event::ElectionFinalized { compute, score });

frame/election-provider-multi-phase/src/mock.rs

@@ -20,7 +20,7 @@ use crate::{self as multi_phase, unsigned::MinerConfig};
 use frame_election_provider_support::{
 	data_provider,
 	onchain::{self},
-	ElectionDataProvider, NposSolution, SequentialPhragmen,
+	ElectionBounds, ElectionDataProvider, NposSolution, SequentialPhragmen,
 };
 pub use frame_support::{assert_noop, assert_ok, pallet_prelude::GetDefault};
 use frame_support::{
@@ -298,6 +298,8 @@ parameter_types! {
 	pub static MaxElectingVoters: VoterIndex = u32::max_value();
 	pub static MaxElectableTargets: TargetIndex = TargetIndex::max_value();
 	pub static MaxWinners: u32 = 200;
+	pub static VotersBounds: ElectionBounds = ElectionBounds::new_unbounded();
+	pub static TargetsBounds: ElectionBounds = ElectionBounds::new_unbounded();
 
 	pub static EpochLength: u64 = 30;
 	pub static OnChainFallback: bool = true;
@@ -310,8 +312,8 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type DataProvider = StakingMock;
 	type WeightInfo = ();
 	type MaxWinners = MaxWinners;
-	type VotersBound = ConstU32<{ u32::MAX }>;
-	type TargetsBound = ConstU32<{ u32::MAX }>;
+	type VotersBounds = VotersBounds;
+	type TargetsBounds = TargetsBounds;
 }
 
 pub struct MockFallback;
@@ -325,12 +327,15 @@ impl ElectionProviderBase for MockFallback {
 
 impl InstantElectionProvider for MockFallback {
 	fn instant_elect(
-		max_voters: Option<u32>,
-		max_targets: Option<u32>,
+		voters_bounds: ElectionBounds,
+		targets_bounds: ElectionBounds,
 	) -> Result<BoundedSupportsOf<Self>, Self::Error> {
 		if OnChainFallback::get() {
-			onchain::OnChainExecution::<OnChainSeqPhragmen>::instant_elect(max_voters, max_targets)
-				.map_err(|_| "onchain::OnChainExecution failed.")
+			onchain::OnChainExecution::<OnChainSeqPhragmen>::instant_elect(
+				voters_bounds,
+				targets_bounds,
+			)
+			.map_err(|_| "onchain::OnChainExecution failed.")
 		} else {
 			Err("NoFallback.")
 		}
@@ -405,6 +410,8 @@ impl crate::Config for Runtime {
 	type MaxWinners = MaxWinners;
 	type MinerConfig = Self;
 	type Solver = SequentialPhragmen<AccountId, SolutionAccuracyOf<Runtime>, Balancing>;
+	type VotersBounds = VotersBounds;
+	type TargetsBounds = TargetsBounds;
 }
 
 impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
@@ -432,25 +439,24 @@ impl ElectionDataProvider for StakingMock {
 	type BlockNumber = u64;
 	type MaxVotesPerVoter = MaxNominations;
 
-	fn electable_targets(maybe_max_len: Option<usize>) -> data_provider::Result<Vec<AccountId>> {
+	fn electable_targets(bounds: ElectionBounds) -> data_provider::Result<Vec<AccountId>> {
 		let targets = Targets::get();
 
 		if !DataProviderAllowBadData::get() &&
-			maybe_max_len.map_or(false, |max_len| targets.len() > max_len)
+			bounds.count.map_or(false, |max_len| targets.len() > max_len as usize)
 		{
 			return Err("Targets too big")
 		}
 
 		Ok(targets)
 	}
 
-	fn electing_voters(
-		maybe_max_len: Option<usize>,
-	) -> data_provider::Result<Vec<VoterOf<Runtime>>> {
+	fn electing_voters(bounds: ElectionBounds) -> data_provider::Result<Vec<VoterOf<Runtime>>> {
 		let mut voters = Voters::get();
+
 		if !DataProviderAllowBadData::get() {
-			if let Some(max_len) = maybe_max_len {
-				voters.truncate(max_len)
+			if let Some(max_len) = bounds.count {
+				voters.truncate(max_len as usize)
 			}
 		}
 
@@ -470,6 +476,7 @@ impl ElectionDataProvider for StakingMock {
 		voters: Vec<VoterOf<Runtime>>,
 		targets: Vec<AccountId>,
 		_target_stake: Option<VoteWeight>,
+		/* TODO(gpestana): this is the absolute max nomination, make it more explicit */
 	) {
 		Targets::set(targets);
 		Voters::set(voters);

frame/election-provider-support/src/lib.rs

@@ -178,6 +178,7 @@ pub mod traits;
 use sp_runtime::traits::{Bounded, Saturating, Zero};
 use sp_std::{fmt::Debug, prelude::*};
 
+pub use codec::{Decode, Encode};
 /// Re-export the solution generation macro.
 pub use frame_election_provider_solution_type::generate_solution_type;
 pub use frame_support::{traits::Get, weights::Weight, BoundedVec, RuntimeDebug};
@@ -227,7 +228,7 @@ impl<T> __OrInvalidIndex<T> for Option<T> {
 /// making it fast to repeatedly encode into a `SolutionOf<T>`. This property turns out
 /// to be important when trimming for solution length.
 #[derive(RuntimeDebug, Clone, Default)]
-#[cfg_attr(feature = "std", derive(PartialEq, Eq, codec::Encode, codec::Decode))]
+#[cfg_attr(feature = "std", derive(PartialEq, Eq, Encode, Decode))]
 pub struct IndexAssignment<VoterIndex, TargetIndex, P: PerThing> {
 	/// Index of the voter among the voters list.
 	pub who: VoterIndex,
@@ -282,25 +283,23 @@ pub trait ElectionDataProvider {
 	/// All possible targets for the election, i.e. the targets that could become elected, thus
 	/// "electable".
 	///
-	/// If `maybe_max_len` is `Some(v)` then the resulting vector MUST NOT be longer than `v` items
-	/// long.
+	/// If `bounds` are defined, then the resulting vector MUST NOT be longer or larger in MB than
+	/// `v` items long.
 	///
 	/// This should be implemented as a self-weighing function. The implementor should register its
 	/// appropriate weight at the end of execution with the system pallet directly.
-	fn electable_targets(
-		maybe_max_len: Option<usize>,
-	) -> data_provider::Result<Vec<Self::AccountId>>;
+	fn electable_targets(bounds: ElectionBounds) -> data_provider::Result<Vec<Self::AccountId>>;
 
 	/// All the voters that participate in the election, thus "electing".
 	///
 	/// Note that if a notion of self-vote exists, it should be represented here.
 	///
-	/// If `maybe_max_len` is `Some(v)` then the resulting vector MUST NOT be longer than `v` items
-	/// long.
+	/// If `bounds` are defined, then the resulting vector MUST NOT be longer or larger in bytes
+	/// than `v` items long.
 	///
 	/// This should be implemented as a self-weighing function. The implementor should register its
 	/// appropriate weight at the end of execution with the system pallet directly.
-	fn electing_voters(maybe_max_len: Option<usize>) -> data_provider::Result<Vec<VoterOf<Self>>>;
+	fn electing_voters(bounds: ElectionBounds) -> data_provider::Result<Vec<VoterOf<Self>>>;
 
 	/// The number of targets to elect.
 	///
@@ -421,8 +420,8 @@ pub trait ElectionProvider: ElectionProviderBase {
 /// data provider at runtime via `forced_input_voters_bound` and `forced_input_target_bound`.
 pub trait InstantElectionProvider: ElectionProviderBase {
 	fn instant_elect(
-		forced_input_voters_bound: Option<u32>,
-		forced_input_target_bound: Option<u32>,
+		forced_input_voters_bound: ElectionBounds,
+		forced_input_target_bound: ElectionBounds,
 	) -> Result<BoundedSupportsOf<Self>, Self::Error>;
 }
 
@@ -464,8 +463,8 @@ where
 	MaxWinners: Get<u32>,
 {
 	fn instant_elect(
-		_: Option<u32>,
-		_: Option<u32>,
+		_: ElectionBounds,
+		_: ElectionBounds,
 	) -> Result<BoundedSupportsOf<Self>, Self::Error> {
 		Err("`NoElection` cannot do anything.")
 	}
@@ -674,3 +673,100 @@ pub type BoundedSupportsOf<E> = BoundedSupports<
 
 sp_core::generate_feature_enabled_macro!(runtime_benchmarks_enabled, feature = "runtime-benchmarks", $);
 sp_core::generate_feature_enabled_macro!(runtime_benchmarks_or_fuzz_enabled, any(feature = "runtime-benchmarks", feature = "fuzzing"), $);
+
+/// The limits of an election result. The bounds are defined over the count of element of the
+/// election (voters or targets) or the overall datastructure size.
+///
+/// Ordering: when comparing two instances of `ElectionBounds`, the `count` has priority over the
+/// `size`, ie. if `A.count > B.count`, then `A > B` regardless of their relative `size`.
+#[derive(Clone, Copy, RuntimeDebug, scale_info::TypeInfo, Encode, Decode, Eq)]
+pub struct ElectionBounds {
+	/// The bound on number of elements. `None` means unbounded.
+	pub count: Option<u32>,
+	/// The bound on size, in bytes. `None` means unbounded.
+	pub size: Option<u32>,
+}
+
+impl ElectionBounds {
+	/// Returns a new instance of self without bounds.
+	pub const fn new_unbounded() -> Self {
+		ElectionBounds { count: None, size: None }
+	}
+
+	//  Returns true if `given_count` exhausts `self.count`.
+	pub fn count_exhausted(self, given_count: Option<u32>) -> bool {
+		self.count.map_or(false, |count| given_count.unwrap_or(0) > count)
+	}
+
+	//  Returns true if `given_size` exhausts `self.size`.
+	pub fn size_exhausted(self, given_size: Option<u32>) -> bool {
+		self.size.map_or(false, |count| given_size.unwrap_or(0) > count)
+	}
+
+	// Returns true if `given_size` or `given_count` exhausts `self.size` or `self_count`
+	// respectively.
+	pub fn exhausted(self, given_size: Option<u32>, given_count: Option<u32>) -> bool {
+		self.count_exhausted(given_count) || self.size_exhausted(given_size)
+	}
+}
+
+impl PartialEq for ElectionBounds {
+	fn eq(&self, other: &Self) -> bool {
+		self.count == other.count || self.size == self.size
+	}
+}
+
+impl PartialOrd for ElectionBounds {
+	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl Ord for ElectionBounds {
+	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+		if self.count == other.count {
+			self.size.cmp(&other.size)
+		} else {
+			self.count.cmp(&other.count)
+		}
+	}
+}
+
+/// Utility builder for [`ElectionBounds`].
+///
+/// The main purpose of this is to prevent mixing the order of similarly typed arguments (e.g. u32
+/// size and count).
+#[derive(Copy, Clone)]
+pub struct ElectionBoundsBuilder {
+	count: Option<u32>,
+	size: Option<u32>,
+}
+
+impl ElectionBoundsBuilder {
+	/// Returns a new election bounds builder
+	pub fn new() -> Self {
+		ElectionBoundsBuilder { count: None, size: None }
+	}
+
+	/// Set the count of the snapshot.
+	pub fn count(mut self, count: Option<u32>) -> Self {
+		self.count = count;
+		self
+	}
+
+	/// Set the size of the snapshot.
+	pub fn size(mut self, size: Option<u32>) -> Self {
+		self.size = size;
+		self
+	}
+
+	/// Returns an instance of `ElectionBounds` from the current state.
+	pub fn build(self) -> ElectionBounds {
+		ElectionBounds { count: self.count, size: self.size }
+	}
+}
+
+#[cfg(test)]
+mod snapshot_bounds {
+	// TODO(gpestana)
+}