Implementing MaxEncodedLen for generate_solution_type

bin/node/runtime/src/lib.rs

@@ -597,11 +597,13 @@ frame_election_provider_support::generate_solution_type!(
 		VoterIndex = u32,
 		TargetIndex = u16,
 		Accuracy = sp_runtime::PerU16,
+		MaxVoters = MaxElectingVoters,
 	>(16)
 );
 
 parameter_types! {
 	pub MaxNominations: u32 = <NposSolution16 as frame_election_provider_support::NposSolution>::LIMIT as u32;
+	pub MaxElectingVoters: u32 = 10_000;
 }
 
 /// The numbers configured here could always be more than the the maximum limits of staking pallet
@@ -677,7 +679,7 @@ impl pallet_election_provider_multi_phase::Config for Runtime {
 	>;
 	type ForceOrigin = EnsureRootOrHalfCouncil;
 	type MaxElectableTargets = ConstU16<{ u16::MAX }>;
-	type MaxElectingVoters = ConstU32<10_000>;
+	type MaxElectingVoters = MaxElectingVoters;
 	type BenchmarkingConfig = ElectionProviderBenchmarkConfig;
 	type WeightInfo = pallet_election_provider_multi_phase::weights::SubstrateWeight<Self>;
 }

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

@@ -70,7 +70,12 @@ pub(crate) type TargetIndex = u16;
 
 frame_election_provider_support::generate_solution_type!(
 	#[compact]
-	pub struct TestNposSolution::<VoterIndex = VoterIndex, TargetIndex = TargetIndex, Accuracy = PerU16>(16)
+	pub struct TestNposSolution::<
+		VoterIndex = VoterIndex,
+		TargetIndex = TargetIndex,
+		Accuracy = PerU16,
+		MaxVoters = ConstU32::<20>
+	>(16)
 );
 
 /// All events of this pallet.

frame/election-provider-support/Cargo.toml

