Transfers work!

substrate/runtime/contract/src/account_db.rs

@@ -15,6 +15,7 @@
 // along with Substrate. If not, see <http://www.gnu.org/licenses/>.
 
 use super::{Trait, StorageOf, CodeOf};
+use staking;
 use system;
 use double_map::StorageDoubleMap;
 use runtime_support::StorageMap;
@@ -57,15 +58,16 @@ impl<T: Trait> AccountDb<T> for DirectAccountDb {
 	fn get_code(&self, account: &T::AccountId) -> Vec<u8> {
 		<CodeOf<T>>::get(account)
 	}
-	fn get_balance(&self, _account: &T::AccountId) -> T::Balance {
-		// TODO:
-		panic!()
+	fn get_balance(&self, account: &T::AccountId) -> T::Balance {
+		staking::Module::<T>::free_balance(account)
 	}
 	fn commit(&mut self, s: ChangeSet<T>) {
 		for (address, changed) in s.into_iter() {
-			if let Some(_balance) = changed.balance {
-				// TODO:
-				panic!()
+			if let Some(balance) = changed.balance {
+				let still_alive = staking::Module::<T>::commit_free_balance(&address, balance);
+				if !still_alive {
+					continue
+				}
 			}
 			if let Some(code) = changed.code {
 				<CodeOf<T>>::insert(&address, &code);
@@ -152,9 +154,7 @@ impl<'a, T: Trait> AccountDb<T> for OverlayAccountDb<'a, T> {
 				Entry::Occupied(e) => {
 					let mut value = e.into_mut();
 					if changed.balance.is_some() {
-						// TODO:
-						panic!();
-						// value.balance = changed.balance;
+						value.balance = changed.balance;
 					}
 					if changed.code.is_some() {
 						value.code = changed.code;

substrate/runtime/contract/src/exec.rs

@@ -17,7 +17,10 @@
 use super::{CodeOf, ContractAddressFor, Trait};
 use account_db::{AccountDb, ChangeSet, OverlayAccountDb};
 use rstd::prelude::*;
+use runtime_primitives::traits::Zero;
 use runtime_support::StorageMap;
+use staking;
+use system;
 use vm;
 
 //pub struct TransactionData {
@@ -48,7 +51,7 @@ impl<'a, 'b: 'a, T: Trait> ExecutionContext<'a, 'b, T> {
 	pub fn call(
 		&mut self,
 		dest: T::AccountId,
-		_value: T::Balance,
+		value: T::Balance,
 		gas_limit: u64,
 		_data: Vec<u8>,
 	) -> Result<vm::ExecutionResult, ()> {
@@ -57,9 +60,13 @@ impl<'a, 'b: 'a, T: Trait> ExecutionContext<'a, 'b, T> {
 		// TODO: transfer `_value` using `overlay`. Return an error if failed.
 		// TODO: check the new depth
 
-		let (exec_result, change_set) = if !dest_code.is_empty() {
+		let (exec_result, change_set) = {
 			let mut overlay = OverlayAccountDb::new(self.account_db);
-			let exec_result = {
+
+			// TODO: It would be nice to propogate the error.
+			transfer(&self.self_account, &dest, value, &mut overlay).map_err(|_| ())?;
+
+			let exec_result = if !dest_code.is_empty() {
 				let mut nested = ExecutionContext {
 					account_db: &mut overlay,
 					_caller: self.self_account.clone(),
@@ -68,21 +75,18 @@ impl<'a, 'b: 'a, T: Trait> ExecutionContext<'a, 'b, T> {
 					depth: self.depth + 1,
 				};
 				vm::execute(&dest_code, &mut nested, gas_limit).map_err(|_| ())?
-			};
 
 			// TODO: Need to propagate gas_left.
 			// TODO: Need to return result buffer.
-
-			(exec_result, overlay.into_change_set())
-		} else {
-			// that was a plain transfer
-			(
+			} else {
+				// that was a plain transfer
 				vm::ExecutionResult {
 					gas_left: gas_limit,
 					return_data: Vec::new(),
-				},
-				ChangeSet::new(),
-			)
+				}
+			};
+
+			(exec_result, overlay.into_change_set())
 		};
 
 		self.account_db.commit(change_set);
@@ -132,6 +136,44 @@ impl<'a, 'b: 'a, T: Trait> ExecutionContext<'a, 'b, T> {
 	}
 }
 
+fn transfer<T: Trait>(
+	transactor: &T::AccountId,
+	dest: &T::AccountId,
+	value: T::Balance,
+	overlay: &mut OverlayAccountDb<T>,
+) -> Result<(), &'static str> {
+	let would_create = overlay.get_balance(transactor).is_zero();
+	let fee = if would_create {
+		<staking::Module<T>>::creation_fee()
+	} else {
+		<staking::Module<T>>::transfer_fee()
+	};
+	let liability = value + fee;
+
+	let from_balance = overlay.get_balance(transactor);
+	if from_balance < liability {
+		return Err("balance too low to send value");
+	}
+	if would_create && value < <staking::Module<T>>::existential_deposit() {
+		return Err("value too low to create account");
+	}
+	if <staking::Module<T>>::bondage(transactor) > <system::Module<T>>::block_number() {
+		return Err("bondage too high to send value");
+	}
+
+	let to_balance = overlay.get_balance(dest);
+	if to_balance + value <= to_balance {
+		return Err("destination balance too high to receive value");
+	}
+
+	if transactor != dest {
+		overlay.set_balance(transactor, from_balance - liability);
+		overlay.set_balance(dest, to_balance + value);
+	}
+
+	Ok(())
+}
+
 impl<'a, 'b: 'a, T: Trait + 'b> vm::Ext for ExecutionContext<'a, 'b, T> {
 	type AccountId = T::AccountId;
 	type Balance = T::Balance;

substrate/runtime/contract/src/lib.rs

@@ -66,7 +66,7 @@ pub use vm::Ext;
 
 use exec::ExecutionContext;
 
-use account_db::OverlayAccountDb;
+use account_db::{AccountDb, DirectAccountDb, OverlayAccountDb};
 
 use runtime_primitives::traits::RefInto;
 use runtime_support::dispatch::Result;
@@ -147,18 +147,23 @@ impl<T: Trait> Module<T> {
 
 		let mut overlay = OverlayAccountDb::<T>::new(&account_db::DirectAccountDb);
 
-		let mut ctx = ExecutionContext {
-			// TODO: fuck
-			_caller: aux.clone(),
-			self_account: aux.clone(),
-			gas_price,
-			depth: 0,
-			account_db: &mut overlay,
+		let result = {
+			let mut ctx = ExecutionContext {
+				// TODO: fuck
+				_caller: aux.clone(),
+				self_account: aux.clone(),
+				gas_price,
+				depth: 0,
+				account_db: &mut overlay,
+			};
+			ctx.call(dest, value, gas_limit, data).map_err(|_| "execution failed")
 		};
-		let result = ctx.call(dest, value, gas_limit, data).map_err(|_| "execution failed");
 
+		// TODO: Can we return early or we always need to do some finalization steps?
 		result?;
 
+		account_db::DirectAccountDb.commit(overlay.into_change_set());
+
 		// TODO: commit changes from `overlay` to DirectAccountDb.
 		// TODO: finalization: refund `gas_left`.
 

substrate/runtime/staking/src/lib.rs

@@ -438,6 +438,38 @@ impl<T: Trait> Module<T> {
 		}
 	}
 
+	/// TODO: Document
+	pub fn commit_free_balance(who: &T::AccountId, balance: T::Balance) -> bool {
+		let ed = <Module<T>>::existential_deposit();
+		// If the balance is too low, then the account is reaped.
+		// NOTE: There are two balances for every account: `reserved_balance` and
+		// `free_balance`. This contract subsystem only cares about the latter: whenever
+		// the term "balance" is used *here* it should be assumed to mean "free balance"
+		// in the rest of the module.
+		// Free balance can never be less than ED. If that happens, it gets reduced to zero
+		// and the account information relevant to this subsystem is deleted (i.e. the
+		// account is reaped).
+		// NOTE: This is orthogonal to the `Bondage` value that an account has, a high
+		// value of which makes even the `free_balance` unspendable.
+		// TODO: enforce this for the other balance-altering functions.
+		if balance < ed {
+			Self::on_free_too_low(who);
+			false
+		} else {
+			if !<FreeBalance<T>>::exists(who) {
+				let outcome = Self::new_account(&who, balance);
+				let credit = match outcome {
+					NewAccountOutcome::GoodHint => balance + <Module<T>>::reclaim_rebate(),
+					_ => balance,
+				};
+				<FreeBalance<T>>::insert(who, credit);
+			} else {
+				<FreeBalance<T>>::insert(who, balance);
+			}
+			true
+		}
+	}
+
 	/// Deducts up to `value` from the combined balance of `who`, preferring to deduct from the
 	/// free balance. This function cannot fail.
 	///