Move sp-npos-elections-solution-type to frame-election-provider-support (#11016)

* Move `sp-npos-elections-solution-type` to `frame-election-provider-support` First stab at it, will need to amend some more stuff * Fixing tests * Fixing tests * Fixing cargo.toml for std configuration * fmt * Committing suggested changes renaming, and re exporting macro. * Removing unneeded imports
2026-06-11 14:11:09 +00:00 · 2022-03-14 10:00:41 +00:00
parent 46891e849f
commit 644140f9da
35 changed files with 616 additions and 536 deletions
@@ -2160,10 +2160,26 @@ dependencies = [
 "sp-trie",
 ]

+[[package]]
+name = "frame-election-provider-solution-type"
+version = "4.0.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "proc-macro-crate 1.1.0",
+ "proc-macro2",
+ "quote",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-npos-elections",
+ "syn",
+ "trybuild",
+]
+
 [[package]]
 name = "frame-election-provider-support"
 version = "4.0.0-dev"
 dependencies = [
+ "frame-election-provider-solution-type",
 "frame-support",
 "frame-system",
 "parity-scale-codec",
@@ -2176,6 +2192,21 @@ dependencies = [
 "sp-std",
 ]

+[[package]]
+name = "frame-election-solution-type-fuzzer"
+version = "2.0.0-alpha.5"
+dependencies = [
+ "clap 3.0.7",
+ "frame-election-provider-solution-type",
+ "honggfuzz",
+ "parity-scale-codec",
+ "rand 0.8.4",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-npos-elections",
+ "sp-runtime",
+]
+
 [[package]]
 name = "frame-executive"
 version = "4.0.0-dev"
@@ -10058,7 +10089,6 @@ dependencies = [
 "serde",
 "sp-arithmetic",
 "sp-core",
- "sp-npos-elections-solution-type",
 "sp-runtime",
 "sp-std",
 "substrate-test-utils",
@@ -10077,21 +10107,6 @@ dependencies = [
 "sp-runtime",
 ]

-[[package]]
-name = "sp-npos-elections-solution-type"
-version = "4.0.0-dev"
-dependencies = [
- "parity-scale-codec",
- "proc-macro-crate 1.1.0",
- "proc-macro2",
- "quote",
- "scale-info",
- "sp-arithmetic",
- "sp-npos-elections",
- "syn",
- "trybuild",
-]
-
 [[package]]
 name = "sp-offchain"
 version = "4.0.0-dev"
@@ -86,6 +86,8 @@ members = [
 	"frame/try-runtime",
 	"frame/election-provider-multi-phase",
 	"frame/election-provider-support",
+	"frame/election-provider-support/solution-type",
+	"frame/election-provider-support/solution-type/fuzzer",
 	"frame/examples/basic",
 	"frame/examples/offchain-worker",
 	"frame/examples/parallel",
@@ -169,7 +171,6 @@ members = [
 	"primitives/keystore",
 	"primitives/maybe-compressed-blob",
 	"primitives/npos-elections",
-	"primitives/npos-elections/solution-type",
 	"primitives/npos-elections/fuzzer",
 	"primitives/offchain",
 	"primitives/panic-handler",
@@ -588,7 +588,7 @@ parameter_types! {
 		.get(DispatchClass::Normal);
 }

-sp_npos_elections::generate_solution_type!(
+frame_election_provider_support::generate_solution_type!(
 	#[compact]
 	pub struct NposSolution16::<
 		VoterIndex = u32,
@@ -46,8 +46,7 @@ sp-core = { version = "6.0.0", default-features = false, path = "../../primitive
 sp-io = { version = "6.0.0", path = "../../primitives/io" }
 sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../primitives/npos-elections" }
 sp-tracing = { version = "5.0.0", path = "../../primitives/tracing" }
-frame-election-provider-support = { version = "4.0.0-dev", features = [
-], path = "../election-provider-support" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
 pallet-balances = { version = "4.0.0-dev", path = "../balances" }
 frame-benchmarking = { version = "4.0.0-dev", path = "../benchmarking" }

@@ -68,7 +68,7 @@ pub(crate) type BlockNumber = u64;
 pub(crate) type VoterIndex = u32;
 pub(crate) type TargetIndex = u16;

-sp_npos_elections::generate_solution_type!(
+frame_election_provider_support::generate_solution_type!(
 	#[compact]
 	pub struct TestNposSolution::<VoterIndex = VoterIndex, TargetIndex = TargetIndex, Accuracy = PerU16>(16)
 );
@@ -21,6 +21,7 @@ sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = ".
 sp-runtime = { version = "6.0.0", default-features = false, path = "../../primitives/runtime" }
 frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
 frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+frame-election-provider-solution-type = { version = "4.0.0-dev", path = "solution-type" }

 [dev-dependencies]
 sp-npos-elections = { version = "4.0.0-dev", path = "../../primitives/npos-elections" }
@@ -1,5 +1,5 @@
 [package]
-name = "sp-npos-elections-solution-type"
+name = "frame-election-provider-solution-type"
 version = "4.0.0-dev"
 authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2021"
@@ -23,7 +23,7 @@ proc-macro-crate = "1.1.0"
 [dev-dependencies]
 parity-scale-codec = "3.0.0"
 scale-info = "2.0.1"
-sp-arithmetic = { path = "../../arithmetic", version = "5.0.0"}
+sp-arithmetic = { version = "5.0.0", path = "../../../primitives/arithmetic" }
 # used by generate_solution_type:
-sp-npos-elections = { path = "..", version = "4.0.0-dev" }
+sp-npos-elections = { version = "4.0.0-dev", path = "../../../primitives/npos-elections" }
 trybuild = "1.0.53"
@@ -0,0 +1,30 @@
+[package]
+name = "frame-election-solution-type-fuzzer"
+version = "2.0.0-alpha.5"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzzer for phragmén solution type implementation."
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+clap = { version = "3.0", features = ["derive"] }
+honggfuzz = "0.5"
+rand = { version = "0.8", features = ["std", "small_rng"] }
+
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+frame-election-provider-solution-type = { version = "4.0.0-dev", path = ".." }
+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" }
+
+[[bin]]
+name = "compact"
+path = "src/compact.rs"
@@ -1,5 +1,6 @@
+use frame_election_provider_solution_type::generate_solution_type;
 use honggfuzz::fuzz;
-use sp_npos_elections::{generate_solution_type, sp_arithmetic::Percent};
+use sp_arithmetic::Percent;
 use sp_runtime::codec::{Encode, Error};

 fn main() {
@@ -57,7 +57,7 @@ pub(crate) fn syn_err(message: &'static str) -> syn::Error {
 /// type, `u8` target type and `Perbill` accuracy with maximum of 4 edges per voter.
 ///
 /// ```
-/// # use sp_npos_elections_solution_type::generate_solution_type;
+/// # use frame_election_provider_solution_type::generate_solution_type;
 /// # use sp_arithmetic::per_things::Perbill;
 /// generate_solution_type!(pub struct TestSolution::<
 ///     VoterIndex = u16,
@@ -100,7 +100,7 @@ pub(crate) fn syn_err(message: &'static str) -> syn::Error {
 /// for numbers will be used, similar to how `parity-scale-codec`'s `Compact` works.
 ///
 /// ```
-/// # use sp_npos_elections_solution_type::generate_solution_type;
+/// # use frame_election_provider_solution_type::generate_solution_type;
 /// # use sp_npos_elections::NposSolution;
 /// # use sp_arithmetic::per_things::Perbill;
 /// generate_solution_type!(
@@ -0,0 +1,178 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Mock file for solution-type.
+
+#![cfg(test)]
+
+use std::{collections::HashMap, convert::TryInto, hash::Hash, HashSet};
+
+use rand::{seq::SliceRandom, Rng};
+
+/// 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);
+
+pub type TestAccuracy = sp_runtime::Perbill;
+
+pub fn p(p: u8) -> TestAccuracy {
+	TestAccuracy::from_percent(p.into())
+}
+
+pub type MockAssignment = crate::Assignment<AccountId, TestAccuracy>;
+pub type Voter = (AccountId, VoteWeight, Vec<AccountId>);
+
+crate::generate_solution_type! {
+	pub struct TestSolution::<
+		VoterIndex = u32,
+		TargetIndex = u16,
+		Accuracy = TestAccuracy,
+	>(16)
+}
+
+/// Generate voter and assignment lists. Makes no attempt to be realistic about winner or assignment
+/// fairness.
+///
+/// Maintains these invariants:
+///
+/// - candidate ids have `CANDIDATE_MASK` bit set
+/// - voter ids do not have `CANDIDATE_MASK` bit set
+/// - assignments have the same ordering as voters
+/// - `assignments.distribution.iter().map(|(_, frac)| frac).sum() == One::one()`
+/// - a coherent set of winners is chosen.
+/// - the winner set is a subset of the candidate set.
+/// - `assignments.distribution.iter().all(|(who, _)| winners.contains(who))`
+pub fn generate_random_votes(
+	candidate_count: usize,
+	voter_count: usize,
+	mut rng: impl Rng,
+) -> (Vec<Voter>, Vec<MockAssignment>, Vec<AccountId>) {
+	// cache for fast generation of unique candidate and voter ids
+	let mut used_ids = HashSet::with_capacity(candidate_count + voter_count);
+
+	// candidates are easy: just a completely random set of IDs
+	let mut candidates: Vec<AccountId> = Vec::with_capacity(candidate_count);
+	while candidates.len() < candidate_count {
+		let mut new = || rng.gen::<AccountId>() | CANDIDATE_MASK;
+		let mut id = new();
+		// insert returns `false` when the value was already present
+		while !used_ids.insert(id) {
+			id = new();
+		}
+		candidates.push(id);
+	}
+
+	// voters are random ids, random weights, random selection from the candidates
+	let mut voters = Vec::with_capacity(voter_count);
+	while voters.len() < voter_count {
+		let mut new = || rng.gen::<AccountId>() & !CANDIDATE_MASK;
+		let mut id = new();
+		// insert returns `false` when the value was already present
+		while !used_ids.insert(id) {
+			id = new();
+		}
+
+		let vote_weight = rng.gen();
+
+		// it's not interesting if a voter chooses 0 or all candidates, so rule those cases out.
+		// also, let's not generate any cases which result in a compact overflow.
+		let n_candidates_chosen =
+			rng.gen_range(1, candidates.len().min(<TestSolution as crate::NposSolution>::LIMIT));
+
+		let mut chosen_candidates = Vec::with_capacity(n_candidates_chosen);
+		chosen_candidates.extend(candidates.choose_multiple(&mut rng, n_candidates_chosen));
+		voters.push((id, vote_weight, chosen_candidates));
+	}
+
+	// always generate a sensible number of winners: elections are uninteresting if nobody wins,
+	// or everybody wins
+	let num_winners = rng.gen_range(1, candidate_count);
+	let mut winners: HashSet<AccountId> = HashSet::with_capacity(num_winners);
+	winners.extend(candidates.choose_multiple(&mut rng, num_winners));
+	assert_eq!(winners.len(), num_winners);
+
+	let mut assignments = Vec::with_capacity(voters.len());
+	for (voter_id, _, votes) in voters.iter() {
+		let chosen_winners = votes.iter().filter(|vote| winners.contains(vote)).cloned();
+		let num_chosen_winners = chosen_winners.clone().count();
+
+		// distribute the available stake randomly
+		let stake_distribution = if num_chosen_winners == 0 {
+			continue
+		} else {
+			let mut available_stake = 1000;
+			let mut stake_distribution = Vec::with_capacity(num_chosen_winners);
+			for _ in 0..num_chosen_winners - 1 {
+				let stake = rng.gen_range(0, available_stake).min(1);
+				stake_distribution.push(TestAccuracy::from_perthousand(stake));
+				available_stake -= stake;
+			}
+			stake_distribution.push(TestAccuracy::from_perthousand(available_stake));
+			stake_distribution.shuffle(&mut rng);
+			stake_distribution
+		};
+
+		assignments.push(MockAssignment {
+			who: *voter_id,
+			distribution: chosen_winners.zip(stake_distribution).collect(),
+		});
+	}
+
+	(voters, assignments, candidates)
+}
+
+fn generate_cache<Voters, Item>(voters: Voters) -> HashMap<Item, usize>
+where
+	Voters: Iterator<Item = Item>,
+	Item: Hash + Eq + Copy,
+{
+	let mut cache = HashMap::new();
+	for (idx, voter_id) in voters.enumerate() {
+		cache.insert(voter_id, idx);
+	}
+	cache
+}
+
+/// Create a function that returns the index of a voter in the voters list.
+pub fn make_voter_fn<VoterIndex>(voters: &[Voter]) -> impl Fn(&AccountId) -> Option<VoterIndex>
+where
+	usize: TryInto<VoterIndex>,
+{
+	let cache = generate_cache(voters.iter().map(|(id, _, _)| *id));
+	move |who| {
+		if cache.get(who).is_none() {
+			println!("WARNING: voter {} will raise InvalidIndex", who);
+		}
+		cache.get(who).cloned().and_then(|i| i.try_into().ok())
+	}
+}
+
+/// Create a function that returns the index of a candidate in the candidates list.
+pub fn make_target_fn<TargetIndex>(
+	candidates: &[AccountId],
+) -> impl Fn(&AccountId) -> Option<TargetIndex>
+where
+	usize: TryInto<TargetIndex>,
+{
+	let cache = generate_cache(candidates.iter().cloned());
+	move |who| {
+		if cache.get(who).is_none() {
+			println!("WARNING: target {} will raise InvalidIndex", who);
+		}
+		cache.get(who).cloned().and_then(|i| i.try_into().ok())
+	}
+}
@@ -0,0 +1,350 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests for solution-type.
+
+#![cfg(test)]
+
+use crate::{mock::*, IndexAssignment, NposSolution};
+use rand::SeedableRng;
+use std::convert::TryInto;
+
+mod solution_type {
+	use super::*;
+	use codec::{Decode, Encode};
+	// these need to come from the same dev-dependency `sp-npos-elections`, not from the crate.
+	use crate::{generate_solution_type, Assignment, Error as NposError, NposSolution};
+	use sp_std::{convert::TryInto, fmt::Debug};
+
+	#[allow(dead_code)]
+	mod __private {
+		// This is just to make sure that the solution can be generated in a scope without any
+		// imports.
+		use crate::generate_solution_type;
+		generate_solution_type!(
+			#[compact]
+			struct InnerTestSolutionIsolated::<VoterIndex = u32, TargetIndex = u8, Accuracy = sp_runtime::Percent>(12)
+		);
+	}
+
+	#[test]
+	fn solution_struct_works_with_and_without_compact() {
+		// we use u32 size to make sure compact is smaller.
+		let without_compact = {
+			generate_solution_type!(
+				pub struct InnerTestSolution::<
+					VoterIndex = u32,
+					TargetIndex = u32,
+					Accuracy = TestAccuracy,
+				>(16)
+			);
+			let solution = InnerTestSolution {
+				votes1: vec![(2, 20), (4, 40)],
+				votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+				..Default::default()
+			};
+
+			solution.encode().len()
+		};
+
+		let with_compact = {
+			generate_solution_type!(
+				#[compact]
+				pub struct InnerTestSolutionCompact::<
+					VoterIndex = u32,
+					TargetIndex = u32,
+					Accuracy = TestAccuracy,
+				>(16)
+			);
+			let compact = InnerTestSolutionCompact {
+				votes1: vec![(2, 20), (4, 40)],
+				votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+				..Default::default()
+			};
+
+			compact.encode().len()
+		};
+
+		assert!(with_compact < without_compact);
+	}
+
+	#[test]
+	fn solution_struct_is_codec() {
+		let solution = TestSolution {
+			votes1: vec![(2, 20), (4, 40)],
+			votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+			..Default::default()
+		};
+
+		let encoded = solution.encode();
+
+		assert_eq!(solution, Decode::decode(&mut &encoded[..]).unwrap());
+		assert_eq!(solution.voter_count(), 4);
+		assert_eq!(solution.edge_count(), 2 + 4);
+		assert_eq!(solution.unique_targets(), vec![10, 11, 20, 40, 50, 51]);
+	}
+
+	#[test]
+	fn remove_voter_works() {
+		let mut solution = TestSolution {
+			votes1: vec![(0, 2), (1, 6)],
+			votes2: vec![(2, [(0, p(80))], 1), (3, [(7, p(85))], 8)],
+			votes3: vec![(4, [(3, p(50)), (4, p(25))], 5)],
+			..Default::default()
+		};
+
+		assert!(!solution.remove_voter(11));
+		assert!(solution.remove_voter(2));
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2), (1, 6)],
+				votes2: vec![(3, [(7, p(85))], 8)],
+				votes3: vec![(4, [(3, p(50)), (4, p(25))], 5,)],
+				..Default::default()
+			},
+		);
+
+		assert!(solution.remove_voter(4));
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2), (1, 6)],
+				votes2: vec![(3, [(7, p(85))], 8)],
+				..Default::default()
+			},
+		);
+
+		assert!(solution.remove_voter(1));
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2)],
+				votes2: vec![(3, [(7, p(85))], 8),],
+				..Default::default()
+			},
+		);
+	}
+
+	#[test]
+	fn from_and_into_assignment_works() {
+		let voters = vec![2 as AccountId, 4, 1, 5, 3];
+		let targets = vec![
+			10 as AccountId,
+			11,
+			20, // 2
+			30,
+			31, // 4
+			32,
+			40, // 6
+			50,
+			51, // 8
+		];
+
+		let assignments = vec![
+			Assignment { who: 2 as AccountId, distribution: vec![(20u64, p(100))] },
+			Assignment { who: 4, distribution: vec![(40, p(100))] },
+			Assignment { who: 1, distribution: vec![(10, p(80)), (11, p(20))] },
+			Assignment { who: 5, distribution: vec![(50, p(85)), (51, p(15))] },
+			Assignment { who: 3, distribution: vec![(30, p(50)), (31, p(25)), (32, p(25))] },
+		];
+
+		let voter_index = |a: &AccountId| -> Option<u32> {
+			voters.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+		let target_index = |a: &AccountId| -> Option<u16> {
+			targets.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+
+		let solution =
+			TestSolution::from_assignment(&assignments, voter_index, target_index).unwrap();
+
+		// basically number of assignments that it is encoding.
+		assert_eq!(solution.voter_count(), assignments.len());
+		assert_eq!(
+			solution.edge_count(),
+			assignments.iter().fold(0, |a, b| a + b.distribution.len()),
+		);
+
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2), (1, 6)],
+				votes2: vec![(2, [(0, p(80))], 1), (3, [(7, p(85))], 8)],
+				votes3: vec![(4, [(3, p(50)), (4, p(25))], 5)],
+				..Default::default()
+			}
+		);
+
+		assert_eq!(solution.unique_targets(), vec![0, 1, 2, 3, 4, 5, 6, 7, 8]);
+
+		let voter_at = |a: u32| -> Option<AccountId> {
+			voters.get(<u32 as TryInto<usize>>::try_into(a).unwrap()).cloned()
+		};
+		let target_at = |a: u16| -> Option<AccountId> {
+			targets.get(<u16 as TryInto<usize>>::try_into(a).unwrap()).cloned()
+		};
+
+		assert_eq!(solution.into_assignment(voter_at, target_at).unwrap(), assignments);
+	}
+
+	#[test]
+	fn unique_targets_len_edge_count_works() {
+		// we don't really care about voters here so all duplicates. This is not invalid per se.
+		let solution = TestSolution {
+			votes1: vec![(99, 1), (99, 2)],
+			votes2: vec![(99, [(3, p(10))], 7), (99, [(4, p(10))], 8)],
+			votes3: vec![(99, [(11, p(10)), (12, p(10))], 13)],
+			// ensure the last one is also counted.
+			votes16: vec![(
+				99,
+				[
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+				],
+				67,
+			)],
+			..Default::default()
+		};
+
+		assert_eq!(solution.unique_targets(), vec![1, 2, 3, 4, 7, 8, 11, 12, 13, 66, 67]);
+		assert_eq!(solution.edge_count(), 2 + (2 * 2) + 3 + 16);
+		assert_eq!(solution.voter_count(), 6);
+
+		// this one has some duplicates.
+		let solution = TestSolution {
+			votes1: vec![(99, 1), (99, 1)],
+			votes2: vec![(99, [(3, p(10))], 7), (99, [(4, p(10))], 8)],
+			votes3: vec![(99, [(11, p(10)), (11, p(10))], 13)],
+			..Default::default()
+		};
+
+		assert_eq!(solution.unique_targets(), vec![1, 3, 4, 7, 8, 11, 13]);
+		assert_eq!(solution.edge_count(), 2 + (2 * 2) + 3);
+		assert_eq!(solution.voter_count(), 5);
+	}
+
+	#[test]
+	fn solution_into_assignment_must_report_overflow() {
+		// in votes2
+		let solution = TestSolution {
+			votes1: Default::default(),
+			votes2: vec![(0, [(1, p(100))], 2)],
+			..Default::default()
+		};
+
+		let voter_at = |a: u32| -> Option<AccountId> { Some(a as AccountId) };
+		let target_at = |a: u16| -> Option<AccountId> { Some(a as AccountId) };
+
+		assert_eq!(
+			solution.into_assignment(&voter_at, &target_at).unwrap_err(),
+			NposError::SolutionWeightOverflow,
+		);
+
+		// in votes3 onwards
+		let solution = TestSolution {
+			votes1: Default::default(),
+			votes2: Default::default(),
+			votes3: vec![(0, [(1, p(70)), (2, p(80))], 3)],
+			..Default::default()
+		};
+
+		assert_eq!(
+			solution.into_assignment(&voter_at, &target_at).unwrap_err(),
+			NposError::SolutionWeightOverflow,
+		);
+	}
+
+	#[test]
+	fn target_count_overflow_is_detected() {
+		let voter_index = |a: &AccountId| -> Option<u32> { Some(*a as u32) };
+		let target_index = |a: &AccountId| -> Option<u16> { Some(*a as u16) };
+
+		let assignments = vec![Assignment {
+			who: 1 as AccountId,
+			distribution: (10..27).map(|i| (i as AccountId, p(i as u8))).collect::<Vec<_>>(),
+		}];
+
+		let solution = TestSolution::from_assignment(&assignments, voter_index, target_index);
+		assert_eq!(solution.unwrap_err(), NposError::SolutionTargetOverflow);
+	}
+
+	#[test]
+	fn zero_target_count_is_ignored() {
+		let voters = vec![1 as AccountId, 2];
+		let targets = vec![10 as AccountId, 11];
+
+		let assignments = vec![
+			Assignment { who: 1 as AccountId, distribution: vec![(10, p(50)), (11, p(50))] },
+			Assignment { who: 2, distribution: vec![] },
+		];
+
+		let voter_index = |a: &AccountId| -> Option<u32> {
+			voters.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+		let target_index = |a: &AccountId| -> Option<u16> {
+			targets.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+
+		let solution =
+			TestSolution::from_assignment(&assignments, voter_index, target_index).unwrap();
+
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: Default::default(),
+				votes2: vec![(0, [(0, p(50))], 1)],
+				..Default::default()
+			}
+		);
+	}
+}
+
+#[test]
+fn index_assignments_generate_same_solution_as_plain_assignments() {
+	let rng = rand::rngs::SmallRng::seed_from_u64(0);
+
+	let (voters, assignments, candidates) = generate_random_votes(1000, 2500, rng);
+	let voter_index = make_voter_fn(&voters);
+	let target_index = make_target_fn(&candidates);
+
+	let solution =
+		TestSolution::from_assignment(&assignments, &voter_index, &target_index).unwrap();
+
+	let index_assignments = assignments
+		.into_iter()
+		.map(|assignment| IndexAssignment::new(&assignment, &voter_index, &target_index))
+		.collect::<Result<Vec<_>, _>>()
+		.unwrap();
+
+	let index_compact = index_assignments.as_slice().try_into().unwrap();
+
+	assert_eq!(solution, index_compact);
+}
@@ -1,4 +1,4 @@
-use sp_npos_elections_solution_type::generate_solution_type;
+use frame_election_provider_solution_type::generate_solution_type;

 generate_solution_type!(pub struct TestSolution::<
 	VoterIndex = u16,
@@ -1,4 +1,4 @@
-use sp_npos_elections_solution_type::generate_solution_type;
+use frame_election_provider_solution_type::generate_solution_type;

 generate_solution_type!(pub struct TestSolution::<
 	VoterIndex = u16,
@@ -1,4 +1,4 @@
-use sp_npos_elections_solution_type::generate_solution_type;
+use frame_election_provider_solution_type::generate_solution_type;

 generate_solution_type!(pub struct TestSolution::<
 	u16,
@@ -1,4 +1,4 @@
-use sp_npos_elections_solution_type::generate_solution_type;
+use frame_election_provider_solution_type::generate_solution_type;

 generate_solution_type!(pub struct TestSolution::<
 	u16,
@@ -1,4 +1,4 @@
-use sp_npos_elections_solution_type::generate_solution_type;
+use frame_election_provider_solution_type::generate_solution_type;

 generate_solution_type!(pub struct TestSolution::<
 	TargetIndex = u16,
@@ -1,4 +1,4 @@
-use sp_npos_elections_solution_type::generate_solution_type;
+use frame_election_provider_solution_type::generate_solution_type;

 generate_solution_type!(
 	#[pages(1)] pub struct TestSolution::<
@@ -172,6 +172,7 @@ use sp_runtime::traits::Bounded;
 use sp_std::{fmt::Debug, prelude::*};

 /// Re-export some type as they are used in the interface.
+pub use frame_election_provider_solution_type::generate_solution_type;
 pub use sp_arithmetic::PerThing;
 pub use sp_npos_elections::{
 	Assignment, ElectionResult, ExtendedBalance, IdentifierT, PerThing128, Support, Supports,
@@ -302,7 +302,7 @@ mod pallet;
 use codec::{Decode, Encode, HasCompact};
 use frame_support::{
 	parameter_types,
-	traits::{ConstU32, Currency, Get},
+	traits::{Currency, Get},
 	weights::Weight,
 	BoundedVec, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
 };
@@ -861,6 +861,6 @@ pub struct TestBenchmarkingConfig;

 #[cfg(feature = "std")]
 impl BenchmarkingConfig for TestBenchmarkingConfig {
-	type MaxValidators = ConstU32<100>;
-	type MaxNominators = ConstU32<100>;
+	type MaxValidators = frame_support::traits::ConstU32<100>;
+	type MaxNominators = frame_support::traits::ConstU32<100>;
 }
@@ -17,7 +17,6 @@ codec = { package = "parity-scale-codec", version = "3.0.0", default-features =
 scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
 serde = { version = "1.0.136", optional = true, features = ["derive"] }
 sp-std = { version = "4.0.0", default-features = false, path = "../std" }
-sp-npos-elections-solution-type = { version = "4.0.0-dev", path = "./solution-type" }
 sp-arithmetic = { version = "5.0.0", default-features = false, path = "../arithmetic" }
 sp-core = { version = "6.0.0", default-features = false, path = "../core" }
 sp-runtime = { version = "6.0.0", path = "../runtime", default-features = false }
@@ -35,10 +35,6 @@ path = "src/phragmen_balancing.rs"
 name = "phragmms_balancing"
 path = "src/phragmms_balancing.rs"

-[[bin]]
-name = "compact"
-path = "src/compact.rs"
-
 [[bin]]
 name = "phragmen_pjr"
 path = "src/phragmen_pjr.rs"
@@ -77,7 +77,9 @@
 use scale_info::TypeInfo;
 use sp_arithmetic::{traits::Zero, Normalizable, PerThing, Rational128, ThresholdOrd};
 use sp_core::RuntimeDebug;
-use sp_std::{cell::RefCell, cmp::Ordering, collections::btree_map::BTreeMap, prelude::*, rc::Rc};
+use sp_std::{
+	cell::RefCell, cmp::Ordering, collections::btree_map::BTreeMap, prelude::*, rc::Rc, vec,
+};

 use codec::{Decode, Encode, MaxEncodedLen};
 #[cfg(feature = "std")]
@@ -117,9 +119,6 @@ pub use sp_arithmetic;
 #[doc(hidden)]
 pub use sp_std;

-// re-export the solution type macro.
-pub use sp_npos_elections_solution_type::generate_solution_type;
-
 /// The errors that might occur in the this crate and solution-type.
 #[derive(Eq, PartialEq, RuntimeDebug)]
 pub enum Error {
@@ -19,13 +19,6 @@

 #![cfg(test)]

-use std::{
-	collections::{HashMap, HashSet},
-	convert::TryInto,
-	hash::Hash,
-};
-
-use rand::{self, seq::SliceRandom, Rng};
 use sp_arithmetic::{
 	traits::{One, SaturatedConversion, Zero},
 	PerThing,
@@ -37,27 +30,6 @@ use crate::{seq_phragmen, Assignment, ElectionResult, ExtendedBalance, PerThing1

 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);
-
-pub type TestAccuracy = sp_runtime::Perbill;
-
-crate::generate_solution_type! {
-	pub struct TestSolution::<
-		VoterIndex = u32,
-		TargetIndex = u16,
-		Accuracy = TestAccuracy,
-	>(16)
-}
-
-pub fn p(p: u8) -> TestAccuracy {
-	TestAccuracy::from_percent(p.into())
-}
-
-pub type MockAssignment = crate::Assignment<AccountId, TestAccuracy>;
-pub type Voter = (AccountId, VoteWeight, Vec<AccountId>);
-
 #[derive(Default, Debug)]
 pub(crate) struct _Candidate<A> {
 	who: A,
@@ -412,136 +384,3 @@ pub(crate) fn build_support_map_float(
 	}
 	supports
 }
-
-/// Generate voter and assignment lists. Makes no attempt to be realistic about winner or assignment
-/// fairness.
-///
-/// Maintains these invariants:
-///
-/// - candidate ids have `CANDIDATE_MASK` bit set
-/// - voter ids do not have `CANDIDATE_MASK` bit set
-/// - assignments have the same ordering as voters
-/// - `assignments.distribution.iter().map(|(_, frac)| frac).sum() == One::one()`
-/// - a coherent set of winners is chosen.
-/// - the winner set is a subset of the candidate set.
-/// - `assignments.distribution.iter().all(|(who, _)| winners.contains(who))`
-pub fn generate_random_votes(
-	candidate_count: usize,
-	voter_count: usize,
-	mut rng: impl Rng,
-) -> (Vec<Voter>, Vec<MockAssignment>, Vec<AccountId>) {
-	// cache for fast generation of unique candidate and voter ids
-	let mut used_ids = HashSet::with_capacity(candidate_count + voter_count);
-
-	// candidates are easy: just a completely random set of IDs
-	let mut candidates: Vec<AccountId> = Vec::with_capacity(candidate_count);
-	while candidates.len() < candidate_count {
-		let mut new = || rng.gen::<AccountId>() | CANDIDATE_MASK;
-		let mut id = new();
-		// insert returns `false` when the value was already present
-		while !used_ids.insert(id) {
-			id = new();
-		}
-		candidates.push(id);
-	}
-
-	// voters are random ids, random weights, random selection from the candidates
-	let mut voters = Vec::with_capacity(voter_count);
-	while voters.len() < voter_count {
-		let mut new = || rng.gen::<AccountId>() & !CANDIDATE_MASK;
-		let mut id = new();
-		// insert returns `false` when the value was already present
-		while !used_ids.insert(id) {
-			id = new();
-		}
-
-		let vote_weight = rng.gen();
-
-		// it's not interesting if a voter chooses 0 or all candidates, so rule those cases out.
-		// also, let's not generate any cases which result in a compact overflow.
-		let n_candidates_chosen =
-			rng.gen_range(1, candidates.len().min(<TestSolution as crate::NposSolution>::LIMIT));
-
-		let mut chosen_candidates = Vec::with_capacity(n_candidates_chosen);
-		chosen_candidates.extend(candidates.choose_multiple(&mut rng, n_candidates_chosen));
-		voters.push((id, vote_weight, chosen_candidates));
-	}
-
-	// always generate a sensible number of winners: elections are uninteresting if nobody wins,
-	// or everybody wins
-	let num_winners = rng.gen_range(1, candidate_count);
-	let mut winners: HashSet<AccountId> = HashSet::with_capacity(num_winners);
-	winners.extend(candidates.choose_multiple(&mut rng, num_winners));
-	assert_eq!(winners.len(), num_winners);
-
-	let mut assignments = Vec::with_capacity(voters.len());
-	for (voter_id, _, votes) in voters.iter() {
-		let chosen_winners = votes.iter().filter(|vote| winners.contains(vote)).cloned();
-		let num_chosen_winners = chosen_winners.clone().count();
-
-		// distribute the available stake randomly
-		let stake_distribution = if num_chosen_winners == 0 {
-			continue
-		} else {
-			let mut available_stake = 1000;
-			let mut stake_distribution = Vec::with_capacity(num_chosen_winners);
-			for _ in 0..num_chosen_winners - 1 {
-				let stake = rng.gen_range(0, available_stake).min(1);
-				stake_distribution.push(TestAccuracy::from_perthousand(stake));
-				available_stake -= stake;
-			}
-			stake_distribution.push(TestAccuracy::from_perthousand(available_stake));
-			stake_distribution.shuffle(&mut rng);
-			stake_distribution
-		};
-
-		assignments.push(MockAssignment {
-			who: *voter_id,
-			distribution: chosen_winners.zip(stake_distribution).collect(),
-		});
-	}
-
-	(voters, assignments, candidates)
-}
-
-fn generate_cache<Voters, Item>(voters: Voters) -> HashMap<Item, usize>
-where
-	Voters: Iterator<Item = Item>,
-	Item: Hash + Eq + Copy,
-{
-	let mut cache = HashMap::new();
-	for (idx, voter_id) in voters.enumerate() {
-		cache.insert(voter_id, idx);
-	}
-	cache
-}
-
-/// Create a function that returns the index of a voter in the voters list.
-pub fn make_voter_fn<VoterIndex>(voters: &[Voter]) -> impl Fn(&AccountId) -> Option<VoterIndex>
-where
-	usize: TryInto<VoterIndex>,
-{
-	let cache = generate_cache(voters.iter().map(|(id, _, _)| *id));
-	move |who| {
-		if cache.get(who).is_none() {
-			println!("WARNING: voter {} will raise InvalidIndex", who);
-		}
-		cache.get(who).cloned().and_then(|i| i.try_into().ok())
-	}
-}
-
-/// Create a function that returns the index of a candidate in the candidates list.
-pub fn make_target_fn<TargetIndex>(
-	candidates: &[AccountId],
-) -> impl Fn(&AccountId) -> Option<TargetIndex>
-where
-	usize: TryInto<TargetIndex>,
-{
-	let cache = generate_cache(candidates.iter().cloned());
-	move |who| {
-		if cache.get(who).is_none() {
-			println!("WARNING: target {} will raise InvalidIndex", who);
-		}
-		cache.get(who).cloned().and_then(|i| i.try_into().ok())
-	}
-}
@@ -19,12 +19,9 @@

 use crate::{
 	balancing, helpers::*, mock::*, seq_phragmen, seq_phragmen_core, setup_inputs, to_support_map,
-	Assignment, ElectionResult, ExtendedBalance, IndexAssignment, NposSolution, StakedAssignment,
-	Support, Voter,
+	Assignment, ElectionResult, ExtendedBalance, StakedAssignment, Support, Voter,
 };
-use rand::{self, SeedableRng};
 use sp_arithmetic::{PerU16, Perbill, Percent, Permill};
-use std::convert::TryInto;
 use substrate_test_utils::assert_eq_uvec;

 #[test]
@@ -919,329 +916,3 @@ mod score {
 		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([10, 5, 25]));
 	}
 }
-
-mod solution_type {
-	use super::*;
-	use codec::{Decode, Encode};
-	// these need to come from the same dev-dependency `sp-npos-elections`, not from the crate.
-	use crate::{generate_solution_type, Assignment, Error as NposError, NposSolution};
-	use sp_std::{convert::TryInto, fmt::Debug};
-
-	#[allow(dead_code)]
-	mod __private {
-		// This is just to make sure that the solution can be generated in a scope without any
-		// imports.
-		use crate::generate_solution_type;
-		generate_solution_type!(
-			#[compact]
-			struct InnerTestSolutionIsolated::<VoterIndex = u32, TargetIndex = u8, Accuracy = sp_runtime::Percent>(12)
-		);
-	}
-
-	#[test]
-	fn solution_struct_works_with_and_without_compact() {
-		// we use u32 size to make sure compact is smaller.
-		let without_compact = {
-			generate_solution_type!(
-				pub struct InnerTestSolution::<
-					VoterIndex = u32,
-					TargetIndex = u32,
-					Accuracy = TestAccuracy,
-				>(16)
-			);
-			let solution = InnerTestSolution {
-				votes1: vec![(2, 20), (4, 40)],
-				votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
-				..Default::default()
-			};
-
-			solution.encode().len()
-		};
-
-		let with_compact = {
-			generate_solution_type!(
-				#[compact]
-				pub struct InnerTestSolutionCompact::<
-					VoterIndex = u32,
-					TargetIndex = u32,
-					Accuracy = TestAccuracy,
-				>(16)
-			);
-			let compact = InnerTestSolutionCompact {
-				votes1: vec![(2, 20), (4, 40)],
-				votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
-				..Default::default()
-			};
-
-			compact.encode().len()
-		};
-
-		assert!(with_compact < without_compact);
-	}
-
-	#[test]
-	fn solution_struct_is_codec() {
-		let solution = TestSolution {
-			votes1: vec![(2, 20), (4, 40)],
-			votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
-			..Default::default()
-		};
-
-		let encoded = solution.encode();
-
-		assert_eq!(solution, Decode::decode(&mut &encoded[..]).unwrap());
-		assert_eq!(solution.voter_count(), 4);
-		assert_eq!(solution.edge_count(), 2 + 4);
-		assert_eq!(solution.unique_targets(), vec![10, 11, 20, 40, 50, 51]);
-	}
-
-	#[test]
-	fn remove_voter_works() {
-		let mut solution = TestSolution {
-			votes1: vec![(0, 2), (1, 6)],
-			votes2: vec![(2, [(0, p(80))], 1), (3, [(7, p(85))], 8)],
-			votes3: vec![(4, [(3, p(50)), (4, p(25))], 5)],
-			..Default::default()
-		};
-
-		assert!(!solution.remove_voter(11));
-		assert!(solution.remove_voter(2));
-		assert_eq!(
-			solution,
-			TestSolution {
-				votes1: vec![(0, 2), (1, 6)],
-				votes2: vec![(3, [(7, p(85))], 8)],
-				votes3: vec![(4, [(3, p(50)), (4, p(25))], 5,)],
-				..Default::default()
-			},
-		);
-
-		assert!(solution.remove_voter(4));
-		assert_eq!(
-			solution,
-			TestSolution {
-				votes1: vec![(0, 2), (1, 6)],
-				votes2: vec![(3, [(7, p(85))], 8)],
-				..Default::default()
-			},
-		);
-
-		assert!(solution.remove_voter(1));
-		assert_eq!(
-			solution,
-			TestSolution {
-				votes1: vec![(0, 2)],
-				votes2: vec![(3, [(7, p(85))], 8),],
-				..Default::default()
-			},
-		);
-	}
-
-	#[test]
-	fn from_and_into_assignment_works() {
-		let voters = vec![2 as AccountId, 4, 1, 5, 3];
-		let targets = vec![
-			10 as AccountId,
-			11,
-			20, // 2
-			30,
-			31, // 4
-			32,
-			40, // 6
-			50,
-			51, // 8
-		];
-
-		let assignments = vec![
-			Assignment { who: 2 as AccountId, distribution: vec![(20u64, p(100))] },
-			Assignment { who: 4, distribution: vec![(40, p(100))] },
-			Assignment { who: 1, distribution: vec![(10, p(80)), (11, p(20))] },
-			Assignment { who: 5, distribution: vec![(50, p(85)), (51, p(15))] },
-			Assignment { who: 3, distribution: vec![(30, p(50)), (31, p(25)), (32, p(25))] },
-		];
-
-		let voter_index = |a: &AccountId| -> Option<u32> {
-			voters.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
-		};
-		let target_index = |a: &AccountId| -> Option<u16> {
-			targets.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
-		};
-
-		let solution =
-			TestSolution::from_assignment(&assignments, voter_index, target_index).unwrap();
-
-		// basically number of assignments that it is encoding.
-		assert_eq!(solution.voter_count(), assignments.len());
-		assert_eq!(
-			solution.edge_count(),
-			assignments.iter().fold(0, |a, b| a + b.distribution.len()),
-		);
-
-		assert_eq!(
-			solution,
-			TestSolution {
-				votes1: vec![(0, 2), (1, 6)],
-				votes2: vec![(2, [(0, p(80))], 1), (3, [(7, p(85))], 8)],
-				votes3: vec![(4, [(3, p(50)), (4, p(25))], 5)],
-				..Default::default()
-			}
-		);
-
-		assert_eq!(solution.unique_targets(), vec![0, 1, 2, 3, 4, 5, 6, 7, 8]);
-
-		let voter_at = |a: u32| -> Option<AccountId> {
-			voters.get(<u32 as TryInto<usize>>::try_into(a).unwrap()).cloned()
-		};
-		let target_at = |a: u16| -> Option<AccountId> {
-			targets.get(<u16 as TryInto<usize>>::try_into(a).unwrap()).cloned()
-		};
-
-		assert_eq!(solution.into_assignment(voter_at, target_at).unwrap(), assignments);
-	}
-
-	#[test]
-	fn unique_targets_len_edge_count_works() {
-		// we don't really care about voters here so all duplicates. This is not invalid per se.
-		let solution = TestSolution {
-			votes1: vec![(99, 1), (99, 2)],
-			votes2: vec![(99, [(3, p(10))], 7), (99, [(4, p(10))], 8)],
-			votes3: vec![(99, [(11, p(10)), (12, p(10))], 13)],
-			// ensure the last one is also counted.
-			votes16: vec![(
-				99,
-				[
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-					(66, p(10)),
-				],
-				67,
-			)],
-			..Default::default()
-		};
-
-		assert_eq!(solution.unique_targets(), vec![1, 2, 3, 4, 7, 8, 11, 12, 13, 66, 67]);
-		assert_eq!(solution.edge_count(), 2 + (2 * 2) + 3 + 16);
-		assert_eq!(solution.voter_count(), 6);
-
-		// this one has some duplicates.
-		let solution = TestSolution {
-			votes1: vec![(99, 1), (99, 1)],
-			votes2: vec![(99, [(3, p(10))], 7), (99, [(4, p(10))], 8)],
-			votes3: vec![(99, [(11, p(10)), (11, p(10))], 13)],
-			..Default::default()
-		};
-
-		assert_eq!(solution.unique_targets(), vec![1, 3, 4, 7, 8, 11, 13]);
-		assert_eq!(solution.edge_count(), 2 + (2 * 2) + 3);
-		assert_eq!(solution.voter_count(), 5);
-	}
-
-	#[test]
-	fn solution_into_assignment_must_report_overflow() {
-		// in votes2
-		let solution = TestSolution {
-			votes1: Default::default(),
-			votes2: vec![(0, [(1, p(100))], 2)],
-			..Default::default()
-		};
-
-		let voter_at = |a: u32| -> Option<AccountId> { Some(a as AccountId) };
-		let target_at = |a: u16| -> Option<AccountId> { Some(a as AccountId) };
-
-		assert_eq!(
-			solution.into_assignment(&voter_at, &target_at).unwrap_err(),
-			NposError::SolutionWeightOverflow,
-		);
-
-		// in votes3 onwards
-		let solution = TestSolution {
-			votes1: Default::default(),
-			votes2: Default::default(),
-			votes3: vec![(0, [(1, p(70)), (2, p(80))], 3)],
-			..Default::default()
-		};
-
-		assert_eq!(
-			solution.into_assignment(&voter_at, &target_at).unwrap_err(),
-			NposError::SolutionWeightOverflow,
-		);
-	}
-
-	#[test]
-	fn target_count_overflow_is_detected() {
-		let voter_index = |a: &AccountId| -> Option<u32> { Some(*a as u32) };
-		let target_index = |a: &AccountId| -> Option<u16> { Some(*a as u16) };
-
-		let assignments = vec![Assignment {
-			who: 1 as AccountId,
-			distribution: (10..27).map(|i| (i as AccountId, p(i as u8))).collect::<Vec<_>>(),
-		}];
-
-		let solution = TestSolution::from_assignment(&assignments, voter_index, target_index);
-		assert_eq!(solution.unwrap_err(), NposError::SolutionTargetOverflow);
-	}
-
-	#[test]
-	fn zero_target_count_is_ignored() {
-		let voters = vec![1 as AccountId, 2];
-		let targets = vec![10 as AccountId, 11];
-
-		let assignments = vec![
-			Assignment { who: 1 as AccountId, distribution: vec![(10, p(50)), (11, p(50))] },
-			Assignment { who: 2, distribution: vec![] },
-		];
-
-		let voter_index = |a: &AccountId| -> Option<u32> {
-			voters.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
-		};
-		let target_index = |a: &AccountId| -> Option<u16> {
-			targets.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
-		};
-
-		let solution =
-			TestSolution::from_assignment(&assignments, voter_index, target_index).unwrap();
-
-		assert_eq!(
-			solution,
-			TestSolution {
-				votes1: Default::default(),
-				votes2: vec![(0, [(0, p(50))], 1)],
-				..Default::default()
-			}
-		);
-	}
-}
-
-#[test]
-fn index_assignments_generate_same_solution_as_plain_assignments() {
-	let rng = rand::rngs::SmallRng::seed_from_u64(0);
-
-	let (voters, assignments, candidates) = generate_random_votes(1000, 2500, rng);
-	let voter_index = make_voter_fn(&voters);
-	let target_index = make_target_fn(&candidates);
-
-	let solution =
-		TestSolution::from_assignment(&assignments, &voter_index, &target_index).unwrap();
-
-	let index_assignments = assignments
-		.into_iter()
-		.map(|assignment| IndexAssignment::new(&assignment, &voter_index, &target_index))
-		.collect::<Result<Vec<_>, _>>()
-		.unwrap();
-
-	let index_compact = index_assignments.as_slice().try_into().unwrap();
-
-	assert_eq!(solution, index_compact);
-}