Allow root origin to force transition phases

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

@@ -382,6 +382,20 @@ frame_benchmarking::benchmarks! {
 		assert!(<MultiPhase<T>>::queued_solution().is_some());
 	}
 
+	force_rotate_round {
+
+	}: _(RawOrigin::Root, Phase::Off)
+	verify {
+		assert_eq!(<MultiPhase<T>>::round(), 2);
+	}
+
+	force_rotate_round_from_signed {
+		<CurrentPhase<T>>::put(Phase::Signed);
+	}: force_rotate_round(RawOrigin::Root, Phase::Signed)
+	verify {
+		assert_eq!(<MultiPhase<T>>::round(), 2);
+	}
+
 	// This is checking a valid solution. The worse case is indeed a valid solution.
 	feasibility_check {
 		// number of votes in snapshot.

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

@@ -738,6 +738,28 @@ pub mod pallet {
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(now: T::BlockNumber) -> Weight {
+			if Self::force_phase().is_some() {
+				match Self::force_phase() {
+					Some(Phase::Signed) => {
+						// If the current phase is not `Phase::Off` proceed to the next round.
+						if !Self::current_phase().is_off() {
+							Self::do_force_rotate_round();
+						}
+
+						match Self::create_snapshot() {
+							Ok(_) => Self::phase_transition(Phase::Signed),
+							Err(why) => {
+								log!(warn, "failed to open signed phase due to {:?}", why);
+								return T::WeightInfo::on_initialize_nothing()
+							},
+						}
+						<ForcePhase<T>>::kill();
+						return T::WeightInfo::on_initialize_open_signed()
+					},
+					_ => {},
+				}
+			}
+
 			let next_election = T::DataProvider::next_election_prediction(now).max(now);
 
 			let signed_deadline = T::SignedPhase::get() + T::UnsignedPhase::get();
@@ -880,7 +902,7 @@ pub mod pallet {
 	impl<T: Config> Pallet<T> {
 		/// Submit a solution for the unsigned phase.
 		///
-		/// The dispatch origin fo this call must be __none__.
+		/// The dispatch origin for this call must be __none__.
 		///
 		/// This submission is checked on the fly. Moreover, this unsigned solution is only
 		/// validated when submitted to the pool from the **local** node. Effectively, this means
@@ -994,7 +1016,7 @@ pub mod pallet {
 
 		/// Submit a solution for the signed phase.
 		///
-		/// The dispatch origin fo this call must be __signed__.
+		/// The dispatch origin for this call must be __signed__.
 		///
 		/// The solution is potentially queued, based on the claimed score and processed at the end
 		/// of the signed phase.
@@ -1112,6 +1134,57 @@ pub mod pallet {
 			<QueuedSolution<T>>::put(solution);
 			Ok(())
 		}
+
+		/// Rotates the round which results in setting the current phase to
+		/// `Phase::Off` and removes all the current solutions.
+		///
+		/// The dispatch origin for this call must be `ForceOrigin`.
+		#[pallet::call_index(5)]
+		#[pallet::weight(({
+			if current_phase.is_signed() {
+				T::WeightInfo::force_rotate_round_from_signed()
+			}else {
+				T::WeightInfo::force_rotate_round()
+			}
+		}, DispatchClass::Operational))]
+		pub fn force_rotate_round(
+			origin: OriginFor<T>,
+			current_phase: Phase<T::BlockNumber>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			ensure!(current_phase == Self::current_phase(), <Error<T>>::CallNotAllowed);
+
+			Self::do_force_rotate_round();
+
+			Ok(())
+		}
+
+		/// Initializes an open signed phase. If the current phase is not
+		/// `Phase::Off` proceeds to the next round.
+		///
+		/// The dispatch origin for this call must be root.
+		#[pallet::call_index(6)]
+		#[pallet::weight((T::DbWeight::get().writes(1), DispatchClass::Operational))]
+		pub fn force_start_signed_phase(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+
+			<ForcePhase<T>>::put(Phase::Signed);
+			Ok(())
+		}
+
+		/// Sets the current phase to `Phase::Emergency` and removes the current
+		/// queued solution.
+		///
+		/// The dispatch origin for this call must be `ForceOrigin`.
+		#[pallet::call_index(8)]
+		#[pallet::weight((T::DbWeight::get().writes(2), DispatchClass::Operational))]
+		pub fn force_start_emergency_phase(origin: OriginFor<T>) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+
+			<QueuedSolution<T>>::kill();
+			<CurrentPhase<T>>::put(Phase::Emergency);
+			Ok(())
+		}
 	}
 
 	#[pallet::event]
@@ -1174,6 +1247,8 @@ pub mod pallet {
 		BoundNotMet,
 		/// Submitted solution has too many winners
 		TooManyWinners,
+		/// Failed to create a snapshot.
+		SnapshotCreationFailed,
 	}
 
 	#[pallet::validate_unsigned]
