From c0df5cee0726c55d707ad8cc9cc77e2ea4ee994a Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 13:58:36 +0200
Subject: [PATCH 1/8] remove old migration code

---
 frame/democracy/src/lib.rs           | 25 --------------
 frame/offences/src/lib.rs            |  8 -----
 frame/staking/src/lib.rs             | 49 ----------------------------
 frame/transaction-payment/src/lib.rs | 14 --------
 4 files changed, 96 deletions(-)

diff --git a/frame/democracy/src/lib.rs b/frame/democracy/src/lib.rs
index b60d658cde59d..ddc3b36f4c877 100644
--- a/frame/democracy/src/lib.rs
+++ b/frame/democracy/src/lib.rs
@@ -525,12 +525,6 @@ decl_module! {
 
 		fn deposit_event() = default;
 
-		fn on_runtime_upgrade() -> Weight {
-			Self::migrate();
-
-			0
-		}
-
 		/// Propose a sensitive action to be taken.
 		///
 		/// The dispatch origin of this call must be _Signed_ and the sender must
@@ -1268,25 +1262,6 @@ decl_module! {
 }
 
 impl<T: Trait> Module<T> {
-	fn migrate() {
-		use frame_support::{Twox64Concat, migration::{StorageKeyIterator, remove_storage_prefix}};
-		remove_storage_prefix(b"Democracy", b"VotesOf", &[]);
-		remove_storage_prefix(b"Democracy", b"VotersFor", &[]);
-		remove_storage_prefix(b"Democracy", b"Delegations", &[]);
-		for (who, (end, proposal_hash, threshold, delay))
-			in StorageKeyIterator::<
-				ReferendumIndex,
-				(T::BlockNumber, T::Hash, VoteThreshold, T::BlockNumber),
-				Twox64Concat,
-			>::new(b"Democracy", b"ReferendumInfoOf").drain()
-		{
-			let status = ReferendumStatus {
-				end, proposal_hash, threshold, delay, tally: Tally::default()
-			};
-			ReferendumInfoOf::<T>::insert(who, ReferendumInfo::Ongoing(status))
-		}
-	}
-
 	// exposed immutables.
 
 	/// Get the amount locked in support of `proposal`; `None` if proposal isn't a valid proposal
diff --git a/frame/offences/src/lib.rs b/frame/offences/src/lib.rs
index 1ad188a7a8364..b877d1e2b20dd 100644
--- a/frame/offences/src/lib.rs
+++ b/frame/offences/src/lib.rs
@@ -99,14 +99,6 @@ decl_module! {
 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 		fn deposit_event() = default;
 
-		fn on_runtime_upgrade() -> Weight {
-			Reports::<T>::remove_all();
-			ConcurrentReportsIndex::<T>::remove_all();
-			ReportsByKindIndex::remove_all();
-
-			0
-		}
-
 		fn on_initialize(now: T::BlockNumber) -> Weight {
 			// only decode storage if we can actually submit anything again.
 			if T::OnOffenceHandler::can_report() {
diff --git a/frame/staking/src/lib.rs b/frame/staking/src/lib.rs
index 67240d8d34b2a..ca3fb51ecb749 100644
--- a/frame/staking/src/lib.rs
+++ b/frame/staking/src/lib.rs
@@ -1246,18 +1246,6 @@ decl_module! {
 			}
 		}
 
-		fn on_runtime_upgrade() -> Weight {
-			// For Kusama the type hasn't actually changed as Moment was u64 and was the number of
-			// millisecond since unix epoch.
-			StorageVersion::mutate(|v| {
-				if matches!(v, Releases::V2_0_0) {
-					Self::migrate_last_reward_to_claimed_rewards();
-				}
-				*v = Releases::V3_0_0;
-			});
-			0
-		}
-
 		/// Take the origin account as a stash and lock up `value` of its balance. `controller` will
 		/// be the account that controls it.
 		///
@@ -1935,43 +1923,6 @@ decl_module! {
 }
 
 impl<T: Trait> Module<T> {
-	/// Migrate `last_reward` to `claimed_rewards`
-	pub fn migrate_last_reward_to_claimed_rewards() {
-		use frame_support::migration::{StorageIterator, put_storage_value};
-		// Migrate from `last_reward` to `claimed_rewards`.
-		// We will construct a vector from `current_era - history_depth` to `last_reward`
-		// for each validator and nominator.
-		//
-		// Old Staking Ledger
-		#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
-		struct OldStakingLedger<AccountId, Balance: HasCompact> {
-			pub stash: AccountId,
-			#[codec(compact)]
-			pub total: Balance,
-			#[codec(compact)]
-			pub active: Balance,
-			pub unlocking: Vec<UnlockChunk<Balance>>,
-			pub last_reward: Option<EraIndex>,
-		}
-		// Current era and history depth
-		let current_era = Self::current_era().unwrap_or(0);
-		let history_depth = Self::history_depth();
-		let last_payout_era = current_era.saturating_sub(history_depth);
-		// Convert all ledgers to the new format.
-		for (hash, old_ledger) in StorageIterator::<OldStakingLedger<T::AccountId, BalanceOf<T>>>::new(b"Staking", b"Ledger").drain() {
-			let last_reward = old_ledger.last_reward.unwrap_or(0);
-			let new_ledger = StakingLedger {
-				stash: old_ledger.stash,
-				total: old_ledger.total,
-				active: old_ledger.active,
-				unlocking: old_ledger.unlocking,
-				claimed_rewards: (last_payout_era..=last_reward).collect(),
-			};
-			put_storage_value(b"Staking", b"Ledger", &hash, new_ledger);
-		}
-		MigrateEra::put(current_era);
-	}
-
 	/// The total balance that can be slashed from a stash account as of right now.
 	pub fn slashable_balance_of(stash: &T::AccountId) -> BalanceOf<T> {
 		Self::bonded(stash).and_then(Self::ledger).map(|l| l.active).unwrap_or_default()
diff --git a/frame/transaction-payment/src/lib.rs b/frame/transaction-payment/src/lib.rs
index c5992ab1298b8..cb693a0fd0854 100644
--- a/frame/transaction-payment/src/lib.rs
+++ b/frame/transaction-payment/src/lib.rs
@@ -93,20 +93,6 @@ decl_module! {
 				*fm = T::FeeMultiplierUpdate::convert(*fm)
 			});
 		}
-
-		fn on_runtime_upgrade() -> Weight {
-			// TODO: Remove this code after on-chain upgrade from u32 to u64 weights
-			use sp_runtime::Fixed64;
-			use frame_support::migration::take_storage_value;
-			if let Some(old_next_fee_multiplier) = take_storage_value::<Fixed64>(b"TransactionPayment", b"NextFeeMultiplier", &[]) {
-				let raw_multiplier = old_next_fee_multiplier.into_inner() as i128;
-				// Fixed64 used 10^9 precision, where Fixed128 uses 10^18, so we need to add 9 zeros.
-				let new_raw_multiplier: i128 = raw_multiplier.saturating_mul(1_000_000_000);
-				let new_next_fee_multiplier: Fixed128 = Fixed128::from_parts(new_raw_multiplier);
-				NextFeeMultiplier::put(new_next_fee_multiplier);
-			}
-			0
-		}
 	}
 }
 

From 95262b1ac43c9b5bcf49d2ae80800feabcbbbaa0 Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 14:11:59 +0200
Subject: [PATCH 2/8] Remove old staking

---
 frame/staking/src/lib.rs   | 219 +-----------------
 frame/staking/src/mock.rs  |  34 +--
 frame/staking/src/tests.rs | 459 -------------------------------------
 3 files changed, 10 insertions(+), 702 deletions(-)

diff --git a/frame/staking/src/lib.rs b/frame/staking/src/lib.rs
index ca3fb51ecb749..444caac732ae8 100644
--- a/frame/staking/src/lib.rs
+++ b/frame/staking/src/lib.rs
@@ -1037,9 +1037,6 @@ decl_storage! {
 		///
 		/// This is set to v3.0.0 for new networks.
 		StorageVersion build(|_: &GenesisConfig<T>| Releases::V3_0_0): Releases;
-
-		/// The era where we migrated from Lazy Payouts to Simple Payouts
-		MigrateEra: Option<EraIndex>;
 	}
 	add_extra_genesis {
 		config(stakers):
@@ -1246,6 +1243,15 @@ decl_module! {
 			}
 		}
 
+		fn on_runtime_upgrade() -> Weight {
+			use frame_support::storage::migration::take_storage_value;
+			if let Some(_) = take_storage_value::<EraIndex>(b"Staking", b"MigrateEra", b"") {
+				T::DbWeight::get().reads_writes(1, 1)
+			} else {
+				T::DbWeight::get().reads(1)
+			}
+		}
+
 		/// Take the origin account as a stash and lock up `value` of its balance. `controller` will
 		/// be the account that controls it.
 		///
@@ -1664,69 +1670,6 @@ decl_module! {
 			<Self as Store>::UnappliedSlashes::insert(&era, &unapplied);
 		}
 
-		/// **This extrinsic will be removed after `MigrationEra + HistoryDepth` has passed, giving
-		/// opportunity for users to claim all rewards before moving to Simple Payouts. After this
-		/// time, you should use `payout_stakers` instead.**
-		///
-		/// Make one nominator's payout for one era.
-		///
-		/// - `who` is the controller account of the nominator to pay out.
-		/// - `era` may not be lower than one following the most recently paid era. If it is higher,
-		///   then it indicates an instruction to skip the payout of all previous eras.
-		/// - `validators` is the list of all validators that `who` had exposure to during `era`,
-		///   alongside the index of `who` in the clipped exposure of the validator.
-		///   I.e. each element is a tuple of
-		///   `(validator, index of `who` in clipped exposure of validator)`.
-		///   If it is incomplete, then less than the full reward will be paid out.
-		///   It must not exceed `MAX_NOMINATIONS`.
-		///
-		/// WARNING: once an era is payed for a validator such validator can't claim the payout of
-		/// previous era.
-		///
-		/// WARNING: Incorrect arguments here can result in loss of payout. Be very careful.
-		///
-		/// # <weight>
-		/// - Number of storage read of `O(validators)`; `validators` is the argument of the call,
-		///   and is bounded by `MAX_NOMINATIONS`.
-		/// - Each storage read is `O(N)` size and decode complexity; `N` is the  maximum
-		///   nominations that can be given to a single validator.
-		/// - Computation complexity: `O(MAX_NOMINATIONS * logN)`; `MAX_NOMINATIONS` is the
-		///   maximum number of validators that may be nominated by a single nominator, it is
-		///   bounded only economically (all nominators are required to place a minimum stake).
-		/// # </weight>
-		#[weight = 500_000_000]
-		fn payout_nominator(origin, era: EraIndex, validators: Vec<(T::AccountId, u32)>)
-			-> DispatchResult
-		{
-			let ctrl = ensure_signed(origin)?;
-			Self::do_payout_nominator(ctrl, era, validators)
-		}
-
-		/// **This extrinsic will be removed after `MigrationEra + HistoryDepth` has passed, giving
-		/// opportunity for users to claim all rewards before moving to Simple Payouts. After this
-		/// time, you should use `payout_stakers` instead.**
-		///
-		/// Make one validator's payout for one era.
-		///
-		/// - `who` is the controller account of the validator to pay out.
-		/// - `era` may not be lower than one following the most recently paid era. If it is higher,
-		///   then it indicates an instruction to skip the payout of all previous eras.
-		///
-		/// WARNING: once an era is payed for a validator such validator can't claim the payout of
-		/// previous era.
-		///
-		/// WARNING: Incorrect arguments here can result in loss of payout. Be very careful.
-		///
-		/// # <weight>
-		/// - Time complexity: O(1).
-		/// - Contains a limited number of reads and writes.
-		/// # </weight>
-		#[weight = 500_000_000]
-		fn payout_validator(origin, era: EraIndex) -> DispatchResult {
-			let ctrl = ensure_signed(origin)?;
-			Self::do_payout_validator(ctrl, era)
-		}
-
 		/// Pay out all the stakers behind a single validator for a single era.
 		///
 		/// - `validator_stash` is the stash account of the validator. Their nominators, up to
@@ -1974,143 +1917,6 @@ impl<T: Trait> Module<T> {
 		<SnapshotNominators<T>>::kill();
 	}
 
-	fn do_payout_nominator(ctrl: T::AccountId, era: EraIndex, validators: Vec<(T::AccountId, u32)>)
-		-> DispatchResult
-	{
-		// validators len must not exceed `MAX_NOMINATIONS` to avoid querying more validator
-		// exposure than necessary.
-		if validators.len() > MAX_NOMINATIONS {
-			return Err(Error::<T>::InvalidNumberOfNominations.into());
-		}
-		// If migrate_era is not populated, then you should use `payout_stakers`
-		let migrate_era = MigrateEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
-		// This payout mechanism will only work for eras before the migration.
-		// Subsequent payouts should use `payout_stakers`.
-		ensure!(era < migrate_era, Error::<T>::InvalidEraToReward);
-		let current_era = CurrentEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
-		ensure!(era <= current_era, Error::<T>::InvalidEraToReward);
-		let history_depth = Self::history_depth();
-		ensure!(era >= current_era.saturating_sub(history_depth), Error::<T>::InvalidEraToReward);
-
-		// Note: if era has no reward to be claimed, era may be future. better not to update
-		// `nominator_ledger.last_reward` in this case.
-		let era_payout = <ErasValidatorReward<T>>::get(&era)
-			.ok_or_else(|| Error::<T>::InvalidEraToReward)?;
-
-		let mut nominator_ledger = <Ledger<T>>::get(&ctrl).ok_or_else(|| Error::<T>::NotController)?;
-
-		ensure!(
-			Self::era_election_status().is_closed() || Self::payee(&nominator_ledger.stash) != RewardDestination::Staked,
-			Error::<T>::CallNotAllowed,
-		);
-
-		nominator_ledger.claimed_rewards.retain(|&x| x >= current_era.saturating_sub(history_depth));
-		match nominator_ledger.claimed_rewards.binary_search(&era) {
-			Ok(_) => Err(Error::<T>::AlreadyClaimed)?,
-			Err(pos) => nominator_ledger.claimed_rewards.insert(pos, era),
-		}
-
-		<Ledger<T>>::insert(&ctrl, &nominator_ledger);
-
-		let mut reward = Perbill::zero();
-		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
-
-		for (validator, nominator_index) in validators.into_iter() {
-			let commission = Self::eras_validator_prefs(&era, &validator).commission;
-			let validator_exposure = <ErasStakersClipped<T>>::get(&era, &validator);
-
-			if let Some(nominator_exposure) = validator_exposure.others
-				.get(nominator_index as usize)
-			{
-				if nominator_exposure.who != nominator_ledger.stash {
-					continue;
-				}
-
-				let nominator_exposure_part = Perbill::from_rational_approximation(
-					nominator_exposure.value,
-					validator_exposure.total,
-				);
-				let validator_point = era_reward_points.individual.get(&validator)
-					.map(|points| *points)
-					.unwrap_or_else(|| Zero::zero());
-				let validator_point_part = Perbill::from_rational_approximation(
-					validator_point,
-					era_reward_points.total,
-				);
-				reward = reward.saturating_add(
-					validator_point_part
-						.saturating_mul(Perbill::one().saturating_sub(commission))
-						.saturating_mul(nominator_exposure_part)
-				);
-			}
-		}
-
-		if let Some(imbalance) = Self::make_payout(&nominator_ledger.stash, reward * era_payout) {
-			Self::deposit_event(RawEvent::Reward(ctrl, imbalance.peek()));
-		}
-
-		Ok(())
-	}
-
-	fn do_payout_validator(ctrl: T::AccountId, era: EraIndex) -> DispatchResult {
-		// If migrate_era is not populated, then you should use `payout_stakers`
-		let migrate_era = MigrateEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
-		// This payout mechanism will only work for eras before the migration.
-		// Subsequent payouts should use `payout_stakers`.
-		ensure!(era < migrate_era, Error::<T>::InvalidEraToReward);
-		let current_era = CurrentEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
-		ensure!(era <= current_era, Error::<T>::InvalidEraToReward);
-		let history_depth = Self::history_depth();
-		ensure!(era >= current_era.saturating_sub(history_depth), Error::<T>::InvalidEraToReward);
-
-		// Note: if era has no reward to be claimed, era may be future. better not to update
-		// `ledger.last_reward` in this case.
-		let era_payout = <ErasValidatorReward<T>>::get(&era)
-			.ok_or_else(|| Error::<T>::InvalidEraToReward)?;
-
-		let mut ledger = <Ledger<T>>::get(&ctrl).ok_or_else(|| Error::<T>::NotController)?;
-
-		ensure!(
-			Self::era_election_status().is_closed() || Self::payee(&ledger.stash) != RewardDestination::Staked,
-			Error::<T>::CallNotAllowed,
-		);
-
-		ledger.claimed_rewards.retain(|&x| x >= current_era.saturating_sub(history_depth));
-		match ledger.claimed_rewards.binary_search(&era) {
-			Ok(_) => Err(Error::<T>::AlreadyClaimed)?,
-			Err(pos) => ledger.claimed_rewards.insert(pos, era),
-		}
-
-		<Ledger<T>>::insert(&ctrl, &ledger);
-
-		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
-		let commission = Self::eras_validator_prefs(&era, &ledger.stash).commission;
-		let exposure = <ErasStakersClipped<T>>::get(&era, &ledger.stash);
-
-		let exposure_part = Perbill::from_rational_approximation(
-			exposure.own,
-			exposure.total,
-		);
-		let validator_point = era_reward_points.individual.get(&ledger.stash)
-			.map(|points| *points)
-			.unwrap_or_else(|| Zero::zero());
-		let validator_point_part = Perbill::from_rational_approximation(
-			validator_point,
-			era_reward_points.total,
-		);
-		let reward = validator_point_part.saturating_mul(
-			commission.saturating_add(
-				Perbill::one().saturating_sub(commission).saturating_mul(exposure_part)
-			)
-		);
-
-		if let Some(imbalance) = Self::make_payout(&ledger.stash, reward * era_payout) {
-			Self::deposit_event(RawEvent::Reward(ctrl, imbalance.peek()));
-		}
-
-		Ok(())
-	}
-
 	fn do_payout_stakers(
 		validator_stash: T::AccountId,
 		era: EraIndex,
@@ -2121,13 +1927,6 @@ impl<T: Trait> Module<T> {
 		let history_depth = Self::history_depth();
 		ensure!(era >= current_era.saturating_sub(history_depth), Error::<T>::InvalidEraToReward);
 
-		// If there was no migration, then this function is always valid.
-		if let Some(migrate_era) = MigrateEra::get() {
-			// This payout mechanism will only work for eras on and after the migration.
-			// Payouts before then should use `payout_nominator`/`payout_validator`.
-			ensure!(migrate_era <= era, Error::<T>::InvalidEraToReward);
-		}
-
 		// Note: if era has no reward to be claimed, era may be future. better not to update
 		// `ledger.claimed_rewards` in this case.
 		let era_payout = <ErasValidatorReward<T>>::get(&era)
diff --git a/frame/staking/src/mock.rs b/frame/staking/src/mock.rs
index a34f3425564cd..886da0534784a 100644
--- a/frame/staking/src/mock.rs
+++ b/frame/staking/src/mock.rs
@@ -16,7 +16,7 @@
 
 //! Test utilities
 
-use std::{collections::{HashSet, HashMap}, cell::RefCell};
+use std::{collections::HashSet, cell::RefCell};
 use sp_runtime::Perbill;
 use sp_runtime::curve::PiecewiseLinear;
 use sp_runtime::traits::{IdentityLookup, Convert, SaturatedConversion, Zero};
@@ -948,38 +948,6 @@ pub(crate) fn prepare_submission_with(
 	(compact, winners, score)
 }
 
-/// Make all validator and nominator request their payment
-pub(crate) fn make_all_reward_payment_before_migration(era: EraIndex) {
-	let validators_with_reward = ErasRewardPoints::<Test>::get(era).individual.keys()
-		.cloned()
-		.collect::<Vec<_>>();
-
-	// reward nominators
-	let mut nominator_controllers = HashMap::new();
-	for validator in Staking::eras_reward_points(era).individual.keys() {
-		let validator_exposure = Staking::eras_stakers_clipped(era, validator);
-		for (nom_index, nom) in validator_exposure.others.iter().enumerate() {
-			if let Some(nom_ctrl) = Staking::bonded(nom.who) {
-				nominator_controllers.entry(nom_ctrl)
-					.or_insert(vec![])
-					.push((validator.clone(), nom_index as u32));
-			}
-		}
-	}
-	for (nominator_controller, validators_with_nom_index) in nominator_controllers {
-		assert_ok!(Staking::payout_nominator(
-			Origin::signed(nominator_controller),
-			era,
-			validators_with_nom_index,
-		));
-	}
-
-	// reward validators
-	for validator_controller in validators_with_reward.iter().filter_map(Staking::bonded) {
-		assert_ok!(Staking::payout_validator(Origin::signed(validator_controller), era));
-	}
-}
-
 /// Make all validator and nominator request their payment
 pub(crate) fn make_all_reward_payment(era: EraIndex) {
 	let validators_with_reward = ErasRewardPoints::<Test>::get(era).individual.keys()
diff --git a/frame/staking/src/tests.rs b/frame/staking/src/tests.rs
index 84c937d324cab..035eed23d4e5e 100644
--- a/frame/staking/src/tests.rs
+++ b/frame/staking/src/tests.rs
@@ -4264,462 +4264,3 @@ fn bond_during_era_correctly_populates_claimed_rewards() {
 		);
 	});
 }
-
-/* These migration tests below can be removed once migration code is removed */
-
-#[test]
-fn assert_migration_is_noop() {
-	let kusama_active_era = "4a0200000190e2721171010000";
-	let era = ActiveEraInfo::decode(&mut &hex::decode(kusama_active_era).unwrap()[..]).unwrap();
-	assert_eq!(era.index, 586);
-	assert_eq!(era.start, Some(1585135674000));
-}
-
-#[test]
-fn test_last_reward_migration() {
-	use sp_storage::Storage;
-
-	let mut s = Storage::default();
-
-	#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
-	struct OldStakingLedger<AccountId, Balance: HasCompact> {
-		pub stash: AccountId,
-		#[codec(compact)]
-		pub total: Balance,
-		#[codec(compact)]
-		pub active: Balance,
-		pub unlocking: Vec<UnlockChunk<Balance>>,
-		pub last_reward: Option<EraIndex>,
-	}
-
-	let old_staking10 = OldStakingLedger::<u64, u64> {
-		stash: 0,
-		total: 10,
-		active: 10,
-		unlocking: vec![UnlockChunk{ value: 1234, era: 56}],
-		last_reward: Some(8),
-	};
-
-	let old_staking11 = OldStakingLedger::<u64, u64> {
-		stash: 1,
-		total: 0,
-		active: 0,
-		unlocking: vec![],
-		last_reward: None,
-	};
-
-	let old_staking12 = OldStakingLedger::<u64, u64> {
-		stash: 2,
-		total: 100,
-		active: 100,
-		unlocking: vec![UnlockChunk{ value: 9876, era: 54}, UnlockChunk{ value: 98, era: 76}],
-		last_reward: Some(23),
-	};
-
-	let old_staking13 = OldStakingLedger::<u64, u64> {
-		stash: 3,
-		total: 100,
-		active: 100,
-		unlocking: vec![],
-		last_reward: Some(23),
-	};
-
-	let data = vec![
-		(
-			Ledger::<Test>::hashed_key_for(10),
-			old_staking10.encode().to_vec()
-		),
-		(
-			Ledger::<Test>::hashed_key_for(11),
-			old_staking11.encode().to_vec()
-		),
-		(
-			Ledger::<Test>::hashed_key_for(12),
-			old_staking12.encode().to_vec()
-		),
-		(
-			Ledger::<Test>::hashed_key_for(13),
-			old_staking13.encode().to_vec()
-		),
-	];
-
-	s.top = data.into_iter().collect();
-	sp_io::TestExternalities::new(s).execute_with(|| {
-		HistoryDepth::put(84);
-		CurrentEra::put(99);
-		let nominations = Nominations::<AccountId> {
-			targets: vec![],
-			submitted_in: 0,
-			suppressed: false
-		};
-		Nominators::<Test>::insert(3, nominations);
-		Bonded::<Test>::insert(3, 13);
-		Staking::migrate_last_reward_to_claimed_rewards();
-		// Test staker out of range
-		assert_eq!(
-			Ledger::<Test>::get(10),
-			Some(StakingLedger {
-				stash: 0,
-				total: 10,
-				active: 10,
-				unlocking: vec![UnlockChunk{ value: 1234, era: 56}],
-				claimed_rewards: vec![],
-			})
-		);
-		// Test staker none
-		assert_eq!(
-			Ledger::<Test>::get(11),
-			Some(StakingLedger {
-				stash: 1,
-				total: 0,
-				active: 0,
-				unlocking: vec![],
-				claimed_rewards: vec![],
-			})
-		);
-		// Test staker migration
-		assert_eq!(
-			Ledger::<Test>::get(12),
-			Some(StakingLedger {
-				stash: 2,
-				total: 100,
-				active: 100,
-				unlocking: vec![UnlockChunk{ value: 9876, era: 54}, UnlockChunk{ value: 98, era: 76}],
-				claimed_rewards: vec![15,16,17,18,19,20,21,22,23],
-			})
-		);
-		// Test nominator migration
-		assert_eq!(
-			Ledger::<Test>::get(13),
-			Some(StakingLedger {
-				stash: 3,
-				total: 100,
-				active: 100,
-				unlocking: vec![],
-				claimed_rewards: vec![15,16,17,18,19,20,21,22,23],
-			})
-		);
-	});
-}
-
-#[test]
-fn rewards_should_work_before_migration() {
-	// should check that before migration:
-	// * rewards get recorded per session
-	// * rewards get paid per Era
-	// * Check that nominators are also rewarded
-	ExtBuilder::default().nominate(true).build_and_execute(|| {
-		MigrateEra::put(10);
-		let init_balance_10 = Balances::total_balance(&10);
-		let init_balance_11 = Balances::total_balance(&11);
-		let init_balance_20 = Balances::total_balance(&20);
-		let init_balance_21 = Balances::total_balance(&21);
-		let init_balance_100 = Balances::total_balance(&100);
-		let init_balance_101 = Balances::total_balance(&101);
-
-		// Check state
-		Payee::<Test>::insert(11, RewardDestination::Controller);
-		Payee::<Test>::insert(21, RewardDestination::Controller);
-		Payee::<Test>::insert(101, RewardDestination::Controller);
-
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		// This is the second validator of the current elected set.
-		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_0 > 10); // Test is meaningful if reward something
-
-		start_session(1);
-
-		assert_eq!(Balances::total_balance(&10), init_balance_10);
-		assert_eq!(Balances::total_balance(&11), init_balance_11);
-		assert_eq!(Balances::total_balance(&20), init_balance_20);
-		assert_eq!(Balances::total_balance(&21), init_balance_21);
-		assert_eq!(Balances::total_balance(&100), init_balance_100);
-		assert_eq!(Balances::total_balance(&101), init_balance_101);
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
-			total: 50*3,
-			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
-		});
-		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
-		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
-		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
-		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
-
-		start_session(2);
-		start_session(3);
-
-		assert_eq!(Staking::active_era().unwrap().index, 1);
-		mock::make_all_reward_payment_before_migration(0);
-
-		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * total_payout_0*2/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
-		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0*1/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
-		assert_eq_error_rate!(
-			Balances::total_balance(&100),
-			init_balance_100
-				+ part_for_100_from_10 * total_payout_0 * 2/3
-				+ part_for_100_from_20 * total_payout_0 * 1/3,
-			2
-		);
-		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
-
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		<Module<Test>>::reward_by_ids(vec![(11, 1)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_1 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_1 > 10); // Test is meaningful if reward something
-
-		mock::start_era(2);
-		mock::make_all_reward_payment_before_migration(1);
-
-		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * (total_payout_0 * 2/3 + total_payout_1), 2);
-		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
-		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0 * 1/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
-		assert_eq_error_rate!(
-			Balances::total_balance(&100),
-			init_balance_100
-				+ part_for_100_from_10 * (total_payout_0 * 2/3 + total_payout_1)
-				+ part_for_100_from_20 * total_payout_0 * 1/3,
-			2
-		);
-		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
-	});
-}
-
-#[test]
-fn migrate_era_should_work() {
-	// should check that before and after migration:
-	// * rewards get recorded per session
-	// * rewards get paid per Era
-	// * Check that nominators are also rewarded
-	ExtBuilder::default().nominate(true).build_and_execute(|| {
-		MigrateEra::put(1);
-		let init_balance_10 = Balances::total_balance(&10);
-		let init_balance_11 = Balances::total_balance(&11);
-		let init_balance_20 = Balances::total_balance(&20);
-		let init_balance_21 = Balances::total_balance(&21);
-		let init_balance_100 = Balances::total_balance(&100);
-		let init_balance_101 = Balances::total_balance(&101);
-
-		// Check state
-		Payee::<Test>::insert(11, RewardDestination::Controller);
-		Payee::<Test>::insert(21, RewardDestination::Controller);
-		Payee::<Test>::insert(101, RewardDestination::Controller);
-
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		// This is the second validator of the current elected set.
-		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_0 > 10); // Test is meaningful if reward something
-
-		start_session(1);
-
-		assert_eq!(Balances::total_balance(&10), init_balance_10);
-		assert_eq!(Balances::total_balance(&11), init_balance_11);
-		assert_eq!(Balances::total_balance(&20), init_balance_20);
-		assert_eq!(Balances::total_balance(&21), init_balance_21);
-		assert_eq!(Balances::total_balance(&100), init_balance_100);
-		assert_eq!(Balances::total_balance(&101), init_balance_101);
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
-			total: 50*3,
-			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
-		});
-		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
-		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
-		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
-		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
-
-		start_session(2);
-		start_session(3);
-
-		assert_eq!(Staking::active_era().unwrap().index, 1);
-		mock::make_all_reward_payment_before_migration(0);
-
-		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * total_payout_0*2/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
-		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0*1/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
-		assert_eq_error_rate!(
-			Balances::total_balance(&100),
-			init_balance_100
-				+ part_for_100_from_10 * total_payout_0 * 2/3
-				+ part_for_100_from_20 * total_payout_0 * 1/3,
-			2
-		);
-		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
-
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		<Module<Test>>::reward_by_ids(vec![(11, 1)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_1 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_1 > 10); // Test is meaningful if reward something
-
-		mock::start_era(2);
-		mock::make_all_reward_payment(1);
-
-		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * (total_payout_0 * 2/3 + total_payout_1), 2);
-		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
-		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0 * 1/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
-		assert_eq_error_rate!(
-			Balances::total_balance(&100),
-			init_balance_100
-				+ part_for_100_from_10 * (total_payout_0 * 2/3 + total_payout_1)
-				+ part_for_100_from_20 * total_payout_0 * 1/3,
-			2
-		);
-		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
-	});
-}
-
-#[test]
-#[should_panic]
-fn migrate_era_should_handle_error() {
-	ExtBuilder::default().nominate(true).build_and_execute(|| {
-		MigrateEra::put(1);
-		let init_balance_10 = Balances::total_balance(&10);
-		let init_balance_11 = Balances::total_balance(&11);
-		let init_balance_20 = Balances::total_balance(&20);
-		let init_balance_21 = Balances::total_balance(&21);
-		let init_balance_100 = Balances::total_balance(&100);
-		let init_balance_101 = Balances::total_balance(&101);
-
-		// Check state
-		Payee::<Test>::insert(11, RewardDestination::Controller);
-		Payee::<Test>::insert(21, RewardDestination::Controller);
-		Payee::<Test>::insert(101, RewardDestination::Controller);
-
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		// This is the second validator of the current elected set.
-		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_0 > 10); // Test is meaningful if reward something
-
-		start_session(1);
-
-		assert_eq!(Balances::total_balance(&10), init_balance_10);
-		assert_eq!(Balances::total_balance(&11), init_balance_11);
-		assert_eq!(Balances::total_balance(&20), init_balance_20);
-		assert_eq!(Balances::total_balance(&21), init_balance_21);
-		assert_eq!(Balances::total_balance(&100), init_balance_100);
-		assert_eq!(Balances::total_balance(&101), init_balance_101);
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
-			total: 50*3,
-			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
-		});
-
-		start_session(2);
-		start_session(3);
-
-		assert_eq!(Staking::active_era().unwrap().index, 1);
-		mock::make_all_reward_payment(0);
-	});
-}
-
-#[test]
-#[should_panic]
-fn migrate_era_should_handle_errors_2() {
-	// should check that before and after migration:
-	// * rewards get recorded per session
-	// * rewards get paid per Era
-	// * Check that nominators are also rewarded
-	ExtBuilder::default().nominate(true).build_and_execute(|| {
-		MigrateEra::put(1);
-		let init_balance_10 = Balances::total_balance(&10);
-		let init_balance_11 = Balances::total_balance(&11);
-		let init_balance_20 = Balances::total_balance(&20);
-		let init_balance_21 = Balances::total_balance(&21);
-		let init_balance_100 = Balances::total_balance(&100);
-		let init_balance_101 = Balances::total_balance(&101);
-
-		// Check state
-		Payee::<Test>::insert(11, RewardDestination::Controller);
-		Payee::<Test>::insert(21, RewardDestination::Controller);
-		Payee::<Test>::insert(101, RewardDestination::Controller);
-
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
-		// This is the second validator of the current elected set.
-		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_0 > 10); // Test is meaningful if reward something
-
-		start_session(1);
-
-		assert_eq!(Balances::total_balance(&10), init_balance_10);
-		assert_eq!(Balances::total_balance(&11), init_balance_11);
-		assert_eq!(Balances::total_balance(&20), init_balance_20);
-		assert_eq!(Balances::total_balance(&21), init_balance_21);
-		assert_eq!(Balances::total_balance(&100), init_balance_100);
-		assert_eq!(Balances::total_balance(&101), init_balance_101);
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
-			total: 50*3,
-			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
-		});
-		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
-		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
-		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
-		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
-
-		start_session(2);
-		start_session(3);
-
-		assert_eq!(Staking::active_era().unwrap().index, 1);
-		mock::make_all_reward_payment_before_migration(0);
-
-		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * total_payout_0*2/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
-		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0*1/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
-		assert_eq_error_rate!(
-			Balances::total_balance(&100),
-			init_balance_100
-				+ part_for_100_from_10 * total_payout_0 * 2/3
-				+ part_for_100_from_20 * total_payout_0 * 1/3,
-			2
-		);
-		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
-
-		assert_eq_uvec!(Session::validators(), vec![11, 21]);
-		<Module<Test>>::reward_by_ids(vec![(11, 1)]);
-
-		// Compute total payout now for whole duration as other parameter won't change
-		let total_payout_1 = current_total_payout_for_duration(3 * 1000);
-		assert!(total_payout_1 > 10); // Test is meaningful if reward something
-
-		mock::start_era(2);
-		mock::make_all_reward_payment_before_migration(1);
-
-		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * (total_payout_0 * 2/3 + total_payout_1), 2);
-		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
-		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0 * 1/3, 2);
-		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
-		assert_eq_error_rate!(
-			Balances::total_balance(&100),
-			init_balance_100
-				+ part_for_100_from_10 * (total_payout_0 * 2/3 + total_payout_1)
-				+ part_for_100_from_20 * total_payout_0 * 1/3,
-			2
-		);
-		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
-	});
-}

