Merge branch 'master' into light-poa

ethcore/src/engines/authority_round/mod.rs

@@ -31,7 +31,6 @@ use error::{Error, TransactionError, BlockError};
 use ethjson;
 use header::{Header, BlockNumber};
 use spec::CommonParams;
-use state::CleanupMode;
 use transaction::UnverifiedTransaction;
 
 use super::signer::EngineSigner;
@@ -522,7 +521,9 @@ impl Engine for AuthorityRound {
 		let parent_hash = block.fields().header.parent_hash().clone();
 		::engines::common::push_last_hash(block, last_hashes.clone(), self, &parent_hash)?;
 
-		if !epoch_begin { return Ok(()) }
+		// with immediate transitions, we don't use the epoch mechanism anyway.
+		// the genesis is always considered an epoch, but we ignore it intentionally.
+		if self.immediate_transitions || !epoch_begin { return Ok(()) }
 
 		// genesis is never a new block, but might as well check.
 		let header = block.fields().header.clone();
@@ -546,17 +547,7 @@ impl Engine for AuthorityRound {
 
 	/// Apply the block reward on finalisation of the block.
 	fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
-		let fields = block.fields_mut();
-		// Bestow block reward
-		let reward = self.params().block_reward;
-		let res = fields.state.add_balance(fields.header.author(), &reward, CleanupMode::NoEmpty)
-			.map_err(::error::Error::from)
-			.and_then(|_| fields.state.commit());
-		// Commit state so that we can actually figure out the state root.
-		if let Err(ref e) = res {
-			warn!("Encountered error on closing block: {}", e);
-		}
-		res
+		::engines::common::bestow_block_reward(block, self)
 	}
 
 	/// Check the number of seal fields.

ethcore/src/engines/mod.rs

@@ -409,8 +409,9 @@ pub mod common {
 	use transaction::SYSTEM_ADDRESS;
 	use executive::Executive;
 	use vm::{CallType, ActionParams, ActionValue, EnvInfo, LastHashes};
-	use trace::{NoopTracer, NoopVMTracer};
+	use trace::{NoopTracer, NoopVMTracer, Tracer, ExecutiveTracer, RewardType};
 	use state::Substate;
+	use state::CleanupMode;
 
 	use util::*;
 	use super::Engine;
@@ -479,4 +480,27 @@ pub mod common {
 		}
 		Ok(())
 	}
+
+	/// Trace rewards on closing block
+	pub fn bestow_block_reward<E: Engine + ?Sized>(block: &mut ExecutedBlock, engine: &E) -> Result<(), Error> {
+		let fields = block.fields_mut();
+		// Bestow block reward
+		let reward = engine.params().block_reward;
+		let res = fields.state.add_balance(fields.header.author(), &reward, CleanupMode::NoEmpty)
+			.map_err(::error::Error::from)
+			.and_then(|_| fields.state.commit());
+
+		let block_author = fields.header.author().clone();
+		fields.traces.as_mut().map(|mut traces| {
+  			let mut tracer = ExecutiveTracer::default();
+  			tracer.trace_reward(block_author, engine.params().block_reward, RewardType::Block);
+  			traces.push(tracer.drain())
+		});
+
+		// Commit state so that we can actually figure out the state root.
+		if let Err(ref e) = res {
+			warn!("Encountered error on bestowing reward: {}", e);
+		}
+		res
+	}
 }

ethcore/src/engines/null_engine.rs

@@ -17,10 +17,15 @@
 use std::collections::BTreeMap;
 use util::Address;
 use builtin::Builtin;
+use block::{ExecutedBlock, IsBlock};
+use util::U256;
 use engines::Engine;
 use spec::CommonParams;
 use evm::Schedule;
 use header::BlockNumber;
+use error::Error;
+use state::CleanupMode;
+use trace::{Tracer, ExecutiveTracer, RewardType};
 
 /// An engine which does not provide any consensus mechanism and does not seal blocks.
 pub struct NullEngine {
@@ -64,4 +69,48 @@ impl Engine for NullEngine {
 	fn snapshot_components(&self) -> Option<Box<::snapshot::SnapshotComponents>> {
 		Some(Box::new(::snapshot::PowSnapshot::new(10000, 10000)))
 	}
+
+	fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
+		if self.params.block_reward == U256::zero() {
+			// we don't have to apply reward in this case
+			return Ok(())
+		}
+
+		/// Block reward
+		let tracing_enabled = block.tracing_enabled();
+		let fields = block.fields_mut();
+		let mut tracer = ExecutiveTracer::default();
+
+		let result_block_reward = U256::from(1000000000);
+		fields.state.add_balance(
+			fields.header.author(),
+			&result_block_reward,
+			CleanupMode::NoEmpty
+		)?;
+
+		if tracing_enabled {
+			let block_author = fields.header.author().clone();
+			tracer.trace_reward(block_author, result_block_reward, RewardType::Block);
+		}
+
+		/// Uncle rewards
+		let result_uncle_reward = U256::from(10000000);
+		for u in fields.uncles.iter() {
+			let uncle_author = u.author().clone();
+			fields.state.add_balance(
+				u.author(),
+				&(result_uncle_reward),
+				CleanupMode::NoEmpty
+			)?;
+			if tracing_enabled {
+				tracer.trace_reward(uncle_author, result_uncle_reward, RewardType::Uncle);
+			}
+		}
+
+		fields.state.commit()?;
+		if tracing_enabled {
+			fields.traces.as_mut().map(|mut traces| traces.push(tracer.drain()));
+		}
+		Ok(())
+	}
 }

ethcore/src/engines/tendermint/mod.rs

@@ -40,7 +40,6 @@ use account_provider::AccountProvider;
 use block::*;
 use spec::CommonParams;
 use engines::{Engine, Seal, EngineError, ConstructedVerifier};
-use state::CleanupMode;
 use io::IoService;
 use super::signer::EngineSigner;
 use super::validator_set::{ValidatorSet, SimpleList};
@@ -541,17 +540,7 @@ impl Engine for Tendermint {
 
 	/// Apply the block reward on finalisation of the block.
 	fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error>{
-		let fields = block.fields_mut();
-		// Bestow block reward
-		let reward = self.params().block_reward;
-		let res = fields.state.add_balance(fields.header.author(), &reward, CleanupMode::NoEmpty)
-			.map_err(::error::Error::from)
-			.and_then(|_| fields.state.commit());
-		// Commit state so that we can actually figure out the state root.
-		if let Err(ref e) = res {
-			warn!("Encountered error on closing block: {}", e);
-		}
-		res
+		::engines::common::bestow_block_reward(block, self)
 	}
 
 	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {

ethcore/src/engines/validator_set/simple_list.rs

@@ -16,7 +16,8 @@
 
 /// Preconfigured validator list.
 
-use util::{H256, Address, HeapSizeOf};
+use heapsize::HeapSizeOf;
+use util::{H256, Address};
 
 use engines::{Call, Engine};
 use header::{BlockNumber, Header};

ethcore/src/engines/validator_set/test.rs

@@ -19,7 +19,8 @@
 use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
-use util::{Bytes, H256, Address, HeapSizeOf};
+use heapsize::HeapSizeOf;
+use util::{Bytes, H256, Address};
 
 use engines::{Call, Engine};
 use header::{Header, BlockNumber};