Finally decoupled solution from the pallet.. such a PITA.

frame/election-providers/src/lib.rs

@@ -31,14 +31,15 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use sp_std::prelude::*;
+use sp_std::{fmt::Debug, prelude::*};
+
 /// The onchain module.
 pub mod onchain;
 /// The two-phase module.
 pub mod two_phase;
 
 use sp_arithmetic::PerThing;
-use sp_npos_elections::{ExtendedBalance, Support, SupportMap};
+use sp_npos_elections::{CompactSolution, ExtendedBalance, PerThing128, Support, SupportMap};
 
 // for the helper macros
 #[doc(hidden)]
@@ -87,7 +88,11 @@ impl<A> FlattenSupportMap<A> for SupportMap<A> {
 /// }
 /// ```
 pub trait ElectionDataProvider<AccountId, B> {
-	type CompactSolution: codec::Codec + Default + PartialEq + Eq;
+	/// The compact solution type.
+	///
+	/// This should encode the entire solution with the least possible space usage.
+	type CompactSolution: codec::Codec + Default + PartialEq + Eq + Clone + Debug + CompactSolution;
+
 	/// All possible targets for the election, i.e. the candidates.
 	fn targets() -> Vec<AccountId>;
 
@@ -116,25 +121,6 @@ pub trait ElectionDataProvider<AccountId, B> {
 	fn next_election_prediction(now: B) -> B;
 }
 
-#[cfg(feature = "std")]
-impl<AccountId, B: Default> ElectionDataProvider<AccountId, B> for () {
-	fn targets() -> Vec<AccountId> {
-		Default::default()
-	}
-	fn voters() -> Vec<(AccountId, VoteWeight, Vec<AccountId>)> {
-		Default::default()
-	}
-	fn desired_targets() -> u32 {
-		Default::default()
-	}
-	fn feasibility_check_assignment<P: PerThing>(_: &AccountId, _: &[(AccountId, P)]) -> bool {
-		Default::default()
-	}
-	fn next_election_prediction(_: B) -> B {
-		Default::default()
-	}
-}
-
 /// Something that can compute the result of an election and pass it back to the caller.
 pub trait ElectionProvider<AccountId> {
 	/// Indicate weather this election provider needs data when calling [`elect`] or not.
@@ -150,18 +136,15 @@ pub trait ElectionProvider<AccountId> {
 	/// Note that based on the logic of the type that will implement this trait, the input data may
 	/// or may not be used. To hint about this to the call site, [`NEEDS_ELECT_DATA`] should be
 	/// properly set.
-	fn elect<P: PerThing>(
+	///
+	/// The implementation should, if possible, use the accuracy `P` to compute the election result.
+	fn elect<P: PerThing128>(
 		to_elect: usize, // TODO: consider making this u32
 		targets: Vec<AccountId>,
 		voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
 	) -> Result<FlatSupportMap<AccountId>, Self::Error>
 	where
-		// TODO: Okay about these two, I get that we probably need the first one, but can't we
-		// alleviate the latter one? I think we can say that all PerThing are Mul of some types.
-		// Perhaps it is time to move the PerBill macros to something better? Yeah I think then we
-		// can get rid of both of these types everywhere.
-		ExtendedBalance: From<<P as PerThing>::Inner>,
-		P: sp_std::ops::Mul<ExtendedBalance, Output = ExtendedBalance>;
+		ExtendedBalance: From<<P as PerThing>::Inner>;
 
 	/// Returns true if an election is still ongoing. This can be used by the call site to
 	/// dynamically check of a long-lasting election (such as [`two_phase`]) is still on-going or

frame/election-providers/src/onchain.rs

@@ -1,6 +1,6 @@
 use crate::{ElectionProvider, FlatSupportMap, FlattenSupportMap};
 use sp_arithmetic::PerThing;
-use sp_npos_elections::{ElectionResult, ExtendedBalance, IdentifierT, VoteWeight};
+use sp_npos_elections::{ElectionResult, ExtendedBalance, IdentifierT, PerThing128, VoteWeight};
 use sp_runtime::RuntimeDebug;
 use sp_std::{collections::btree_map::BTreeMap, prelude::*};
 
@@ -23,14 +23,13 @@ impl<AccountId: IdentifierT> ElectionProvider<AccountId> for OnChainSequentialPh
 
 	const NEEDS_ELECT_DATA: bool = true;
 
-	fn elect<P: sp_arithmetic::PerThing>(
+	fn elect<P: PerThing128>(
 		to_elect: usize,
 		targets: Vec<AccountId>,
 		voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
 	) -> Result<FlatSupportMap<AccountId>, Self::Error>
 	where
 		ExtendedBalance: From<<P as PerThing>::Inner>,
-		P: sp_std::ops::Mul<ExtendedBalance, Output = ExtendedBalance>,
 	{
 		// TODO: we really don't need to do this conversion all the time. With
 		// https://github.com/paritytech/substrate/pull/6685 merged, we should make variants of
@@ -39,6 +38,7 @@ impl<AccountId: IdentifierT> ElectionProvider<AccountId> for OnChainSequentialPh
 		// TODO: Okay even if not the above, then def. make the extension traits for converting
 		// between validator Major and Nominator Major result types, and make the conversions be
 		// lossless and painless to happen.
+
 		let mut stake_map: BTreeMap<AccountId, VoteWeight> = BTreeMap::new();
 		voters.iter().for_each(|(v, s, _)| {
 			stake_map.insert(v.clone(), *s);

frame/election-providers/src/two_phase/macros.rs

@@ -29,25 +29,25 @@ macro_rules! log {
 
 #[macro_export]
 macro_rules! voter_index_fn {
-	($voters:ident, $acc:ty) => {
-		|who: &$acc| -> Option<$crate::two_phase::VoterIndex> {
+	($voters:ident, $acc:ty, $t:ident) => {
+		|who: &$acc| -> Option<$crate::two_phase::CompactVoterIndexOf<$t>> {
 					$voters
 						.iter()
 						.position(|(x, _, _)| x == who)
-						.and_then(|i| <usize as $crate::TryInto<$crate::two_phase::VoterIndex>>::try_into(i).ok())
+						.and_then(|i| <usize as $crate::TryInto<$crate::two_phase::CompactVoterIndexOf<$t>>>::try_into(i).ok())
 					}
 	};
 }
 
 #[macro_export]
 macro_rules! target_index_fn {
-	($targets:ident, $acc:ty) => {
-		|who: &$acc| -> Option<$crate::two_phase::TargetIndex> {
-					$targets
-						.iter()
-						.position(|x| x == who)
-						.and_then(|i| <usize as $crate::TryInto<$crate::two_phase::TargetIndex>>::try_into(i).ok())
-					}
+	($targets:ident, $acc:ty, $t:ident) => {
+		|who: &$acc| -> Option<$crate::two_phase::CompactTargetIndexOf<$t>> {
+			$targets
+				.iter()
+				.position(|x| x == who)
+				.and_then(|i| <usize as $crate::TryInto<$crate::two_phase::CompactTargetIndexOf<$t>>>::try_into(i).ok())
+			}
 	};
 }
 

frame/election-providers/src/two_phase/mock.rs

@@ -1,9 +1,11 @@
 use super::*;
 use frame_support::{parameter_types, traits::OnInitialize};
 use sp_core::H256;
+use sp_npos_elections::CompactSolution;
 use sp_runtime::{
 	testing::Header,
 	traits::{BlakeTwo256, IdentityLookup},
+	PerU16,
 };
 use std::cell::RefCell;
 
@@ -17,6 +19,11 @@ pub(crate) type TwoPhase = super::Module<Runtime>;
 pub(crate) type Balance = u64;
 pub(crate) type AccountId = u64;
 
+sp_npos_elections::generate_solution_type!(
+	#[compact]
+	pub struct TestCompact::<u32, u16, PerU16>(16)
+);
+
 /// To from `now` to block `n`.
 pub fn roll_to(n: u64) {
 	let now = System::block_number();
@@ -34,21 +41,22 @@ pub fn balances(who: &AccountId) -> (Balance, Balance) {
 /// Spit out a verifiable raw solution.
 ///
 /// This is a good example of what an offchain miner would do.
-pub fn raw_solution() -> RawSolution {
+pub fn raw_solution() -> RawSolution<CompactOf<Runtime>> {
 	let voters = TwoPhase::snapshot_voters().unwrap();
 	let targets = TwoPhase::snapshot_targets().unwrap();
 	let desired = TwoPhase::desired_targets() as usize;
 
 	// closures
-	let voter_index = crate::voter_index_fn!(voters, AccountId);
-	let target_index = crate::target_index_fn!(targets, AccountId);
+	let voter_index = crate::voter_index_fn!(voters, AccountId, Runtime);
+	let target_index = crate::target_index_fn!(targets, AccountId, Runtime);
 	let stake_of = crate::stake_of_fn!(voters, AccountId);
 
 	use sp_npos_elections::{seq_phragmen, to_without_backing, ElectionResult};
 	let ElectionResult {
 		winners,
 		assignments,
-	} = seq_phragmen::<_, OffchainAccuracy>(desired, targets.clone(), voters.clone(), None).unwrap();
+	} = seq_phragmen::<_, CompactAccuracyOf<Runtime>>(desired, targets.clone(), voters.clone(), None)
+		.unwrap();
 
 	let winners = to_without_backing(winners);
 
@@ -59,17 +67,9 @@ pub fn raw_solution() -> RawSolution {
 		sp_npos_elections::evaluate_support(&support)
 	};
 	let compact =
-		CompactAssignments::from_assignment(assignments, &voter_index, &target_index).unwrap();
-	let winners = winners
-		.into_iter()
-		.map(|w| target_index(&w).unwrap())
-		.collect::<Vec<_>>();
+		<CompactOf<Runtime>>::from_assignment(assignments, &voter_index, &target_index).unwrap();
 
-	RawSolution {
-		winners,
-		compact,
-		score,
-	}
+	RawSolution { compact, score }
 }
 
 frame_support::impl_outer_origin! {
@@ -191,7 +191,7 @@ impl crate::two_phase::Trait for Runtime {
 	type SolutionImprovementThreshold = ();
 	type SlashHandler = ();
 	type RewardHandler = ();
-	type ElectionDataProvider = ExtBuilder;
+	type ElectionDataProvider = StakingMock;
 	type WeightInfo = ();
 }
 
@@ -207,7 +207,11 @@ impl Default for ExtBuilder {
 	}
 }
 
-impl crate::ElectionDataProvider<AccountId, u64> for ExtBuilder {
+pub struct StakingMock;
+
+impl crate::ElectionDataProvider<AccountId, u64> for StakingMock {
+	type CompactSolution = TestCompact;
+
 	fn targets() -> Vec<AccountId> {
 		Targets::get()
 	}