From b607fb5deaee71ac3ad86d663b999f84dd105052 Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 14:14:22 +0200
Subject: [PATCH 3/8] Remove indices migration

---
 frame/indices/src/lib.rs | 31 -------------------------------
 1 file changed, 31 deletions(-)

diff --git a/frame/indices/src/lib.rs b/frame/indices/src/lib.rs
index 4861197eda371..c144772138e53 100644
--- a/frame/indices/src/lib.rs
+++ b/frame/indices/src/lib.rs
@@ -28,7 +28,6 @@ use frame_support::{Parameter, decl_module, decl_error, decl_event, decl_storage
 use frame_support::weights::Weight;
 use frame_support::dispatch::DispatchResult;
 use frame_support::traits::{Currency, ReservableCurrency, Get, BalanceStatus::Reserved};
-use frame_support::storage::migration::take_storage_value;
 use frame_system::{ensure_signed, ensure_root};
 use self::address::Address as RawAddress;
 
@@ -99,12 +98,6 @@ decl_module! {
 	pub struct Module<T: Trait> for enum Call where origin: T::Origin, system = frame_system {
 		fn deposit_event() = default;
 
-		fn on_initialize() -> Weight {
-			Self::migrations();
-
-			0
-		}
-
 		/// Assign an previously unassigned index.
 		///
 		/// Payment: `Deposit` is reserved from the sender account.
@@ -241,30 +234,6 @@ impl<T: Trait> Module<T> {
 			address::Address::Index(i) => Self::lookup_index(i),
 		}
 	}
-
-	/// Do any migrations.
-	fn migrations() {
-		if let Some(set_count) = take_storage_value::<T::AccountIndex>(b"Indices", b"NextEnumSet", b"") {
-			// migrations need doing.
-			let set_size: T::AccountIndex = 64.into();
-
-			let mut set_index: T::AccountIndex = Zero::zero();
-			while set_index < set_count {
-				let maybe_accounts = take_storage_value::<Vec<T::AccountId>>(b"Indices", b"EnumSet", BlakeTwo256::hash_of(&set_index).as_ref());
-				if let Some(accounts) = maybe_accounts {
-					for (item_index, target) in accounts.into_iter().enumerate() {
-						if target != T::AccountId::default() && !T::Currency::total_balance(&target).is_zero() {
-							let index = set_index * set_size + T::AccountIndex::from(item_index as u32);
-							Accounts::<T>::insert(index, (target, BalanceOf::<T>::zero()));
-						}
-					}
-				} else {
-					break;
-				}
-				set_index += One::one();
-			}
-		}
-	}
 }
 
 impl<T: Trait> StaticLookup for Module<T> {

From 227b97595f3f07e37557e8744490c86e38b27bd5 Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 14:34:19 +0200
Subject: [PATCH 4/8] Remove upgrade test in transaction-payment

---
 frame/transaction-payment/src/lib.rs | 35 ----------------------------
 1 file changed, 35 deletions(-)

diff --git a/frame/transaction-payment/src/lib.rs b/frame/transaction-payment/src/lib.rs
index cb693a0fd0854..6153860e1efa4 100644
--- a/frame/transaction-payment/src/lib.rs
+++ b/frame/transaction-payment/src/lib.rs
@@ -830,38 +830,3 @@ mod tests {
 			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
 		});
 	}
