Stash/controller model for staking

node/runtime/src/lib.rs

@@ -60,8 +60,8 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("node"),
 	impl_name: create_runtime_str!("substrate-node"),
 	authoring_version: 10,
-	spec_version: 29,
-	impl_version: 29,
+	spec_version: 35,
+	impl_version: 35,
 	apis: RUNTIME_API_VERSIONS,
 };
 

srml/aura/src/lib.rs

@@ -207,9 +207,9 @@ impl<T: Trait> OnTimestampSet<T::Moment> for Module<T> {
 /// A type for performing slashing based on aura reports.
 pub struct StakingSlasher<T>(::rstd::marker::PhantomData<T>);
 
-impl<T: staking::Trait + Trait> HandleReport for StakingSlasher<T> {
+impl<T: session::Trait + Trait> HandleReport for StakingSlasher<T> {
 	fn handle_report(report: AuraReport) {
-		let validators = staking::Module::<T>::validators();
+		let validators = session::Module::<T>::validators();
 
 		report.punish(
 			validators.len(),

srml/balances/src/lib.rs

@@ -268,34 +268,6 @@ impl<T: Trait> Module<T> {
 		}
 	}
 
-	/// Adds up to `value` to the free balance of `who`. If `who` doesn't exist, it is created.
-	///
-	/// This is a sensitive function since it circumvents any fees associated with account
-	/// setup. Ensure it is only called by trusted code.
-	///
-	/// NOTE: This assumes that the total stake remains unchanged after this operation. If
-	/// you mean to actually mint value into existence, then use `reward` instead.
-	pub fn increase_free_balance_creating(who: &T::AccountId, value: T::Balance) -> UpdateBalanceOutcome {
-		Self::set_free_balance_creating(who, Self::free_balance(who) + value)
-	}
-
-	/// Substrates `value` from the free balance of `who`. If the whole amount cannot be
-	/// deducted, an error is returned.
-	///
-	/// NOTE: This assumes that the total stake remains unchanged after this operation. If
-	/// you mean to actually burn value out of existence, then use `slash` instead.
-	pub fn decrease_free_balance(
-		who: &T::AccountId,
-		value: T::Balance
-	) -> result::Result<UpdateBalanceOutcome, &'static str> {
-		T::EnsureAccountLiquid::ensure_account_liquid(who)?;
-		let b = Self::free_balance(who);
-		if b < value {
-			return Err("account has too few funds")
-		}
-		Ok(Self::set_free_balance(who, b - value))
-	}
-
 	/// Transfer some liquid free balance to another staker.
 	pub fn make_transfer(transactor: &T::AccountId, dest: &T::AccountId, value: T::Balance) -> Result {
 		let from_balance = Self::free_balance(transactor);
@@ -316,7 +288,7 @@ impl<T: Trait> Module<T> {
 		if would_create && value < Self::existential_deposit() {
 			return Err("value too low to create account");
 		}
-		T::EnsureAccountLiquid::ensure_account_liquid(transactor)?;
+		T::EnsureAccountLiquid::ensure_account_can_transfer(transactor)?;
 
 		// NOTE: total stake being stored in the same type means that this could never overflow
 		// but better to be safe than sorry.
@@ -398,17 +370,21 @@ where
 	}
 
 	fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool {
-		if T::EnsureAccountLiquid::ensure_account_liquid(who).is_ok() {
+		if T::EnsureAccountLiquid::ensure_account_can_transfer(who).is_ok() {
 			Self::free_balance(who) >= value
 		} else {
 			false
 		}
 	}
 
-	fn total_issuance() -> Self:: Balance {
+	fn total_issuance() -> Self::Balance {
 		Self::total_issuance()
 	}
 
+	fn minimum_balance() -> Self::Balance {
+		Self::existential_deposit()
+	}
+
 	fn free_balance(who: &T::AccountId) -> Self::Balance {
 		Self::free_balance(who)
 	}
@@ -442,12 +418,24 @@ where
 		Self::set_free_balance_creating(who, Self::free_balance(who) + value)
 	}
 
+	fn decrease_free_balance(
+		who: &T::AccountId,
+		value: T::Balance
+	) -> result::Result<UpdateBalanceOutcome, &'static str> {
+		T::EnsureAccountLiquid::ensure_account_can_transfer(who)?;
+		let b = Self::free_balance(who);
+		if b < value {
+			return Err("account has too few funds")
+		}
+		Ok(Self::set_free_balance(who, b - value))
+	}
+
 	fn reserve(who: &T::AccountId, value: Self::Balance) -> result::Result<(), &'static str> {
 		let b = Self::free_balance(who);
 		if b < value {
 			return Err("not enough free funds")
 		}
-		T::EnsureAccountLiquid::ensure_account_liquid(who)?;
+		T::EnsureAccountLiquid::ensure_account_can_transfer(who)?;
 		Self::set_reserved_balance(who, Self::reserved_balance(who) + value);
 		Self::set_free_balance(who, b - value);
 		Ok(())
@@ -505,7 +493,7 @@ impl<T: Trait> TransferAsset<T::AccountId> for Module<T> {
 	}
 
 	fn remove_from(who: &T::AccountId, value: T::Balance) -> Result {
-		T::EnsureAccountLiquid::ensure_account_liquid(who)?;
+		T::EnsureAccountLiquid::ensure_account_can_transfer(who)?;
 		let b = Self::free_balance(who);
 		ensure!(b >= value, "account has too few funds");
 		Self::set_free_balance(who, b - value);

srml/contract/COMPLEXITY.md

@@ -135,10 +135,10 @@ This function performs the following steps:
 
 1. Querying source and destination balances from an overlay (see `get_balance`),
 2. Querying `existential_deposit`.
-3. Executing `ensure_account_liquid` hook.
+3. Executing `ensure_account_can_transfer` hook.
 4. Updating source and destination balance in the overlay (see `set_balance`).
 
-**Note** that the complexity of executing `ensure_account_liquid` hook should be considered separately.
+**Note** that the complexity of executing `ensure_account_can_transfer` hook should be considered separately.
 
 In the course of the execution this function can perform up to 2 DB reads to `get_balance` of source and destination accounts. It can also induce up to 2 DB writes via `set_balance` if flushed to the storage.
 

srml/contract/src/exec.rs

@@ -520,7 +520,7 @@ fn transfer<'a, T: Trait, V: Vm<T>, L: Loader<T>>(
 	if would_create && value < ctx.config.existential_deposit {
 		return Err("value too low to create account");
 	}
-	<T as balances::Trait>::EnsureAccountLiquid::ensure_account_liquid(transactor)?;
+	<T as balances::Trait>::EnsureAccountLiquid::ensure_account_can_transfer(transactor)?;
 
 	let new_to_balance = match to_balance.checked_add(&value) {
 		Some(b) => b,

srml/democracy/src/lib.rs

@@ -416,7 +416,7 @@ impl<T: Trait> OnFreeBalanceZero<T::AccountId> for Module<T> {
 }
 
 impl<T: Trait> EnsureAccountLiquid<T::AccountId> for Module<T> {
-	fn ensure_account_liquid(who: &T::AccountId) -> Result {
+	fn ensure_account_can_transfer(who: &T::AccountId) -> Result {
 		if Self::bondage(who) <= <system::Module<T>>::block_number() {
 			Ok(())
 		} else {