WIP migration

frame/staking/src/lib.rs

@@ -110,6 +110,8 @@
 //! The **reward and slashing** procedure is the core of the Staking module, attempting to _embrace
 //! valid behavior_ while _punishing any misbehavior or lack of availability_.
 //!
+//! Reward must be claimed by stakers for each era before it gets too old by $HISTORY_DEPTH.
+//!
 //! Slashing can occur at any point in time, once misbehavior is reported. Once slashing is
 //! determined, a value is deducted from the balance of the validator and all the nominators who
 //! voted for this validator (values are deducted from the _stash_ account of the slashed entity).
@@ -165,14 +167,6 @@
 //!
 //! ## Implementation Details
 //!
-//! ### Slot Stake
-//!
-//! The term [`SlotStake`](./struct.Module.html#method.slot_stake) will be used throughout this
-//! section. It refers to a value calculated at the end of each era, containing the _minimum value
-//! at stake among all validators._ Note that a validator's value at stake might be a combination
-//! of the validator's own stake and the votes it received. See [`Exposure`](./struct.Exposure.html)
-//! for more details.
-//!
 //! ### Reward Calculation
 //!
 //! Validators and nominators are rewarded at the end of each era. The total reward of an era is
@@ -314,7 +308,7 @@ pub struct EraRewardPoints<AccountId: Ord> {
 	individual: BTreeMap<AccountId, RewardPoint>,
 }
 