-
-	// TODO Remove after u32 to u64 weights upgrade
-	#[test]
-	fn upgrade_to_fixed128_works() {
-		// TODO You can remove this from dev-dependencies after removing this test
-		use sp_storage::Storage;
-		use sp_runtime::Fixed64;
-		use frame_support::storage::generator::StorageValue;
-		use frame_support::traits::OnRuntimeUpgrade;
-		use core::num::NonZeroI128;
-
-		let mut s = Storage::default();
-
-		let original_multiplier = Fixed64::from_rational(1, 2);
-
-		let data = vec![
-			(
-				NextFeeMultiplier::storage_value_final_key().to_vec(),
-				original_multiplier.encode().to_vec()
-			),
-		];
-
-		s.top = data.into_iter().collect();
-
-		sp_io::TestExternalities::new(s).execute_with(|| {
-			let old_value = NextFeeMultiplier::get();
-			assert!(old_value != Fixed128::from_rational(1, NonZeroI128::new(2).unwrap()));
-
-			// Convert Fixed64(.5) to Fixed128(.5)
-			TransactionPayment::on_runtime_upgrade();
-			let new_value = NextFeeMultiplier::get();
-			assert_eq!(new_value, Fixed128::from_rational(1, NonZeroI128::new(2).unwrap()));
-		});
-	}
-}

