Decouple Staking and Election - Part 3: Signed Phase

bin/node/runtime/src/lib.rs

@@ -73,6 +73,7 @@ use pallet_session::{historical as pallet_session_historical};
 use sp_inherents::{InherentData, CheckInherentsResult};
 use static_assertions::const_assert;
 use pallet_contracts::weights::WeightInfo;
+use pallet_election_provider_multi_phase::FallbackStrategy;
 
 #[cfg(any(feature = "std", test))]
 pub use sp_runtime::BuildStorage;
@@ -516,9 +517,14 @@ parameter_types! {
 	pub const SignedPhase: u32 = EPOCH_DURATION_IN_BLOCKS / 4;
 	pub const UnsignedPhase: u32 = EPOCH_DURATION_IN_BLOCKS / 4;
 
-	// fallback: no need to do on-chain phragmen initially.
-	pub const Fallback: pallet_election_provider_multi_phase::FallbackStrategy =
-		pallet_election_provider_multi_phase::FallbackStrategy::Nothing;
+	// signed config
+	pub const SignedMaxSubmissions: u32 = 10;
+	pub const SignedRewardBase: Balance = 1 * DOLLARS;
+	pub const SignedDepositBase: Balance = 1 * DOLLARS;
+	pub const SignedDepositByte: Balance = 1 * CENTS;
+
+	// fallback: no on-chain fallback.
+	pub const Fallback: FallbackStrategy = FallbackStrategy::Nothing;
 
 	pub SolutionImprovementThreshold: Perbill = Perbill::from_rational(1u32, 10_000);
 
@@ -559,6 +565,14 @@ impl pallet_election_provider_multi_phase::Config for Runtime {
 	type MinerMaxWeight = MinerMaxWeight;
 	type MinerMaxLength = MinerMaxLength;
 	type MinerTxPriority = MultiPhaseUnsignedPriority;
+	type SignedMaxSubmissions = SignedMaxSubmissions;
+	type SignedRewardBase = SignedRewardBase;
+	type SignedDepositBase = SignedDepositBase;
+	type SignedDepositByte = SignedDepositByte;
+	type SignedDepositWeight = ();
+	type SignedMaxWeight = MinerMaxWeight;
+	type SlashHandler = (); // burn slashes
+	type RewardHandler = (); // nothing to do upon rewards
 	type DataProvider = Staking;
 	type OnChainAccuracy = Perbill;
 	type CompactSolution = NposCompactSolution16;
@@ -1556,6 +1570,7 @@ impl_runtime_apis! {
 			add_benchmark!(params, batches, pallet_uniques, Uniques);
 			add_benchmark!(params, batches, pallet_utility, Utility);
 			add_benchmark!(params, batches, pallet_vesting, Vesting);
+			add_benchmark!(params, batches, pallet_election_provider_multi_phase, ElectionProviderMultiPhase);
 
 			if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }
 			Ok(batches)

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

@@ -19,7 +19,7 @@
 
 use super::*;
 use crate::{Pallet as MultiPhase, unsigned::IndexAssignmentOf};
-use frame_benchmarking::impl_benchmark_test_suite;
+use frame_benchmarking::{account, impl_benchmark_test_suite};
 use frame_support::{assert_ok, traits::OnInitialize};
 use frame_system::RawOrigin;
 use rand::{prelude::SliceRandom, rngs::SmallRng, SeedableRng};
@@ -57,7 +57,7 @@ fn solution_with_size<T: Config>(
 	let targets: Vec<T::AccountId> =
 		(0..size.targets).map(|i| frame_benchmarking::account("Targets", i, SEED)).collect();
 
-	let mut rng = SmallRng::seed_from_u64(SEED as u64);
+	let mut rng = SmallRng::seed_from_u64(SEED.into());
 
 	// decide who are the winners.
 	let winners = targets
@@ -176,6 +176,39 @@ frame_benchmarking::benchmarks! {
 		assert!(<MultiPhase<T>>::current_phase().is_unsigned());
 	}
 
+	finalize_signed_phase_accept_solution {
+		let receiver = account("receiver", 0, SEED);
+		let initial_balance = T::Currency::minimum_balance() * 10u32.into();
+		T::Currency::make_free_balance_be(&receiver, initial_balance);
+		let ready: ReadySolution<T::AccountId> = Default::default();
+		let deposit: BalanceOf<T> = 10u32.into();
+		let reward: BalanceOf<T> = 20u32.into();
+
+		assert_ok!(T::Currency::reserve(&receiver, deposit));
+		assert_eq!(T::Currency::free_balance(&receiver), initial_balance - 10u32.into());
+	}: {
+		<MultiPhase<T>>::finalize_signed_phase_accept_solution(ready, &receiver, deposit, reward)
+	} verify {
+		assert_eq!(T::Currency::free_balance(&receiver), initial_balance + 20u32.into());
+		assert_eq!(T::Currency::reserved_balance(&receiver), 0u32.into());
+	}
+
+	finalize_signed_phase_reject_solution {
+		let receiver = account("receiver", 0, SEED);
+		let initial_balance = T::Currency::minimum_balance().max(One::one()) * 10u32.into();
+		let deposit: BalanceOf<T> = 10u32.into();
+		T::Currency::make_free_balance_be(&receiver, initial_balance);
+		assert_ok!(T::Currency::reserve(&receiver, deposit));
+
+		assert_eq!(T::Currency::free_balance(&receiver), initial_balance - 10u32.into());
+		assert_eq!(T::Currency::reserved_balance(&receiver), 10u32.into());
+	}: {
+		<MultiPhase<T>>::finalize_signed_phase_reject_solution(&receiver, deposit)
+	} verify {
+		assert_eq!(T::Currency::free_balance(&receiver), initial_balance - 10u32.into());
+		assert_eq!(T::Currency::reserved_balance(&receiver), 0u32.into());
+	}
+
 	on_initialize_open_unsigned_without_snapshot {
 		// need to assume signed phase was open before
 		<MultiPhase<T>>::on_initialize_open_signed().unwrap();
@@ -227,16 +260,51 @@ frame_benchmarking::benchmarks! {
 		assert!(<MultiPhase<T>>::snapshot().is_some());
 	}
 
+	submit {
+		let c in 1 .. (T::SignedMaxSubmissions::get() - 1);
+
+		// the solution will be worse than all of them meaning the score need to be checked against
+		// ~ log2(c)
+		let solution = RawSolution {
+			score: [(10_000_000u128 - 1).into(), 0, 0],
+			..Default::default()
+		};
+
+		MultiPhase::<T>::on_initialize_open_signed().expect("should be ok to start signed phase");
+		<Round<T>>::put(1);
+
+		let mut signed_submissions = SignedSubmissions::<T>::get();
+		for i in 0..c {
+			let solution = RawSolution {
+				score: [(10_000_000 + i).into(), 0, 0],
+				..Default::default()
+			};
+			let signed_submission = SignedSubmission { solution, ..Default::default() };
+			signed_submissions.insert(signed_submission);
+		}
+		signed_submissions.put();
+
+		let caller = frame_benchmarking::whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller,  T::Currency::minimum_balance() * 10u32.into());
+
+	}: _(RawOrigin::Signed(caller), solution, c)
+	verify {
+		assert!(<MultiPhase<T>>::signed_submissions().len() as u32 == c + 1);
+	}
+
 	submit_unsigned {
 		// number of votes in snapshot.
 		let v in (T::BenchmarkingConfig::VOTERS[0]) .. T::BenchmarkingConfig::VOTERS[1];
 		// number of targets in snapshot.
 		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
 		// number of assignments, i.e. compact.len(). This means the active nominators, thus must be
 		// a subset of `v` component.
-		let a in (T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		let a in
+			(T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
 		// number of desired targets. Must be a subset of `t` component.
-		let d in (T::BenchmarkingConfig::DESIRED_TARGETS[0]) .. T::BenchmarkingConfig::DESIRED_TARGETS[1];
+		let d in
+			(T::BenchmarkingConfig::DESIRED_TARGETS[0]) ..
+			T::BenchmarkingConfig::DESIRED_TARGETS[1];
 
 		let witness = SolutionOrSnapshotSize { voters: v, targets: t };
 		let raw_solution = solution_with_size::<T>(witness, a, d);
@@ -249,7 +317,8 @@ frame_benchmarking::benchmarks! {
 		let encoded_call = <Call<T>>::submit_unsigned(raw_solution.clone(), witness).encode();
 	}: {
 		assert_ok!(<MultiPhase<T>>::submit_unsigned(RawOrigin::None.into(), raw_solution, witness));
-		let _decoded_snap = <RoundSnapshot<T::AccountId> as Decode>::decode(&mut &*encoded_snapshot).unwrap();
+		let _decoded_snap = <RoundSnapshot<T::AccountId> as Decode>::decode(&mut &*encoded_snapshot)
+			.unwrap();
 		let _decoded_call = <Call<T> as Decode>::decode(&mut &*encoded_call).unwrap();
 	} verify {
 		assert!(<MultiPhase<T>>::queued_solution().is_some());
@@ -263,13 +332,17 @@ frame_benchmarking::benchmarks! {
 		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
 		// number of assignments, i.e. compact.len(). This means the active nominators, thus must be
 		// a subset of `v` component.
-		let a in (T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		let a in
+			(T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
 		// number of desired targets. Must be a subset of `t` component.
-		let d in (T::BenchmarkingConfig::DESIRED_TARGETS[0]) .. T::BenchmarkingConfig::DESIRED_TARGETS[1];
+		let d in
+			(T::BenchmarkingConfig::DESIRED_TARGETS[0]) ..
+			T::BenchmarkingConfig::DESIRED_TARGETS[1];
 		// Subtract this percentage from the actual encoded size
 		let f in 0 .. 95;
 
-		// Compute a random solution, then work backwards to get the lists of voters, targets, and assignments
+		// Compute a random solution, then work backwards to get the lists of voters, targets, and
+		// assignments
 		let witness = SolutionOrSnapshotSize { voters: v, targets: t };
 		let RawSolution { compact, .. } = solution_with_size::<T>(witness, a, d);
 		let RoundSnapshot { voters, targets } = MultiPhase::<T>::snapshot().unwrap();
@@ -313,7 +386,11 @@ frame_benchmarking::benchmarks! {
 	} verify {
 		let compact = CompactOf::<T>::try_from(index_assignments.as_slice()).unwrap();
 		let encoding = compact.encode();
-		log!(trace, "encoded size prediction = {}", encoded_size_of(index_assignments.as_slice()).unwrap());
+		log!(
+			trace,
+			"encoded size prediction = {}",
+			encoded_size_of(index_assignments.as_slice()).unwrap(),
+		);
 		log!(trace, "actual encoded size = {}", encoding.len());
 		assert!(encoding.len() <= desired_size);
 	}
@@ -326,9 +403,12 @@ frame_benchmarking::benchmarks! {
 		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
 		// number of assignments, i.e. compact.len(). This means the active nominators, thus must be
 		// a subset of `v` component.
-		let a in (T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		let a in
+			(T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
 		// number of desired targets. Must be a subset of `t` component.
-		let d in (T::BenchmarkingConfig::DESIRED_TARGETS[0]) .. T::BenchmarkingConfig::DESIRED_TARGETS[1];
+		let d in
+			(T::BenchmarkingConfig::DESIRED_TARGETS[0]) ..
+			T::BenchmarkingConfig::DESIRED_TARGETS[1];
 
 		let size = SolutionOrSnapshotSize { voters: v, targets: t };
 		let raw_solution = solution_with_size::<T>(size, a, d);
@@ -340,7 +420,8 @@ frame_benchmarking::benchmarks! {
 		let encoded_snapshot = <MultiPhase<T>>::snapshot().unwrap().encode();
 	}: {
 		assert_ok!(<MultiPhase<T>>::feasibility_check(raw_solution, ElectionCompute::Unsigned));
-		let _decoded_snap = <RoundSnapshot<T::AccountId> as Decode>::decode(&mut &*encoded_snapshot).unwrap();
+		let _decoded_snap = <RoundSnapshot<T::AccountId> as Decode>::decode(&mut &*encoded_snapshot)
+			.unwrap();
 	}
 }
 

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

@@ -47,13 +47,13 @@ pub fn generate_voter_cache<T: Config>(
 	cache
 }
 
-/// Create a function the returns the index a voter in the snapshot.
+/// Create a function that returns the index of a voter in the snapshot.
 ///
 /// The returning index type is the same as the one defined in `T::CompactSolution::Voter`.
 ///
 /// ## Warning
 ///
-/// The snapshot must be the same is the one used to create `cache`.
+/// Note that this will represent the snapshot data from which the `cache` is generated.
 pub fn voter_index_fn<T: Config>(
 	cache: &BTreeMap<T::AccountId, usize>,
 ) -> impl Fn(&T::AccountId) -> Option<CompactVoterIndexOf<T>> + '_ {
@@ -78,7 +78,7 @@ pub fn voter_index_fn_owned<T: Config>(
 ///
 /// ## Warning
 ///
-/// The snapshot must be the same is the one used to create `cache`.
+/// Note that this will represent the snapshot data from which the `cache` is generated.
 pub fn voter_index_fn_usize<T: Config>(
 	cache: &BTreeMap<T::AccountId, usize>,
 ) -> impl Fn(&T::AccountId) -> Option<usize> + '_ {
@@ -103,7 +103,7 @@ pub fn voter_index_fn_linear<T: Config>(
 	}
 }
 
-/// Create a function the returns the index to a target in the snapshot.
+/// Create a function that returns the index of a target in the snapshot.
 ///
 /// The returned index type is the same as the one defined in `T::CompactSolution::Target`.
 ///