@@ -24,6 +24,7 @@ frame-system = { version = "4.0.0-dev", default-features = false, path = "../sys
 frame-election-provider-solution-type = { version = "4.0.0-dev", path = "solution-type" }
 
 [dev-dependencies]
+rand = "0.7.3"
 sp-npos-elections = { version = "4.0.0-dev", path = "../../primitives/npos-elections" }
 sp-core = { version = "6.0.0", path = "../../primitives/core" }
 sp-io = { version = "6.0.0", path = "../../primitives/io" }

frame/election-provider-support/solution-type/Cargo.toml

@@ -26,4 +26,5 @@ scale-info = "2.0.1"
 sp-arithmetic = { version = "5.0.0", path = "../../../primitives/arithmetic" }
 # used by generate_solution_type:
 frame-election-provider-support = { version = "4.0.0-dev", path = ".." }
+frame-support = { version = "4.0.0-dev", path = "../../support" }
 trybuild = "1.0.53"

frame/election-provider-support/solution-type/fuzzer/Cargo.toml

@@ -25,6 +25,7 @@ sp-arithmetic = { version = "5.0.0", path = "../../../../primitives/arithmetic"
 sp-runtime = { version = "6.0.0", path = "../../../../primitives/runtime" }
 # used by generate_solution_type:
 sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../../../primitives/npos-elections" }
+frame-support = { version = "4.0.0-dev", path = "../../../support" }
 
 [[bin]]
 name = "compact"

frame/election-provider-support/solution-type/fuzzer/src/compact.rs

@@ -8,6 +8,7 @@ fn main() {
 		VoterIndex = u32,
 		TargetIndex = u32,
 		Accuracy = Percent,
+		MaxVoters = frame_support::traits::ConstU32::<100_000>,
 	>(16));
 	loop {
 		fuzz!(|fuzzer_data: &[u8]| {

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

@@ -49,6 +49,8 @@ pub(crate) fn syn_err(message: &'static str) -> syn::Error {
 ///   compact encoding.
 /// - The accuracy of the ratios. This must be one of the `PerThing` types defined in
 ///   `sp-arithmetic`.
+/// - The maximum number of voters per snapshot. This must be of type `Get<u32>`. Check <https://github.com/paritytech/substrate/issues/10866>
+///   for more details
 ///
 /// Moreover, the maximum number of edges per voter (distribution per assignment) also need to be
 /// specified. Attempting to convert from/to an assignment with more distributions will fail.
@@ -59,10 +61,12 @@ pub(crate) fn syn_err(message: &'static str) -> syn::Error {
 /// ```
 /// # use frame_election_provider_solution_type::generate_solution_type;
 /// # use sp_arithmetic::per_things::Perbill;
+/// # use frame_support::traits::ConstU32;
 /// generate_solution_type!(pub struct TestSolution::<
 ///     VoterIndex = u16,
 ///     TargetIndex = u8,
 ///     Accuracy = Perbill,
+///     MaxVoters = ConstU32::<10>,
 /// >(4));
 /// ```
 ///
@@ -103,9 +107,15 @@ pub(crate) fn syn_err(message: &'static str) -> syn::Error {
 /// # use frame_election_provider_solution_type::generate_solution_type;
 /// # use frame_election_provider_support::NposSolution;
 /// # use sp_arithmetic::per_things::Perbill;
+/// # use frame_support::traits::ConstU32;
 /// generate_solution_type!(
 ///     #[compact]
-///     pub struct TestSolutionCompact::<VoterIndex = u16, TargetIndex = u8, Accuracy = Perbill>(8)
+///     pub struct TestSolutionCompact::<
+///          VoterIndex = u16,
+///          TargetIndex = u8,
+///          Accuracy = Perbill,
+///          MaxVoters = ConstU32::<10>,
+///     >(8)
 /// );
 /// ```
 #[proc_macro]
@@ -129,6 +139,7 @@ struct SolutionDef {
 	voter_type: syn::Type,
 	target_type: syn::Type,
 	weight_type: syn::Type,
+	max_voters: syn::Type,
 	count: usize,
 	compact_encoding: bool,
 }
@@ -167,11 +178,11 @@ impl Parse for SolutionDef {
 		let _ = <syn::Token![::]>::parse(input)?;
 		let generics: syn::AngleBracketedGenericArguments = input.parse()?;
 
-		if generics.args.len() != 3 {
-			return Err(syn_err("Must provide 3 generic args."))
+		if generics.args.len() != 4 {
+			return Err(syn_err("Must provide 4 generic args."))
 		}
 
-		let expected_types = ["VoterIndex", "TargetIndex", "Accuracy"];
+		let expected_types = ["VoterIndex", "TargetIndex", "Accuracy", "MaxVoters"];
 
 		let mut types: Vec<syn::Type> = generics
 			.args
@@ -197,6 +208,7 @@ impl Parse for SolutionDef {
 			})
 			.collect::<Result<_>>()?;
 
+		let max_voters = types.pop().expect("Vector of length 4 can be popped; qed");
 		let weight_type = types.pop().expect("Vector of length 3 can be popped; qed");
 		let target_type = types.pop().expect("Vector of length 2 can be popped; qed");
 		let voter_type = types.pop().expect("Vector of length 1 can be popped; qed");
@@ -205,7 +217,16 @@ impl Parse for SolutionDef {
 		let count_expr: syn::ExprParen = input.parse()?;
 		let count = parse_parenthesized_number::<usize>(count_expr)?;
 
-		Ok(Self { vis, ident, voter_type, target_type, weight_type, count, compact_encoding })
+		Ok(Self {
+			vis,
+			ident,
+			voter_type,
+			target_type,
+			weight_type,
+			max_voters,
+			count,
+			compact_encoding,
+		})
 	}
 }
 

frame/election-provider-support/solution-type/src/single_page.rs

@@ -28,6 +28,7 @@ pub(crate) fn generate(def: crate::SolutionDef) -> Result<TokenStream2> {
 		voter_type,
 		target_type,
 		weight_type,
+		max_voters,
 		compact_encoding,
 	} = def;
 
@@ -178,6 +179,25 @@ pub(crate) fn generate(def: crate::SolutionDef) -> Result<TokenStream2> {
 			<#ident as _feps::NposSolution>::TargetIndex,
 			<#ident as _feps::NposSolution>::Accuracy,
 		>;
+		impl _feps::codec::MaxEncodedLen for #ident {
+			fn max_encoded_len() -> usize {
+				use frame_support::traits::Get;
+				use _feps::codec::Encode;
+				let s: u32 = #max_voters::get();
+				// The last element of the struct is a vec with 1 voter
+				// then #count-1 tuple of target with an accuracy
+				// and then lastly the final target
+				let max_element_size = #voter_type::max_encoded_len()
+					.saturating_add((#count - 1)
+						.saturating_mul(#target_type::max_encoded_len()
+							.saturating_add(#weight_type::max_encoded_len())))
+					.saturating_add(#target_type::max_encoded_len());
+				// The assumption is that it contains #count-1 empty elements
+				// and then last element with full size
+				#count.saturating_mul(_feps::codec::Compact(0u32).encoded_size())
+					.saturating_add((s as usize).saturating_mul(max_element_size))
+			}
+		}
 		impl<'a> _feps::sp_std::convert::TryFrom<&'a [__IndexAssignment]> for #ident {
 			type Error = _feps::Error;
 			fn try_from(index_assignments: &'a [__IndexAssignment]) -> Result<Self, Self::Error> {

frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.rs

@@ -4,6 +4,7 @@ generate_solution_type!(pub struct TestSolution::<
 	VoterIndex = u16,
 	TargetIndex = u8,
 	Perbill,
+	MaxVoters = frame_support::traits::ConstU32::<10>,
 >(8));
 
 fn main() {}

frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.rs

@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	VoterIndex = u16,
+	TargetIndex = u8,
+	Accuracy = Perbill,
+	frame_support::traits::ConstU32::<10>,
+>(8));
+
+fn main() {}

frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.stderr

@@ -0,0 +1,5 @@
+error: Expected binding: `MaxVoters = ...`
+ --> tests/ui/fail/missing_size_bound.rs:7:2
+  |
+7 |     frame_support::traits::ConstU32::<10>,
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

frame/election-provider-support/solution-type/tests/ui/fail/missing_target.rs

@@ -4,6 +4,7 @@ generate_solution_type!(pub struct TestSolution::<
 	VoterIndex = u16,
 	u8,
 	Accuracy = Perbill,
+	MaxVoters = frame_support::traits::ConstU32::<10>,
 >(8));
 
 fn main() {}

frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.rs

@@ -4,6 +4,7 @@ generate_solution_type!(pub struct TestSolution::<
 	u16,
 	TargetIndex = u8,
 	Accuracy = Perbill,
+	MaxVoters = frame_support::traits::ConstU32::<10>,
 >(8));
 
 fn main() {}

frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.rs

@@ -4,6 +4,7 @@ generate_solution_type!(pub struct TestSolution::<
 	u16,
 	u8,
 	Perbill,
+	MaxVoters = frame_support::traits::ConstU32::<10>,
 >(8));
 
 fn main() {}

frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.rs

@@ -4,6 +4,7 @@ generate_solution_type!(pub struct TestSolution::<
 	TargetIndex = u16,
 	VoterIndex = u8,
 	Accuracy = Perbill,
+	MaxVoters = frame_support::traits::ConstU32::<10>,
 >(8));
 
 fn main() {}

frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.rs

@@ -5,6 +5,7 @@ generate_solution_type!(
 		VoterIndex = u8,
 		TargetIndex = u16,
 		Accuracy = Perbill,
+		MaxVoters = frame_support::traits::ConstU32::<10>,
 	>(8)
 );
 

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

@@ -192,6 +192,11 @@ pub use scale_info;
 pub use sp_arithmetic;
 #[doc(hidden)]
 pub use sp_std;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
 // Simple Extension trait to easily convert `None` from index closures to `Err`.
 //
 // This is only generated and re-exported for the solution code to use.

frame/election-provider-support/solution-type/src/mock.rs → frame/election-provider-support/src/mock.rs

@@ -19,10 +19,16 @@
 
 #![cfg(test)]
 
-use std::{collections::HashMap, convert::TryInto, hash::Hash, HashSet};
+use std::{
+	collections::{HashMap, HashSet},
+	convert::TryInto,
+	hash::Hash,
+};
 
 use rand::{seq::SliceRandom, Rng};
 
+pub type AccountId = u64;
+
 /// The candidate mask allows easy disambiguation between voters and candidates: accounts
 /// for which this bit is set are candidates, and without it, are voters.
 pub const CANDIDATE_MASK: AccountId = 1 << ((std::mem::size_of::<AccountId>() * 8) - 1);
@@ -34,13 +40,14 @@ pub fn p(p: u8) -> TestAccuracy {
 }
 
 pub type MockAssignment = crate::Assignment<AccountId, TestAccuracy>;
-pub type Voter = (AccountId, VoteWeight, Vec<AccountId>);
+pub type Voter = (AccountId, crate::VoteWeight, Vec<AccountId>);
 
 crate::generate_solution_type! {
 	pub struct TestSolution::<
 		VoterIndex = u32,
 		TargetIndex = u16,
 		Accuracy = TestAccuracy,
+		MaxVoters = frame_support::traits::ConstU32::<20>,
 	>(16)
 }