From 0f8236cc086aa50c7cdcfa4b6fa73c16fb48a605 Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 14:34:59 +0200
Subject: [PATCH 5/8] oops

---
 frame/transaction-payment/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/frame/transaction-payment/src/lib.rs b/frame/transaction-payment/src/lib.rs
index 6153860e1efa4..fdcb9122a25e3 100644
--- a/frame/transaction-payment/src/lib.rs
+++ b/frame/transaction-payment/src/lib.rs
@@ -830,3 +830,4 @@ mod tests {
 			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
 		});
 	}
+}

From cd5e95b1657969e3a3e75254754e221e34f017e2 Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 14:48:35 +0200
Subject: [PATCH 6/8] Revert "Remove old staking"

This reverts commit 95262b1ac43c9b5bcf49d2ae80800feabcbbbaa0.
---
 frame/staking/src/lib.rs   | 219 +++++++++++++++++-
 frame/staking/src/mock.rs  |  34 ++-
 frame/staking/src/tests.rs | 459 +++++++++++++++++++++++++++++++++++++
 3 files changed, 702 insertions(+), 10 deletions(-)

diff --git a/frame/staking/src/lib.rs b/frame/staking/src/lib.rs
index 444caac732ae8..ca3fb51ecb749 100644
--- a/frame/staking/src/lib.rs
+++ b/frame/staking/src/lib.rs
@@ -1037,6 +1037,9 @@ decl_storage! {
 		///
 		/// This is set to v3.0.0 for new networks.
 		StorageVersion build(|_: &GenesisConfig<T>| Releases::V3_0_0): Releases;
+
+		/// The era where we migrated from Lazy Payouts to Simple Payouts
+		MigrateEra: Option<EraIndex>;
 	}
 	add_extra_genesis {
 		config(stakers):
@@ -1243,15 +1246,6 @@ decl_module! {
 			}
 		}
 