-/// Deprecated
+/// Deprecated. Used for migration only.
 // Reward points of an era. Used to split era total payout between validators.
 #[derive(Encode, Decode, Default)]
 pub struct EraPoints {
@@ -382,6 +376,17 @@ pub struct UnlockChunk<Balance: HasCompact> {
 	era: EraIndex,
 }
 
+/// Deprecated. Used for migration only.
+#[derive(Encode, Decode)]
+struct StakingLedgerV1<AccountId, Balance: HasCompact> {
+	stash: AccountId,
+	#[codec(compact)]
+	total: Balance,
+	#[codec(compact)]
+	active: Balance,
+	unlocking: Vec<UnlockChunk<Balance>>,
+}
+
 /// The ledger of a (bonded) stash.
 #[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
 pub struct StakingLedger<AccountId, Balance: HasCompact> {
@@ -400,10 +405,8 @@ pub struct StakingLedger<AccountId, Balance: HasCompact> {
 	pub unlocking: Vec<UnlockChunk<Balance>>,
 	/// The next era at which the staker can claim reward.
 	pub next_reward: EraIndex,
-	// TODO: ^^^ this will need migration logic.
 }
 
-
 impl<
 	AccountId,
 	Balance: HasCompact + Copy + Saturating + SimpleArithmetic,
@@ -584,6 +587,8 @@ pub trait SessionInterface<AccountId>: frame_system::Trait {
 	fn validators() -> Vec<AccountId>;
 	/// Prune historical session tries up to but not including the given index.
 	fn prune_historical_up_to(up_to: SessionIndex);
+	/// The current session index.
+	fn current_index() -> SessionIndex;
 }
 
 impl<T: Trait> SessionInterface<<T as frame_system::Trait>::AccountId> for T where
@@ -608,6 +613,10 @@ impl<T: Trait> SessionInterface<<T as frame_system::Trait>::AccountId> for T whe
 	fn prune_historical_up_to(up_to: SessionIndex) {
 		<pallet_session::historical::Module<T>>::prune_up_to(up_to);
 	}
+
+	fn current_index() -> SessionIndex {
+		<pallet_session::Module<T>>::current_index()
+	}
 }
 
 pub trait Trait: frame_system::Trait {
@@ -804,10 +813,18 @@ decl_storage! {
 		/// Deprecated
 		// Rewards for the current era. Using indices of current elected set.
 		CurrentEraPointsEarned: EraPoints;
-	}
-	add_extra_genesis {
-		config(stakers):
-			Vec<(T::AccountId, T::AccountId, BalanceOf<T>, StakerStatus<T::AccountId>)>;
+
+		/// Deprecated
+		// Nominators for a particular account that is in action right now. You can't iterate
+		// through validators here, but you can find them in the Session module.
+		//
+		// This is keyed by the stash account.
+		Stakers: map T::AccountId => Exposure<T::AccountId, BalanceOf<T>>;
+
+}
+add_extra_genesis {
+config(stakers):
+		Vec<(T::AccountId, T::AccountId, BalanceOf<T>, StakerStatus<T::AccountId>)>;
 		build(|config: &GenesisConfig<T>| {
 			for &(ref stash, ref controller, balance, ref status) in &config.stakers {
 				assert!(

frame/staking/src/migration.rs

@@ -24,10 +24,14 @@ pub const CURRENT_VERSION: VersionNumber = 2;
 
 #[cfg(any(test, feature = "migrate"))]
 mod inner {
-	use crate::{Store, Module, Trait};
-	use frame_support::{StorageLinkedMap, StorageValue};
+	use crate::{
+		Store, Module, Trait, EraRewardPoints, SessionInterface, BalanceOf, StakingLedger,
+		StakingLedgerV1,
+	};
+	use frame_support::{StorageLinkedMap, StorageValue, StorageMap, StorageDoubleMap, StoragePrefixedMap};
 	use sp_std::vec::Vec;
 	use super::{CURRENT_VERSION, VersionNumber};
+	use sp_runtime::traits::Zero;
 
 	// the minimum supported version of the migration logic.
 	const MIN_SUPPORTED_VERSION: VersionNumber = 0;
@@ -60,52 +64,65 @@ mod inner {
 		frame_support::print("Finished migrating Staking storage to v1.");
 	}
 
+
 	pub fn from_v1_to_v2<T: Trait>(version: &mut VersionNumber) {
 		if *version != 1 { return }
 		*version += 1;
 
 		// Fill new storages.
 
-		// TODO TODO: ActiveEra.
-		// we can't just compare current elected and T::SessionInterface::validators() because we
-		// could be in a new era while having the same set, we need to compare
-		// CurrentEraStartSessionIndex with session::current_index
-		// Or: what if you put a wrong one ?
+		// Do ActiveEra
+		let current_era_start_index = <Module<T> as Store>::CurrentEraStartSessionIndex::get();
+		let current_era = <Module<T> as Store>::CurrentEra::get();
+		let active_era = if current_era_start_index > T::SessionInterface::current_index() {
+			current_era - 1
+		} else {
+			current_era
+		};
+		<Module<T> as Store>::ActiveEra::put(active_era);
 
 		// Do ErasStakers, ErasValidatorPrefs and ErasTotalStake
-		let current_era = <Module<T> as Store>::CurrentEra::get();
-		let active_era = <Module<T> as Store>::ActiveEra::get();
-		let old_current_elected = <Module<T>>::CurrentElected::get();
-		let mut current_total_stake = 0.into();
+		let old_current_elected = <Module<T> as Store>::CurrentElected::get();
+		let mut current_total_stake = <BalanceOf<T>>::zero();
 		for validator in &old_current_elected {
-			let exposure = <Module<T> as Store>::Stakers::get(elected);
+			let exposure = <Module<T> as Store>::Stakers::get(validator);
 			current_total_stake += exposure.total;
-			let pref = <Module<T> as Store>::Validator::get(elected);
+			let pref = <Module<T> as Store>::Validators::get(validator);
 			<Module<T> as Store>::ErasStakers::insert(current_era, validator, exposure);
-			<Module<T> as Store>::ErasValidatorPrefs::insert(current_era, validator, exposure);
+			<Module<T> as Store>::ErasValidatorPrefs::insert(current_era, validator, pref);
 		}
 		<Module<T> as Store>::ErasTotalStake::insert(current_era, current_total_stake);
-		let mut active_total_stake = 0.into();
-		for validator in T::SessionInterface::validators() {
-			let exposure = <Module<T> as Store>::Stakers::get(elected);
+		let mut active_total_stake = <BalanceOf<T>>::zero();
+		for validator in &T::SessionInterface::validators() {
+			let exposure = <Module<T> as Store>::Stakers::get(validator);
 			active_total_stake += exposure.total;
-			let pref = <Module<T> as Store>::Validator::get(elected);
+			let pref = <Module<T> as Store>::Validators::get(validator);
 			<Module<T> as Store>::ErasStakers::insert(active_era, validator, exposure);
-			<Module<T> as Store>::ErasValidatorPrefs::insert(active_era, validator, exposure);
+			<Module<T> as Store>::ErasValidatorPrefs::insert(active_era, validator, pref);
 		}
 		<Module<T> as Store>::ErasTotalStake::insert(active_era, active_total_stake);
 
 		// Do ErasRewardPoints
 		let points = <Module<T> as Store>::CurrentEraPointsEarned::get();
 		<Module<T> as Store>::ErasRewardPoints::insert(active_era, EraRewardPoints {
 			total: points.total,
-			individual: current_elected.zip(points.individual).collect(),
-			// TODO TODO: this or zip with active_validators?
-		})
+			individual: old_current_elected.iter().cloned().zip(points.individual.iter().cloned()).collect(),
+		});
 
 		// Do ActiveEraStart
 		<Module<T> as Store>::ActiveEraStart::put(<Module<T> as Store>::CurrentEraStart::get());
 
+		// TODO TODO: StakingLedger
+		// let res = <Module<T> as Store>::Ledger::translate_value(
+		// 	|old: StakingLedgerV1<T::AccountId, BalanceOf<T>>| StakingLedger {
+		// 		stash: old.stash,
+		// 		total: old.total,
+		// 		active: old.active,
+		// 		unlocking: old.unlocking,
+		// 		next_reward: 0,
+		// 	}
+		// );
+
 		// Kill old storages
 		<Module<T> as Store>::SlotStake::kill();
 		<Module<T> as Store>::CurrentElected::kill();