WIP

Author: gui1117

bin/node/runtime/src/lib.rs

@@ -78,8 +78,8 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// and set impl_version to equal spec_version. If only runtime
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
-	spec_version: 198,
-	impl_version: 198,
+	spec_version: 199,
+	impl_version: 199,
 	apis: RUNTIME_API_VERSIONS,
 };
 

frame/staking/src/lib.rs

@@ -683,7 +683,7 @@ decl_storage! {
 		pub EraStartSessionIndex get(fn era_start_session_index) build(|_| vec![0]): Vec<SessionIndex>;
 
 		/// Rewards for the current era. Using indices of current elected set.
-		pub CurrentEraPointsEarned get(fn current_era_reward): EraPoints;
+		CurrentEraPointsEarned get(fn current_era_reward): EraPoints;
 
 		/// Mapping from era to its validator set with all information needed for rewarding.
 		///
@@ -744,6 +744,15 @@ decl_storage! {
 
 		/// The version of storage for upgrade.
 		StorageVersion: u32;
+
+		/// Deprecated: This storage is outdated. Information are not relevant anymore.
+		Stakers: map T::AccountId => Exposure<T::AccountId, BalanceOf<T>>;
+
+		/// Deprecated: This storage is outdated. Information are not relevant anymore.
+		CurrentElected: Vec<T::AccountId>;
+
+		/// Deprecated: This storage is outdated. Information are not relevant anymore.
+		SlotStake: BalanceOf<T>;
 	}
 	add_extra_genesis {
 		config(stakers):
@@ -1350,21 +1359,21 @@ impl<T: Trait> Module<T> {
 		}
 
 		// Increment current era.
-		let current_era = current_era + 1;
-		CurrentEra::put(current_era);
+		let new_current_era = current_era + 1;
+		CurrentEra::put(new_current_era);
 		EraStartSessionIndex::mutate(|era_start| {
 			era_start.remove(0)
 		});
 
-		Self::apply_unapplied_slashes(current_era);
+		Self::apply_unapplied_slashes(new_current_era);
 
 		let bonding_duration = T::BondingDuration::get();
 
 		BondedEras::mutate(|bonded| {
-			bonded.push((current_era, session_index + 1));
+			bonded.push((new_current_era, session_index + 1));
 
-			if current_era > bonding_duration {
-				let first_kept = current_era - bonding_duration;
+			if new_current_era > bonding_duration {
+				let first_kept = new_current_era - bonding_duration;
 
 				// prune out everything that's from before the first-kept index.
 				let n_to_prune = bonded.iter()

frame/staking/src/migration.rs

@@ -20,13 +20,13 @@
 pub type VersionNumber = u32;
 
 // the current expected version of the storage
-pub const CURRENT_VERSION: VersionNumber = 1;
+pub const CURRENT_VERSION: VersionNumber = 2;
 
 #[cfg(any(test, feature = "migrate"))]
 mod inner {
-	use crate::{Store, Module, Trait};
-	use support::{StorageLinkedMap, StorageValue};
-	use sp_std::vec::Vec;
+	use crate::{Store, Module, Trait, ValidatorInfoForEra, SessionInterface};
+	use support::{StorageLinkedMap, StorageValue, StorageMap, StoragePrefixedMap};
+	use sp_std::{vec, vec::Vec};
 	use super::{CURRENT_VERSION, VersionNumber};
 
 	// the minimum supported version of the migration logic.
@@ -60,6 +60,42 @@ mod inner {
 		support::print("Finished migrating Staking storage to v1.");
 	}
 
+	// migrate storage from v1 to v2.
+	//
+	// * populate `EraStartSessionIndex` storage with only the current era start
+	// * populate `ValidatorForEra` storage with information from:
+	//   * `Trait::SessionInterface::validators` for validator set
+	//   * `Stakers` for exposure of validators
+	//   * `Validators` for prefs of validators
+	// * populate `SlotStakeForEra` storage with information from `SlotStake`
+	// * remove `CurrentEraStartSessionIndex` storage
+	// * remove `CurrentElected` storage
+	// * remove `SlotStake` storage
+	pub fn from_v1_to_v2<T: Trait>(version: &mut VersionNumber) {
+		if *version != 1 { return }
+		*version += 1;
+
+		let current_era = <Module<T>>::current_era();
+		let current_validator_infos = T::SessionInterface::validators().into_iter()
+			.map(|validator| ValidatorInfoForEra {
+				prefs: <Module<T>>::validators(&validator),
+				exposure: <Module<T> as Store>::Stakers::get(&validator),
+				stash: validator,
+			})
+			.collect::<Vec<_>>();
+		let current_slot_stake = <Module<T> as Store>::SlotStake::get();
+
+		<Module<T> as Store>::ValidatorForEra::insert(&current_era, current_validator_infos);
+		<Module<T> as Store>::SlotStakeForEra::insert(&current_era, current_slot_stake);
+		<Module<T> as Store>::EraStartSessionIndex::put(vec![current_era]);
+
+		<Module<T> as Store>::Stakers::remove_all();
+		<Module<T> as Store>::CurrentElected::kill();
+		<Module<T> as Store>::SlotStake::kill();
+
+		support::print("Finished migrating Staking storage to v2.");
+	}
+
 	pub(super) fn perform_migrations<T: Trait>() {
 		<Module<T> as Store>::StorageVersion::mutate(|version| {
 			if *version < MIN_SUPPORTED_VERSION {
@@ -72,6 +108,7 @@ mod inner {
 			if *version == CURRENT_VERSION { return }
 
 			to_v1::<T>(version);
+			from_v1_to_v2::<T>(version);
 		});
 	}
 }