-		fn on_runtime_upgrade() -> Weight {
-			use frame_support::storage::migration::take_storage_value;
-			if let Some(_) = take_storage_value::<EraIndex>(b"Staking", b"MigrateEra", b"") {
-				T::DbWeight::get().reads_writes(1, 1)
-			} else {
-				T::DbWeight::get().reads(1)
-			}
-		}
-
 		/// Take the origin account as a stash and lock up `value` of its balance. `controller` will
 		/// be the account that controls it.
 		///
@@ -1670,6 +1664,69 @@ decl_module! {
 			<Self as Store>::UnappliedSlashes::insert(&era, &unapplied);
 		}
 
+		/// **This extrinsic will be removed after `MigrationEra + HistoryDepth` has passed, giving
+		/// opportunity for users to claim all rewards before moving to Simple Payouts. After this
+		/// time, you should use `payout_stakers` instead.**
+		///
+		/// Make one nominator's payout for one era.
+		///
+		/// - `who` is the controller account of the nominator to pay out.
+		/// - `era` may not be lower than one following the most recently paid era. If it is higher,
+		///   then it indicates an instruction to skip the payout of all previous eras.
+		/// - `validators` is the list of all validators that `who` had exposure to during `era`,
+		///   alongside the index of `who` in the clipped exposure of the validator.
+		///   I.e. each element is a tuple of
+		///   `(validator, index of `who` in clipped exposure of validator)`.
+		///   If it is incomplete, then less than the full reward will be paid out.
+		///   It must not exceed `MAX_NOMINATIONS`.
+		///
+		/// WARNING: once an era is payed for a validator such validator can't claim the payout of
+		/// previous era.
+		///
+		/// WARNING: Incorrect arguments here can result in loss of payout. Be very careful.
+		///
+		/// # <weight>
+		/// - Number of storage read of `O(validators)`; `validators` is the argument of the call,
+		///   and is bounded by `MAX_NOMINATIONS`.
+		/// - Each storage read is `O(N)` size and decode complexity; `N` is the  maximum
+		///   nominations that can be given to a single validator.
+		/// - Computation complexity: `O(MAX_NOMINATIONS * logN)`; `MAX_NOMINATIONS` is the
+		///   maximum number of validators that may be nominated by a single nominator, it is
+		///   bounded only economically (all nominators are required to place a minimum stake).
+		/// # </weight>
+		#[weight = 500_000_000]
+		fn payout_nominator(origin, era: EraIndex, validators: Vec<(T::AccountId, u32)>)
+			-> DispatchResult
+		{
+			let ctrl = ensure_signed(origin)?;
+			Self::do_payout_nominator(ctrl, era, validators)
+		}
+
+		/// **This extrinsic will be removed after `MigrationEra + HistoryDepth` has passed, giving
+		/// opportunity for users to claim all rewards before moving to Simple Payouts. After this
+		/// time, you should use `payout_stakers` instead.**
+		///
+		/// Make one validator's payout for one era.
+		///
+		/// - `who` is the controller account of the validator to pay out.
+		/// - `era` may not be lower than one following the most recently paid era. If it is higher,
+		///   then it indicates an instruction to skip the payout of all previous eras.
+		///
+		/// WARNING: once an era is payed for a validator such validator can't claim the payout of
+		/// previous era.
+		///
+		/// WARNING: Incorrect arguments here can result in loss of payout. Be very careful.
+		///
+		/// # <weight>
+		/// - Time complexity: O(1).
+		/// - Contains a limited number of reads and writes.
+		/// # </weight>
+		#[weight = 500_000_000]
+		fn payout_validator(origin, era: EraIndex) -> DispatchResult {
+			let ctrl = ensure_signed(origin)?;
+			Self::do_payout_validator(ctrl, era)
+		}
+
 		/// Pay out all the stakers behind a single validator for a single era.
 		///
 		/// - `validator_stash` is the stash account of the validator. Their nominators, up to
@@ -1917,6 +1974,143 @@ impl<T: Trait> Module<T> {
 		<SnapshotNominators<T>>::kill();
 	}
 
