Merge branch 'master' into fee

srml/balances/src/lib.rs

@@ -34,7 +34,7 @@ use runtime_support::{StorageValue, StorageMap, Parameter};
 use runtime_support::traits::{UpdateBalanceOutcome, Currency, EnsureAccountLiquid, OnFreeBalanceZero};
 use runtime_support::dispatch::Result;
 use primitives::traits::{Zero, SimpleArithmetic, TransferAsset,
-	As, StaticLookup, Member, CheckedAdd, CheckedSub};
+	As, StaticLookup, Member, CheckedAdd, CheckedSub, MaybeSerializeDebug};
 use system::{IsDeadAccount, OnNewAccount, ensure_signed};
 
 mod mock;
@@ -337,6 +337,120 @@ impl<T: Trait> Module<T> {
 	}
 }
 
+impl<T: Trait> Currency<T::AccountId> for Module<T>
+where
+	T::Balance: MaybeSerializeDebug
+{
+	type Balance = T::Balance;
+
+	fn total_balance(who: &T::AccountId) -> Self::Balance {
+		Self::free_balance(who) + Self::reserved_balance(who)
+	}
+
+	fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool {
+		Self::free_balance(who) >= value
+	}
+
+	fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool {
+		if T::EnsureAccountLiquid::ensure_account_liquid(who).is_ok() {
+			Self::free_balance(who) >= value
+		} else {
+			false
+		}
+	}
+
+	fn total_issuance() -> Self:: Balance {
+		Self::total_issuance()
+	}
+
+	fn free_balance(who: &T::AccountId) -> Self::Balance {
+		Self::free_balance(who)
+	}
+
+	fn reserved_balance(who: &T::AccountId) -> Self::Balance {
+		Self::reserved_balance(who)
+	}
+
+	fn slash(who: &T::AccountId, value: Self::Balance) -> Option<Self::Balance> {
+		let free_balance = Self::free_balance(who);
+		let free_slash = cmp::min(free_balance, value);
+		Self::set_free_balance(who, free_balance - free_slash);
+		Self::decrease_total_stake_by(free_slash);
+		if free_slash < value {
+			Self::slash_reserved(who, value - free_slash)
+		} else {
+			None
+		}
+	}
+
+	fn reward(who: &T::AccountId, value: Self::Balance) -> result::Result<(), &'static str> {
+		if Self::total_balance(who).is_zero() {
+			return Err("beneficiary account must pre-exist");
+		}
+		Self::set_free_balance(who, Self::free_balance(who) + value);
+		Self::increase_total_stake_by(value);
+		Ok(())
+	}
+
+	fn increase_free_balance_creating(who: &T::AccountId, value: Self::Balance) -> UpdateBalanceOutcome {
+		Self::set_free_balance_creating(who, Self::free_balance(who) + 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)?;
+		Self::set_reserved_balance(who, Self::reserved_balance(who) + value);
+		Self::set_free_balance(who, b - value);
+		Ok(())
+	}
+
+	fn unreserve(who: &T::AccountId, value: Self::Balance) -> Option<Self::Balance> {
+		let b = Self::reserved_balance(who);
+		let actual = cmp::min(b, value);
+		Self::set_free_balance(who, Self::free_balance(who) + actual);
+		Self::set_reserved_balance(who, b - actual);
+		if actual == value {
+			None
+		} else {
+			Some(value - actual)
+		}
+	}
+
+	fn slash_reserved(who: &T::AccountId, value: Self::Balance) -> Option<Self::Balance> {
+		let b = Self::reserved_balance(who);
+		let slash = cmp::min(b, value);
+		Self::set_reserved_balance(who, b - slash);
+		Self::decrease_total_stake_by(slash);
+		if value == slash {
+			None
+		} else {
+			Some(value - slash)
+		}
+	}
+
+	fn repatriate_reserved(
+		slashed: &T::AccountId,
+		beneficiary: &T::AccountId,
+		value: Self::Balance
+	) -> result::Result<Option<Self::Balance>, &'static str> {
+		if Self::total_balance(beneficiary).is_zero() {
+			return Err("beneficiary account must pre-exist");
+		}
+		let b = Self::reserved_balance(slashed);
+		let slash = cmp::min(b, value);
+		Self::set_free_balance(beneficiary, Self::free_balance(beneficiary) + slash);
+		Self::set_reserved_balance(slashed, b - slash);
+		if value == slash {
+			Ok(None)
+		} else {
+			Ok(Some(value - slash))
+		}
+	}
+}
+
 impl<T: Trait> TransferAsset<T::AccountId> for Module<T> {
 	type Amount = T::Balance;
 

srml/executive/src/lib.rs

@@ -46,7 +46,7 @@ use rstd::prelude::*;
 use rstd::marker::PhantomData;
 use rstd::result;
 use primitives::traits::{self, Header, Zero, One, Checkable, Applyable, CheckEqual, OnFinalise,
-	ChargeBytesFee, Hash, As, Digest};
+	OnInitialise, ChargeBytesFee, Hash, As, Digest};
 use runtime_support::Dispatchable;
 use codec::{Codec, Encode};
 use system::extrinsics_root;
@@ -83,8 +83,8 @@ impl<
 	System: system::Trait,
 	Block: traits::Block<Header=System::Header, Hash=System::Hash>,
 	Payment: ChargeBytesFee<System::AccountId>,
-	Finalisation: OnFinalise<System::BlockNumber>,
-> Executive<System, Block, Context, Payment, Finalisation> where
+	AllModules: OnInitialise<System::BlockNumber> + OnFinalise<System::BlockNumber>,
+> Executive<System, Block, Context, Payment, AllModules> where
 	Block::Extrinsic: Checkable<Context> + Codec,
 	<Block::Extrinsic as Checkable<Context>>::Checked: Applyable<Index=System::Index, AccountId=System::AccountId>,
 	<<Block::Extrinsic as Checkable<Context>>::Checked as Applyable>::Call: Dispatchable,