@@ -1317,6 +1392,11 @@ pub mod pallet {
 	#[pallet::getter(fn minimum_untrusted_score)]
 	pub type MinimumUntrustedScore<T: Config> = StorageValue<_, ElectionScore>;
 
+	/// Stores the phase we want to force during `on_initialize`.
+	#[pallet::storage]
+	#[pallet::getter(fn force_phase)]
+	pub type ForcePhase<T: Config> = StorageValue<_, Phase<T::BlockNumber>, OptionQuery>;
+
 	/// The current storage version.
 	///
 	/// v1: https://github.com/paritytech/substrate/pull/12237/
@@ -1356,6 +1436,16 @@ impl<T: Config> Pallet<T> {
 		}
 	}
 
+	/// Remove the current solutions and proceed to the following round.
+	fn do_force_rotate_round() {
+		if Self::current_phase().is_signed() {
+			Self::finalize_signed_phase();
+		}
+
+		<QueuedSolution<T>>::kill();
+		Self::rotate_round();
+	}
+
 	/// Phase transition helper.
 	pub(crate) fn phase_transition(to: Phase<T::BlockNumber>) {
 		log!(info, "Starting phase {:?}, round {}.", to, Self::round());
@@ -1894,7 +1984,7 @@ mod tests {
 			assert_eq!(MultiPhase::current_phase(), Phase::Off);
 			assert_eq!(MultiPhase::round(), 1);
 
-			roll_to(4);
+			roll_to(14);
 			assert_eq!(MultiPhase::current_phase(), Phase::Off);
 			assert!(MultiPhase::snapshot().is_none());
 			assert_eq!(MultiPhase::round(), 1);
@@ -1989,6 +2079,111 @@ mod tests {
 		})
 	}
 
+	#[test]
+	fn force_rotate_round_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to(1);
+			assert_eq!(System::block_number(), 1);
+
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+			assert_eq!(MultiPhase::round(), 1);
+
+			assert_noop!(
+				MultiPhase::force_rotate_round(crate::mock::RuntimeOrigin::none(), Phase::Off),
+				DispatchError::BadOrigin
+			);
+			assert_noop!(
+				MultiPhase::force_rotate_round(crate::mock::RuntimeOrigin::signed(1), Phase::Off),
+				DispatchError::BadOrigin
+			);
+
+			// The provided current phase is incorrect.
+			assert_noop!(
+				MultiPhase::force_rotate_round(crate::mock::RuntimeOrigin::root(), Phase::Signed),
+				Error::<Runtime>::CallNotAllowed
+			);
+
+			assert_ok!(MultiPhase::force_rotate_round(
+				crate::mock::RuntimeOrigin::root(),
+				Phase::Off
+			));
+			assert_eq!(MultiPhase::round(), 2);
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![Event::PhaseTransitioned { from: Phase::Off, to: Phase::Off, round: 2 },]
+			);
+		})
+	}
+
+	#[test]
+	fn force_start_signed_phase_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to(1);
+			assert_eq!(System::block_number(), 1);
+
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+			assert_eq!(MultiPhase::round(), 1);
+
+			assert_noop!(
+				MultiPhase::force_start_signed_phase(crate::mock::RuntimeOrigin::none(),),
+				DispatchError::BadOrigin
+			);
+			assert_noop!(
+				MultiPhase::force_start_signed_phase(crate::mock::RuntimeOrigin::signed(1),),
+				DispatchError::BadOrigin
+			);
+
+			assert_ok!(MultiPhase::force_start_signed_phase(crate::mock::RuntimeOrigin::root(),));
+			assert_eq!(MultiPhase::force_phase(), Some(Phase::Signed));
+
+			roll_to(2);
+			assert!(MultiPhase::current_phase().is_signed());
+			assert!(MultiPhase::snapshot().is_some());
+			assert!(MultiPhase::force_phase().is_none());
+			// Didn't proceed to following round since the previos phase was `Phase::Off`.
+			assert_eq!(MultiPhase::round(), 1);
+
+			assert_ok!(MultiPhase::force_start_signed_phase(crate::mock::RuntimeOrigin::root()));
+			assert_eq!(MultiPhase::force_phase(), Some(Phase::Signed));
+
+			roll_to(3);
+			assert!(MultiPhase::current_phase().is_signed());
+			assert!(MultiPhase::snapshot().is_some());
+			// Proceeded to the following roung because the previous phase was signed.
+			assert_eq!(MultiPhase::round(), 2);
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned { from: Phase::Signed, to: Phase::Off, round: 2 },
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 2 },
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn force_start_emergency_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(System::block_number(), 0);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+			assert_eq!(MultiPhase::round(), 1);
+
+			assert_noop!(
+				MultiPhase::force_start_emergency_phase(crate::mock::RuntimeOrigin::none()),
+				DispatchError::BadOrigin
+			);
+			assert_noop!(
+				MultiPhase::force_start_emergency_phase(crate::mock::RuntimeOrigin::signed(1)),
+				DispatchError::BadOrigin
+			);
+
+			assert_ok!(MultiPhase::force_start_emergency_phase(crate::mock::RuntimeOrigin::root()));
+			assert!(MultiPhase::current_phase().is_emergency());
+		})
+	}
+
 	#[test]
 	fn signed_phase_void() {
 		ExtBuilder::default().phases(0, 10).build_and_execute(|| {