+	fn do_payout_nominator(ctrl: T::AccountId, era: EraIndex, validators: Vec<(T::AccountId, u32)>)
+		-> DispatchResult
+	{
+		// validators len must not exceed `MAX_NOMINATIONS` to avoid querying more validator
+		// exposure than necessary.
+		if validators.len() > MAX_NOMINATIONS {
+			return Err(Error::<T>::InvalidNumberOfNominations.into());
+		}
+		// If migrate_era is not populated, then you should use `payout_stakers`
+		let migrate_era = MigrateEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
+		// This payout mechanism will only work for eras before the migration.
+		// Subsequent payouts should use `payout_stakers`.
+		ensure!(era < migrate_era, Error::<T>::InvalidEraToReward);
+		let current_era = CurrentEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
+		ensure!(era <= current_era, Error::<T>::InvalidEraToReward);
+		let history_depth = Self::history_depth();
+		ensure!(era >= current_era.saturating_sub(history_depth), Error::<T>::InvalidEraToReward);
+
+		// Note: if era has no reward to be claimed, era may be future. better not to update
+		// `nominator_ledger.last_reward` in this case.
+		let era_payout = <ErasValidatorReward<T>>::get(&era)
+			.ok_or_else(|| Error::<T>::InvalidEraToReward)?;
+
+		let mut nominator_ledger = <Ledger<T>>::get(&ctrl).ok_or_else(|| Error::<T>::NotController)?;
+
+		ensure!(
+			Self::era_election_status().is_closed() || Self::payee(&nominator_ledger.stash) != RewardDestination::Staked,
+			Error::<T>::CallNotAllowed,
+		);
+
+		nominator_ledger.claimed_rewards.retain(|&x| x >= current_era.saturating_sub(history_depth));
+		match nominator_ledger.claimed_rewards.binary_search(&era) {
+			Ok(_) => Err(Error::<T>::AlreadyClaimed)?,
+			Err(pos) => nominator_ledger.claimed_rewards.insert(pos, era),
+		}
+
+		<Ledger<T>>::insert(&ctrl, &nominator_ledger);
+
+		let mut reward = Perbill::zero();
+		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
+
+		for (validator, nominator_index) in validators.into_iter() {
+			let commission = Self::eras_validator_prefs(&era, &validator).commission;
+			let validator_exposure = <ErasStakersClipped<T>>::get(&era, &validator);
+
+			if let Some(nominator_exposure) = validator_exposure.others
+				.get(nominator_index as usize)
+			{
+				if nominator_exposure.who != nominator_ledger.stash {
+					continue;
+				}
+
+				let nominator_exposure_part = Perbill::from_rational_approximation(
+					nominator_exposure.value,
+					validator_exposure.total,
+				);
+				let validator_point = era_reward_points.individual.get(&validator)
+					.map(|points| *points)
+					.unwrap_or_else(|| Zero::zero());
+				let validator_point_part = Perbill::from_rational_approximation(
+					validator_point,
+					era_reward_points.total,
+				);
+				reward = reward.saturating_add(
+					validator_point_part
+						.saturating_mul(Perbill::one().saturating_sub(commission))
+						.saturating_mul(nominator_exposure_part)
+				);
+			}
+		}
+
+		if let Some(imbalance) = Self::make_payout(&nominator_ledger.stash, reward * era_payout) {
+			Self::deposit_event(RawEvent::Reward(ctrl, imbalance.peek()));
+		}
+
+		Ok(())
+	}
+
+	fn do_payout_validator(ctrl: T::AccountId, era: EraIndex) -> DispatchResult {
+		// If migrate_era is not populated, then you should use `payout_stakers`
+		let migrate_era = MigrateEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
+		// This payout mechanism will only work for eras before the migration.
+		// Subsequent payouts should use `payout_stakers`.
+		ensure!(era < migrate_era, Error::<T>::InvalidEraToReward);
+		let current_era = CurrentEra::get().ok_or(Error::<T>::InvalidEraToReward)?;
+		ensure!(era <= current_era, Error::<T>::InvalidEraToReward);
+		let history_depth = Self::history_depth();
+		ensure!(era >= current_era.saturating_sub(history_depth), Error::<T>::InvalidEraToReward);
+
+		// Note: if era has no reward to be claimed, era may be future. better not to update
+		// `ledger.last_reward` in this case.
+		let era_payout = <ErasValidatorReward<T>>::get(&era)
+			.ok_or_else(|| Error::<T>::InvalidEraToReward)?;
+
+		let mut ledger = <Ledger<T>>::get(&ctrl).ok_or_else(|| Error::<T>::NotController)?;
+
+		ensure!(
+			Self::era_election_status().is_closed() || Self::payee(&ledger.stash) != RewardDestination::Staked,
+			Error::<T>::CallNotAllowed,
+		);
+
+		ledger.claimed_rewards.retain(|&x| x >= current_era.saturating_sub(history_depth));
+		match ledger.claimed_rewards.binary_search(&era) {
+			Ok(_) => Err(Error::<T>::AlreadyClaimed)?,
+			Err(pos) => ledger.claimed_rewards.insert(pos, era),
+		}
+
+		<Ledger<T>>::insert(&ctrl, &ledger);
+
+		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
+		let commission = Self::eras_validator_prefs(&era, &ledger.stash).commission;
+		let exposure = <ErasStakersClipped<T>>::get(&era, &ledger.stash);
+
+		let exposure_part = Perbill::from_rational_approximation(
+			exposure.own,
+			exposure.total,
+		);
+		let validator_point = era_reward_points.individual.get(&ledger.stash)
+			.map(|points| *points)
+			.unwrap_or_else(|| Zero::zero());
+		let validator_point_part = Perbill::from_rational_approximation(
+			validator_point,
+			era_reward_points.total,
+		);
+		let reward = validator_point_part.saturating_mul(
+			commission.saturating_add(
+				Perbill::one().saturating_sub(commission).saturating_mul(exposure_part)
+			)
+		);
+
+		if let Some(imbalance) = Self::make_payout(&ledger.stash, reward * era_payout) {
+			Self::deposit_event(RawEvent::Reward(ctrl, imbalance.peek()));
+		}
+
+		Ok(())
+	}
+
 	fn do_payout_stakers(
 		validator_stash: T::AccountId,
 		era: EraIndex,
@@ -1927,6 +2121,13 @@ impl<T: Trait> Module<T> {
 		let history_depth = Self::history_depth();
 		ensure!(era >= current_era.saturating_sub(history_depth), Error::<T>::InvalidEraToReward);
 
+		// If there was no migration, then this function is always valid.
+		if let Some(migrate_era) = MigrateEra::get() {
+			// This payout mechanism will only work for eras on and after the migration.
+			// Payouts before then should use `payout_nominator`/`payout_validator`.
+			ensure!(migrate_era <= era, Error::<T>::InvalidEraToReward);
+		}
+
 		// Note: if era has no reward to be claimed, era may be future. better not to update
 		// `ledger.claimed_rewards` in this case.
 		let era_payout = <ErasValidatorReward<T>>::get(&era)
diff --git a/frame/staking/src/mock.rs b/frame/staking/src/mock.rs
index 886da0534784a..a34f3425564cd 100644
--- a/frame/staking/src/mock.rs
+++ b/frame/staking/src/mock.rs
@@ -16,7 +16,7 @@
 
 //! Test utilities
 
-use std::{collections::HashSet, cell::RefCell};
+use std::{collections::{HashSet, HashMap}, cell::RefCell};
 use sp_runtime::Perbill;
 use sp_runtime::curve::PiecewiseLinear;
 use sp_runtime::traits::{IdentityLookup, Convert, SaturatedConversion, Zero};
@@ -948,6 +948,38 @@ pub(crate) fn prepare_submission_with(
 	(compact, winners, score)
 }
 
+/// Make all validator and nominator request their payment
+pub(crate) fn make_all_reward_payment_before_migration(era: EraIndex) {
+	let validators_with_reward = ErasRewardPoints::<Test>::get(era).individual.keys()
+		.cloned()
+		.collect::<Vec<_>>();
+
+	// reward nominators
+	let mut nominator_controllers = HashMap::new();
+	for validator in Staking::eras_reward_points(era).individual.keys() {
+		let validator_exposure = Staking::eras_stakers_clipped(era, validator);
+		for (nom_index, nom) in validator_exposure.others.iter().enumerate() {
+			if let Some(nom_ctrl) = Staking::bonded(nom.who) {
+				nominator_controllers.entry(nom_ctrl)
+					.or_insert(vec![])
+					.push((validator.clone(), nom_index as u32));
+			}
+		}
+	}
+	for (nominator_controller, validators_with_nom_index) in nominator_controllers {
+		assert_ok!(Staking::payout_nominator(
+			Origin::signed(nominator_controller),
+			era,
+			validators_with_nom_index,
+		));
+	}
+
+	// reward validators
+	for validator_controller in validators_with_reward.iter().filter_map(Staking::bonded) {
+		assert_ok!(Staking::payout_validator(Origin::signed(validator_controller), era));
+	}
+}
+
 /// Make all validator and nominator request their payment
 pub(crate) fn make_all_reward_payment(era: EraIndex) {
 	let validators_with_reward = ErasRewardPoints::<Test>::get(era).individual.keys()
diff --git a/frame/staking/src/tests.rs b/frame/staking/src/tests.rs
index 035eed23d4e5e..84c937d324cab 100644
--- a/frame/staking/src/tests.rs
+++ b/frame/staking/src/tests.rs
@@ -4264,3 +4264,462 @@ fn bond_during_era_correctly_populates_claimed_rewards() {
 		);
 	});
 }
+
+/* These migration tests below can be removed once migration code is removed */
+
+#[test]
+fn assert_migration_is_noop() {
+	let kusama_active_era = "4a0200000190e2721171010000";
+	let era = ActiveEraInfo::decode(&mut &hex::decode(kusama_active_era).unwrap()[..]).unwrap();
+	assert_eq!(era.index, 586);
+	assert_eq!(era.start, Some(1585135674000));
+}
+
+#[test]
+fn test_last_reward_migration() {
+	use sp_storage::Storage;
+
+	let mut s = Storage::default();
+
+	#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
+	struct OldStakingLedger<AccountId, Balance: HasCompact> {
+		pub stash: AccountId,
+		#[codec(compact)]
+		pub total: Balance,
+		#[codec(compact)]
+		pub active: Balance,
+		pub unlocking: Vec<UnlockChunk<Balance>>,
+		pub last_reward: Option<EraIndex>,
+	}
+
+	let old_staking10 = OldStakingLedger::<u64, u64> {
+		stash: 0,
+		total: 10,
+		active: 10,
+		unlocking: vec![UnlockChunk{ value: 1234, era: 56}],
+		last_reward: Some(8),
+	};
+
+	let old_staking11 = OldStakingLedger::<u64, u64> {
+		stash: 1,
+		total: 0,
+		active: 0,
+		unlocking: vec![],
+		last_reward: None,
+	};
+
+	let old_staking12 = OldStakingLedger::<u64, u64> {
+		stash: 2,
+		total: 100,
+		active: 100,
+		unlocking: vec![UnlockChunk{ value: 9876, era: 54}, UnlockChunk{ value: 98, era: 76}],
+		last_reward: Some(23),
+	};
+
+	let old_staking13 = OldStakingLedger::<u64, u64> {
+		stash: 3,
+		total: 100,
+		active: 100,
+		unlocking: vec![],
+		last_reward: Some(23),
+	};
+
+	let data = vec![
+		(
+			Ledger::<Test>::hashed_key_for(10),
+			old_staking10.encode().to_vec()
+		),
+		(
+			Ledger::<Test>::hashed_key_for(11),
+			old_staking11.encode().to_vec()
+		),
+		(
+			Ledger::<Test>::hashed_key_for(12),
+			old_staking12.encode().to_vec()
+		),
+		(
+			Ledger::<Test>::hashed_key_for(13),
+			old_staking13.encode().to_vec()
+		),
+	];
+
+	s.top = data.into_iter().collect();
+	sp_io::TestExternalities::new(s).execute_with(|| {
+		HistoryDepth::put(84);
+		CurrentEra::put(99);
+		let nominations = Nominations::<AccountId> {
+			targets: vec![],
+			submitted_in: 0,
+			suppressed: false
+		};
+		Nominators::<Test>::insert(3, nominations);
+		Bonded::<Test>::insert(3, 13);
+		Staking::migrate_last_reward_to_claimed_rewards();
+		// Test staker out of range
+		assert_eq!(
+			Ledger::<Test>::get(10),
+			Some(StakingLedger {
+				stash: 0,
+				total: 10,
+				active: 10,
+				unlocking: vec![UnlockChunk{ value: 1234, era: 56}],
+				claimed_rewards: vec![],
+			})
+		);
+		// Test staker none
+		assert_eq!(
+			Ledger::<Test>::get(11),
+			Some(StakingLedger {
+				stash: 1,
+				total: 0,
+				active: 0,
+				unlocking: vec![],
+				claimed_rewards: vec![],
+			})
+		);
+		// Test staker migration
+		assert_eq!(
+			Ledger::<Test>::get(12),
+			Some(StakingLedger {
+				stash: 2,
+				total: 100,
+				active: 100,
+				unlocking: vec![UnlockChunk{ value: 9876, era: 54}, UnlockChunk{ value: 98, era: 76}],
+				claimed_rewards: vec![15,16,17,18,19,20,21,22,23],
+			})
+		);
+		// Test nominator migration
+		assert_eq!(
+			Ledger::<Test>::get(13),
+			Some(StakingLedger {
+				stash: 3,
+				total: 100,
+				active: 100,
+				unlocking: vec![],
+				claimed_rewards: vec![15,16,17,18,19,20,21,22,23],
+			})
+		);
+	});
+}
+
+#[test]
+fn rewards_should_work_before_migration() {
+	// should check that before migration:
+	// * rewards get recorded per session
+	// * rewards get paid per Era
+	// * Check that nominators are also rewarded
+	ExtBuilder::default().nominate(true).build_and_execute(|| {
+		MigrateEra::put(10);
+		let init_balance_10 = Balances::total_balance(&10);
+		let init_balance_11 = Balances::total_balance(&11);
+		let init_balance_20 = Balances::total_balance(&20);
+		let init_balance_21 = Balances::total_balance(&21);
+		let init_balance_100 = Balances::total_balance(&100);
+		let init_balance_101 = Balances::total_balance(&101);
+
+		// Check state
+		Payee::<Test>::insert(11, RewardDestination::Controller);
+		Payee::<Test>::insert(21, RewardDestination::Controller);
+		Payee::<Test>::insert(101, RewardDestination::Controller);
+
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		// This is the second validator of the current elected set.
+		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_0 > 10); // Test is meaningful if reward something
+
+		start_session(1);
+
+		assert_eq!(Balances::total_balance(&10), init_balance_10);
+		assert_eq!(Balances::total_balance(&11), init_balance_11);
+		assert_eq!(Balances::total_balance(&20), init_balance_20);
+		assert_eq!(Balances::total_balance(&21), init_balance_21);
+		assert_eq!(Balances::total_balance(&100), init_balance_100);
+		assert_eq!(Balances::total_balance(&101), init_balance_101);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
+			total: 50*3,
+			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
+		});
+		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
+		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
+		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
+		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
+
+		start_session(2);
+		start_session(3);
+
+		assert_eq!(Staking::active_era().unwrap().index, 1);
+		mock::make_all_reward_payment_before_migration(0);
+
+		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * total_payout_0*2/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
+		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0*1/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
+		assert_eq_error_rate!(
+			Balances::total_balance(&100),
+			init_balance_100
+				+ part_for_100_from_10 * total_payout_0 * 2/3
+				+ part_for_100_from_20 * total_payout_0 * 1/3,
+			2
+		);
+		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
+
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		<Module<Test>>::reward_by_ids(vec![(11, 1)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_1 > 10); // Test is meaningful if reward something
+
+		mock::start_era(2);
+		mock::make_all_reward_payment_before_migration(1);
+
+		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * (total_payout_0 * 2/3 + total_payout_1), 2);
+		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
+		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0 * 1/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
+		assert_eq_error_rate!(
+			Balances::total_balance(&100),
+			init_balance_100
+				+ part_for_100_from_10 * (total_payout_0 * 2/3 + total_payout_1)
+				+ part_for_100_from_20 * total_payout_0 * 1/3,
+			2
+		);
+		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
+	});
+}
+
+#[test]
+fn migrate_era_should_work() {
+	// should check that before and after migration:
+	// * rewards get recorded per session
+	// * rewards get paid per Era
+	// * Check that nominators are also rewarded
+	ExtBuilder::default().nominate(true).build_and_execute(|| {
+		MigrateEra::put(1);
+		let init_balance_10 = Balances::total_balance(&10);
+		let init_balance_11 = Balances::total_balance(&11);
+		let init_balance_20 = Balances::total_balance(&20);
+		let init_balance_21 = Balances::total_balance(&21);
+		let init_balance_100 = Balances::total_balance(&100);
+		let init_balance_101 = Balances::total_balance(&101);
+
+		// Check state
+		Payee::<Test>::insert(11, RewardDestination::Controller);
+		Payee::<Test>::insert(21, RewardDestination::Controller);
+		Payee::<Test>::insert(101, RewardDestination::Controller);
+
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		// This is the second validator of the current elected set.
+		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_0 > 10); // Test is meaningful if reward something
+
+		start_session(1);
+
+		assert_eq!(Balances::total_balance(&10), init_balance_10);
+		assert_eq!(Balances::total_balance(&11), init_balance_11);
+		assert_eq!(Balances::total_balance(&20), init_balance_20);
+		assert_eq!(Balances::total_balance(&21), init_balance_21);
+		assert_eq!(Balances::total_balance(&100), init_balance_100);
+		assert_eq!(Balances::total_balance(&101), init_balance_101);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
+			total: 50*3,
+			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
+		});
+		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
+		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
+		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
+		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
+
+		start_session(2);
+		start_session(3);
+
+		assert_eq!(Staking::active_era().unwrap().index, 1);
+		mock::make_all_reward_payment_before_migration(0);
+
+		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * total_payout_0*2/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
+		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0*1/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
+		assert_eq_error_rate!(
+			Balances::total_balance(&100),
+			init_balance_100
+				+ part_for_100_from_10 * total_payout_0 * 2/3
+				+ part_for_100_from_20 * total_payout_0 * 1/3,
+			2
+		);
+		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
+
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		<Module<Test>>::reward_by_ids(vec![(11, 1)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_1 > 10); // Test is meaningful if reward something
+
+		mock::start_era(2);
+		mock::make_all_reward_payment(1);
+
+		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * (total_payout_0 * 2/3 + total_payout_1), 2);
+		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
+		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0 * 1/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
+		assert_eq_error_rate!(
+			Balances::total_balance(&100),
+			init_balance_100
+				+ part_for_100_from_10 * (total_payout_0 * 2/3 + total_payout_1)
+				+ part_for_100_from_20 * total_payout_0 * 1/3,
+			2
+		);
+		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
+	});
+}
+
+#[test]
+#[should_panic]
+fn migrate_era_should_handle_error() {
+	ExtBuilder::default().nominate(true).build_and_execute(|| {
+		MigrateEra::put(1);
+		let init_balance_10 = Balances::total_balance(&10);
+		let init_balance_11 = Balances::total_balance(&11);
+		let init_balance_20 = Balances::total_balance(&20);
+		let init_balance_21 = Balances::total_balance(&21);
+		let init_balance_100 = Balances::total_balance(&100);
+		let init_balance_101 = Balances::total_balance(&101);
+
+		// Check state
+		Payee::<Test>::insert(11, RewardDestination::Controller);
+		Payee::<Test>::insert(21, RewardDestination::Controller);
+		Payee::<Test>::insert(101, RewardDestination::Controller);
+
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		// This is the second validator of the current elected set.
+		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_0 > 10); // Test is meaningful if reward something
+
+		start_session(1);
+
+		assert_eq!(Balances::total_balance(&10), init_balance_10);
+		assert_eq!(Balances::total_balance(&11), init_balance_11);
+		assert_eq!(Balances::total_balance(&20), init_balance_20);
+		assert_eq!(Balances::total_balance(&21), init_balance_21);
+		assert_eq!(Balances::total_balance(&100), init_balance_100);
+		assert_eq!(Balances::total_balance(&101), init_balance_101);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
+			total: 50*3,
+			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
+		});
+
+		start_session(2);
+		start_session(3);
+
+		assert_eq!(Staking::active_era().unwrap().index, 1);
+		mock::make_all_reward_payment(0);
+	});
+}
+
+#[test]
+#[should_panic]
+fn migrate_era_should_handle_errors_2() {
+	// should check that before and after migration:
+	// * rewards get recorded per session
+	// * rewards get paid per Era
+	// * Check that nominators are also rewarded
+	ExtBuilder::default().nominate(true).build_and_execute(|| {
+		MigrateEra::put(1);
+		let init_balance_10 = Balances::total_balance(&10);
+		let init_balance_11 = Balances::total_balance(&11);
+		let init_balance_20 = Balances::total_balance(&20);
+		let init_balance_21 = Balances::total_balance(&21);
+		let init_balance_100 = Balances::total_balance(&100);
+		let init_balance_101 = Balances::total_balance(&101);
+
+		// Check state
+		Payee::<Test>::insert(11, RewardDestination::Controller);
+		Payee::<Test>::insert(21, RewardDestination::Controller);
+		Payee::<Test>::insert(101, RewardDestination::Controller);
+
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		<Module<Test>>::reward_by_ids(vec![(11, 50)]);
+		// This is the second validator of the current elected set.
+		<Module<Test>>::reward_by_ids(vec![(21, 50)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_0 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_0 > 10); // Test is meaningful if reward something
+
+		start_session(1);
+
+		assert_eq!(Balances::total_balance(&10), init_balance_10);
+		assert_eq!(Balances::total_balance(&11), init_balance_11);
+		assert_eq!(Balances::total_balance(&20), init_balance_20);
+		assert_eq!(Balances::total_balance(&21), init_balance_21);
+		assert_eq!(Balances::total_balance(&100), init_balance_100);
+		assert_eq!(Balances::total_balance(&101), init_balance_101);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		assert_eq!(Staking::eras_reward_points(Staking::active_era().unwrap().index), EraRewardPoints {
+			total: 50*3,
+			individual: vec![(11, 100), (21, 50)].into_iter().collect(),
+		});
+		let part_for_10 = Perbill::from_rational_approximation::<u32>(1000, 1125);
+		let part_for_20 = Perbill::from_rational_approximation::<u32>(1000, 1375);
+		let part_for_100_from_10 = Perbill::from_rational_approximation::<u32>(125, 1125);
+		let part_for_100_from_20 = Perbill::from_rational_approximation::<u32>(375, 1375);
+
+		start_session(2);
+		start_session(3);
+
+		assert_eq!(Staking::active_era().unwrap().index, 1);
+		mock::make_all_reward_payment_before_migration(0);
+
+		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * total_payout_0*2/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
+		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0*1/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
+		assert_eq_error_rate!(
+			Balances::total_balance(&100),
+			init_balance_100
+				+ part_for_100_from_10 * total_payout_0 * 2/3
+				+ part_for_100_from_20 * total_payout_0 * 1/3,
+			2
+		);
+		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
+
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		<Module<Test>>::reward_by_ids(vec![(11, 1)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(3 * 1000);
+		assert!(total_payout_1 > 10); // Test is meaningful if reward something
+
+		mock::start_era(2);
+		mock::make_all_reward_payment_before_migration(1);
+
+		assert_eq_error_rate!(Balances::total_balance(&10), init_balance_10 + part_for_10 * (total_payout_0 * 2/3 + total_payout_1), 2);
+		assert_eq_error_rate!(Balances::total_balance(&11), init_balance_11, 2);
+		assert_eq_error_rate!(Balances::total_balance(&20), init_balance_20 + part_for_20 * total_payout_0 * 1/3, 2);
+		assert_eq_error_rate!(Balances::total_balance(&21), init_balance_21, 2);
+		assert_eq_error_rate!(
+			Balances::total_balance(&100),
+			init_balance_100
+				+ part_for_100_from_10 * (total_payout_0 * 2/3 + total_payout_1)
+				+ part_for_100_from_20 * total_payout_0 * 1/3,
+			2
+		);
+		assert_eq_error_rate!(Balances::total_balance(&101), init_balance_101, 2);
+	});
+}

From 2d4f5acec744bb3561ee3f03a9de3cf0739b82f5 Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 15:16:06 +0200
Subject: [PATCH 7/8] remove migration test in staking

---
 frame/staking/src/tests.rs | 135 -------------------------------------
 1 file changed, 135 deletions(-)

diff --git a/frame/staking/src/tests.rs b/frame/staking/src/tests.rs
index 84c937d324cab..f3dddc87ed776 100644
--- a/frame/staking/src/tests.rs
+++ b/frame/staking/src/tests.rs
@@ -4267,141 +4267,6 @@ fn bond_during_era_correctly_populates_claimed_rewards() {
 
 /* These migration tests below can be removed once migration code is removed */
 
-#[test]
-fn assert_migration_is_noop() {
-	let kusama_active_era = "4a0200000190e2721171010000";
-	let era = ActiveEraInfo::decode(&mut &hex::decode(kusama_active_era).unwrap()[..]).unwrap();
-	assert_eq!(era.index, 586);
-	assert_eq!(era.start, Some(1585135674000));
-}
-
-#[test]
-fn test_last_reward_migration() {
-	use sp_storage::Storage;
-
-	let mut s = Storage::default();
-
-	#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
-	struct OldStakingLedger<AccountId, Balance: HasCompact> {
-		pub stash: AccountId,
-		#[codec(compact)]
-		pub total: Balance,
-		#[codec(compact)]
-		pub active: Balance,
-		pub unlocking: Vec<UnlockChunk<Balance>>,
-		pub last_reward: Option<EraIndex>,
-	}
-
-	let old_staking10 = OldStakingLedger::<u64, u64> {
-		stash: 0,
-		total: 10,
-		active: 10,
-		unlocking: vec![UnlockChunk{ value: 1234, era: 56}],
-		last_reward: Some(8),
-	};
-
-	let old_staking11 = OldStakingLedger::<u64, u64> {
-		stash: 1,
-		total: 0,
-		active: 0,
-		unlocking: vec![],
-		last_reward: None,
-	};
-
-	let old_staking12 = OldStakingLedger::<u64, u64> {
-		stash: 2,
-		total: 100,
-		active: 100,
-		unlocking: vec![UnlockChunk{ value: 9876, era: 54}, UnlockChunk{ value: 98, era: 76}],
-		last_reward: Some(23),
-	};
-
-	let old_staking13 = OldStakingLedger::<u64, u64> {
-		stash: 3,
-		total: 100,
-		active: 100,
-		unlocking: vec![],
-		last_reward: Some(23),
-	};
-
-	let data = vec![
-		(
-			Ledger::<Test>::hashed_key_for(10),
-			old_staking10.encode().to_vec()
-		),
-		(
-			Ledger::<Test>::hashed_key_for(11),
-			old_staking11.encode().to_vec()
-		),
-		(
-			Ledger::<Test>::hashed_key_for(12),
-			old_staking12.encode().to_vec()
-		),
-		(
-			Ledger::<Test>::hashed_key_for(13),
-			old_staking13.encode().to_vec()
-		),
-	];
-
-	s.top = data.into_iter().collect();
-	sp_io::TestExternalities::new(s).execute_with(|| {
-		HistoryDepth::put(84);
-		CurrentEra::put(99);
-		let nominations = Nominations::<AccountId> {
-			targets: vec![],
-			submitted_in: 0,
-			suppressed: false
-		};
-		Nominators::<Test>::insert(3, nominations);
-		Bonded::<Test>::insert(3, 13);
-		Staking::migrate_last_reward_to_claimed_rewards();
-		// Test staker out of range
-		assert_eq!(
-			Ledger::<Test>::get(10),
-			Some(StakingLedger {
-				stash: 0,
-				total: 10,
-				active: 10,
-				unlocking: vec![UnlockChunk{ value: 1234, era: 56}],
-				claimed_rewards: vec![],
-			})
-		);
-		// Test staker none
-		assert_eq!(
-			Ledger::<Test>::get(11),
-			Some(StakingLedger {
-				stash: 1,
-				total: 0,
-				active: 0,
-				unlocking: vec![],
-				claimed_rewards: vec![],
-			})
-		);
-		// Test staker migration
-		assert_eq!(
-			Ledger::<Test>::get(12),
-			Some(StakingLedger {
-				stash: 2,
-				total: 100,
-				active: 100,
-				unlocking: vec![UnlockChunk{ value: 9876, era: 54}, UnlockChunk{ value: 98, era: 76}],
-				claimed_rewards: vec![15,16,17,18,19,20,21,22,23],
-			})
-		);
-		// Test nominator migration
-		assert_eq!(
-			Ledger::<Test>::get(13),
-			Some(StakingLedger {
-				stash: 3,
-				total: 100,
-				active: 100,
-				unlocking: vec![],
-				claimed_rewards: vec![15,16,17,18,19,20,21,22,23],
-			})
-		);
-	});
-}
-
 #[test]
 fn rewards_should_work_before_migration() {
 	// should check that before migration:

From 21aa811d202775d1ebe64459e314bbf56344a21f Mon Sep 17 00:00:00 2001
From: Shawn Tabrizi <shawntabrizi@gmail.com>
Date: Sat, 2 May 2020 15:52:02 +0200
Subject: [PATCH 8/8] fix warnings

---
 frame/indices/src/lib.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/frame/indices/src/lib.rs b/frame/indices/src/lib.rs
index c144772138e53..8c17fed592130 100644
--- a/frame/indices/src/lib.rs
+++ b/frame/indices/src/lib.rs
@@ -22,10 +22,9 @@
 use sp_std::prelude::*;
 use codec::Codec;
 use sp_runtime::traits::{
-	StaticLookup, Member, LookupError, Zero, One, BlakeTwo256, Hash, Saturating, AtLeast32Bit
+	StaticLookup, Member, LookupError, Zero, Saturating, AtLeast32Bit
 };
 use frame_support::{Parameter, decl_module, decl_error, decl_event, decl_storage, ensure};
-use frame_support::weights::Weight;
 use frame_support::dispatch::DispatchResult;
 use frame_support::traits::{Currency, ReservableCurrency, Get, BalanceStatus::Reserved};
 use frame_system::{ensure_signed, ensure_root};