From 83b8e7df5a6f4bdee8e0ddc208fe44029d4a2517 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Mon, 29 Feb 2016 14:57:41 +0100
Subject: [PATCH 01/37] Initial refactor and block closing.

---
 ethcore/src/block.rs  | 53 +++++++++++++++++++------------------------
 ethcore/src/client.rs | 39 +++++++++++++++++++++++++++----
 ethcore/src/header.rs |  2 +-
 parity/main.rs        |  1 -
 4 files changed, 59 insertions(+), 36 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index 70c6c2fb2..28005b17e 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -155,9 +155,9 @@ pub struct OpenBlock<'x> {
 /// Just like OpenBlock, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
 /// and collected the uncles.
 ///
-/// There is no function available to push a transaction. If you want that you'll need to `reopen()` it.
-pub struct ClosedBlock<'x> {
-	open_block: OpenBlock<'x>,
+/// There is no function available to push a transaction.
+pub struct ClosedBlock {
+	block: ExecutedBlock,
 	uncle_bytes: Bytes,
 }
 
@@ -181,7 +181,7 @@ impl<'x> OpenBlock<'x> {
 		r.block.base.header.set_number(parent.number() + 1);
 		r.block.base.header.set_author(author);
 		r.block.base.header.set_extra_data(extra_data);
-		r.block.base.header.set_timestamp_now();
+		r.block.base.header.set_timestamp_now(parent.timestamp());
 
 		engine.populate_from_parent(&mut r.block.base.header, parent);
 		engine.on_new_block(&mut r.block);
@@ -259,7 +259,7 @@ impl<'x> OpenBlock<'x> {
 	}
 
 	/// Turn this into a `ClosedBlock`. A BlockChain must be provided in order to figure out the uncles.
-	pub fn close(self) -> ClosedBlock<'x> {
+	pub fn close(self) -> ClosedBlock {
 		let mut s = self;
 		s.engine.on_close_block(&mut s.block);
 		s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes().to_vec()).collect());
@@ -271,7 +271,10 @@ impl<'x> OpenBlock<'x> {
 		s.block.base.header.gas_used = s.block.receipts.last().map_or(U256::zero(), |r| r.gas_used);
 		s.block.base.header.note_dirty();
 
-		ClosedBlock::new(s, uncle_bytes)
+		ClosedBlock {
+			block: s.block, 
+			uncle_bytes: uncle_bytes,
+		}
 	}
 }
 
@@ -279,38 +282,28 @@ impl<'x> IsBlock for OpenBlock<'x> {
 	fn block(&self) -> &ExecutedBlock { &self.block }
 }
 
-impl<'x> IsBlock for ClosedBlock<'x> {
-	fn block(&self) -> &ExecutedBlock { &self.open_block.block }
+impl<'x> IsBlock for ClosedBlock {
+	fn block(&self) -> &ExecutedBlock { &self.block }
 }
 
-impl<'x> ClosedBlock<'x> {
-	fn new(open_block: OpenBlock<'x>, uncle_bytes: Bytes) -> Self {
-		ClosedBlock {
-			open_block: open_block,
-			uncle_bytes: uncle_bytes,
-		}
-	}
-
+impl ClosedBlock {
 	/// Get the hash of the header without seal arguments.
 	pub fn hash(&self) -> H256 { self.header().rlp_sha3(Seal::Without) }
 
 	/// Provide a valid seal in order to turn this into a `SealedBlock`.
 	///
 	/// NOTE: This does not check the validity of `seal` with the engine.
-	pub fn seal(self, seal: Vec<Bytes>) -> Result<SealedBlock, BlockError> {
+	pub fn seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, BlockError> {
 		let mut s = self;
-		if seal.len() != s.open_block.engine.seal_fields() {
-			return Err(BlockError::InvalidSealArity(Mismatch{expected: s.open_block.engine.seal_fields(), found: seal.len()}));
+		if seal.len() != engine.seal_fields() {
+			return Err(BlockError::InvalidSealArity(Mismatch{expected: engine.seal_fields(), found: seal.len()}));
 		}
-		s.open_block.block.base.header.set_seal(seal);
-		Ok(SealedBlock { block: s.open_block.block, uncle_bytes: s.uncle_bytes })
+		s.block.base.header.set_seal(seal);
+		Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes })
 	}
 
-	/// Turn this back into an `OpenBlock`.
-	pub fn reopen(self) -> OpenBlock<'x> { self.open_block }
-
 	/// Drop this object and return the underlieing database.
-	pub fn drain(self) -> JournalDB { self.open_block.block.state.drop().1 }
+	pub fn drain(self) -> JournalDB { self.block.state.drop().1 }
 }
 
 impl SealedBlock {
@@ -332,7 +325,7 @@ impl IsBlock for SealedBlock {
 }
 
 /// Enact the block given by block header, transactions and uncles
-pub fn enact<'x>(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock<'x>, Error> {
+pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	{
 		if ::log::max_log_level() >= ::log::LogLevel::Trace {
 			let s = State::from_existing(db.clone(), parent.state_root().clone(), engine.account_start_nonce());
@@ -350,14 +343,14 @@ pub fn enact<'x>(header: &Header, transactions: &[SignedTransaction], uncles: &[
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_bytes<'x>(block_bytes: &[u8], engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock<'x>, Error> {
+pub fn enact_bytes(block_bytes: &[u8], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	let block = BlockView::new(block_bytes);
 	let header = block.header();
 	enact(&header, &block.transactions(), &block.uncles(), engine, db, parent, last_hashes)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_verified<'x>(block: &PreVerifiedBlock, engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock<'x>, Error> {
+pub fn enact_verified(block: &PreVerifiedBlock, engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	let view = BlockView::new(&block.bytes);
 	enact(&block.header, &block.transactions, &view.uncles(), engine, db, parent, last_hashes)
 }
@@ -365,7 +358,7 @@ pub fn enact_verified<'x>(block: &PreVerifiedBlock, engine: &'x Engine, db: Jour
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
 pub fn enact_and_seal(block_bytes: &[u8], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<SealedBlock, Error> {
 	let header = BlockView::new(block_bytes).header_view();
-	Ok(try!(try!(enact_bytes(block_bytes, engine, db, parent, last_hashes)).seal(header.seal())))
+	Ok(try!(try!(enact_bytes(block_bytes, engine, db, parent, last_hashes)).seal(engine, header.seal())))
 }
 
 #[cfg(test)]
@@ -386,7 +379,7 @@ mod tests {
 		let last_hashes = vec![genesis_header.hash()];
 		let b = OpenBlock::new(engine.deref(), db, &genesis_header, last_hashes, Address::zero(), vec![]);
 		let b = b.close();
-		let _ = b.seal(vec![]);
+		let _ = b.seal(engine.deref(), vec![]);
 	}
 
 	#[test]
diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index 5d71eed84..c378fa449 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -193,6 +193,9 @@ pub struct Client {
 	report: RwLock<ClientReport>,
 	import_lock: Mutex<()>,
 	panic_handler: Arc<PanicHandler>,
+
+	// for sealing...
+	_sealing_block: Mutex<Option<ClosedBlock>>,
 }
 
 const HISTORY: u64 = 1000;
@@ -228,7 +231,8 @@ impl Client {
 			block_queue: RwLock::new(block_queue),
 			report: RwLock::new(Default::default()),
 			import_lock: Mutex::new(()),
-			panic_handler: panic_handler
+			panic_handler: panic_handler,
+			_sealing_block: Mutex::new(None),
 		}))
 	}
 
@@ -237,10 +241,10 @@ impl Client {
 		self.block_queue.write().unwrap().flush();
 	}
 
-	fn build_last_hashes(&self, header: &Header) -> LastHashes {
+	fn build_last_hashes(&self, parent_hash: H256) -> LastHashes {
 		let mut last_hashes = LastHashes::new();
 		last_hashes.resize(256, H256::new());
-		last_hashes[0] = header.parent_hash.clone();
+		last_hashes[0] = parent_hash;
 		let chain = self.chain.read().unwrap();
 		for i in 0..255 {
 			match chain.block_details(&last_hashes[i]) {
@@ -273,7 +277,7 @@ impl Client {
 
 		// Enact Verified Block
 		let parent = chain_has_parent.unwrap();
-		let last_hashes = self.build_last_hashes(header);
+		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().clone();
 
 		let enact_result = enact_verified(&block, engine, db, &parent, last_hashes);
@@ -302,6 +306,8 @@ impl Client {
 		let _import_lock = self.import_lock.lock();
 		let blocks = self.block_queue.write().unwrap().drain(max_blocks_to_import);
 
+		let original_best = self.chain_info().best_block_hash;
+
 		for block in blocks {
 			let header = &block.header;
 
@@ -357,6 +363,10 @@ impl Client {
 			}
 		}
 
+		if self.chain_info().best_block_hash != original_best {
+			self.new_chain_head();
+		}
+
 		imported
 	}
 
@@ -403,8 +413,29 @@ impl Client {
 			BlockId::Latest => Some(self.chain.read().unwrap().best_block_number())
 		}
 	}
+
+	/// New chain head event.
+	pub fn new_chain_head(&self) {
+		let h = self.chain.read().unwrap().best_block_hash();
+		info!("NEW CHAIN HEAD: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
+
+		info!("Preparing to seal.");
+		let b = OpenBlock::new(
+			&self.engine,
+			self.state_db.lock(),
+			self.chain.read().unwrap().block_header(&h).unwrap_or_else(|| {return;}),
+			self.build_last_hashes(h.clone()),
+			x!("0037a6b811ffeb6e072da21179d11b1406371c63"),
+			b"Parity".to_owned()
+		);
+		let b = b.close();
+		info!("Sealed: hash={}, diff={}, number={}", b.hash(), b.block().difficulty(), b.block().number());
+		*self._sealing_block.lock().unwrap() = Some(b);
+	}
 }
 
+// TODO: need MinerService MinerIoHandler
+
 impl BlockChainClient for Client {
 	fn block_header(&self, id: BlockId) -> Option<Bytes> {
 		let chain = self.chain.read().unwrap();
diff --git a/ethcore/src/header.rs b/ethcore/src/header.rs
index 6ee682544..3db0be5ff 100644
--- a/ethcore/src/header.rs
+++ b/ethcore/src/header.rs
@@ -131,7 +131,7 @@ impl Header {
 	/// Set the timestamp field of the header.
 	pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
 	/// Set the timestamp field of the header to the current time.
-	pub fn set_timestamp_now(&mut self) { self.timestamp = now_utc().to_timespec().sec as u64; self.note_dirty(); }
+	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = max(now_utc().to_timespec().sec as u64, but_later_than + 1); self.note_dirty(); }
 	/// Set the author field of the header.
 	pub fn set_author(&mut self, a: Address) { if a != self.author { self.author = a; self.note_dirty(); } }
 
diff --git a/parity/main.rs b/parity/main.rs
index 6415dfc33..ff86b1663 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -354,7 +354,6 @@ impl Default for Informant {
 }
 
 impl Informant {
-
 	fn format_bytes(b: usize) -> String {
 		match binary_prefix(b as f64) {
 			Standalone(bytes)   => format!("{} bytes", bytes),

From e20858a5dc048c06bac6d3e744979e9fc3ff1639 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Mon, 29 Feb 2016 15:30:08 +0100
Subject: [PATCH 02/37] Compile fixes.

---
 ethcore/src/client.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index c378fa449..a4ef970a5 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -21,7 +21,7 @@ use util::panics::*;
 use blockchain::{BlockChain, BlockProvider};
 use views::BlockView;
 use error::*;
-use header::{BlockNumber, Header};
+use header::{BlockNumber};
 use state::State;
 use spec::Spec;
 use engine::Engine;
@@ -421,15 +421,15 @@ impl Client {
 
 		info!("Preparing to seal.");
 		let b = OpenBlock::new(
-			&self.engine,
-			self.state_db.lock(),
-			self.chain.read().unwrap().block_header(&h).unwrap_or_else(|| {return;}),
+			self.engine.deref().deref(),
+			self.state_db.lock().unwrap().clone(),
+			match self.chain.read().unwrap().block_header(&h) { Some(ref x) => x, None => {return;} },
 			self.build_last_hashes(h.clone()),
 			x!("0037a6b811ffeb6e072da21179d11b1406371c63"),
-			b"Parity".to_owned()
+			b"Parity".to_vec()
 		);
 		let b = b.close();
-		info!("Sealed: hash={}, diff={}, number={}", b.hash(), b.block().difficulty(), b.block().number());
+		info!("Sealed: hash={}, diff={}, number={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
 		*self._sealing_block.lock().unwrap() = Some(b);
 	}
 }

From ffc5c2ea7bf5747acbbc87dca25e37943312d771 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Mon, 29 Feb 2016 19:30:13 +0100
Subject: [PATCH 03/37] eth_getwork implemented.

---
 Cargo.lock                     |  1 +
 ethash/src/compute.rs          |  3 ++-
 ethash/src/lib.rs              |  4 ++--
 ethcore/src/client.rs          | 13 +++++++------
 ethcore/src/ethereum/ethash.rs | 14 ++++++++++----
 rpc/Cargo.toml                 |  1 +
 rpc/src/v1/impls/eth.rs        | 27 +++++++++++++++++++++++++++
 util/src/misc.rs               |  2 +-
 util/src/uint.rs               | 27 +++++++++++++++++++++++++++
 9 files changed, 78 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bca236813..9c225dbbe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -203,6 +203,7 @@ name = "ethcore-rpc"
 version = "0.9.99"
 dependencies = [
  "clippy 0.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethash 0.9.99",
  "ethcore 0.9.99",
  "ethcore-util 0.9.99",
  "ethsync 0.9.99",
diff --git a/ethash/src/compute.rs b/ethash/src/compute.rs
index 6c311993b..eb64151d0 100644
--- a/ethash/src/compute.rs
+++ b/ethash/src/compute.rs
@@ -172,7 +172,8 @@ fn get_data_size(block_number: u64) -> usize {
 }
 
 #[inline]
-fn get_seedhash(block_number: u64) -> H256 {
+/// Given the `block_number`, determine the seed hash for Ethash.
+pub fn get_seedhash(block_number: u64) -> H256 {
 	let epochs = block_number / ETHASH_EPOCH_LENGTH;
 	let mut ret: H256 = [0u8; 32];
 	for _ in 0..epochs {
diff --git a/ethash/src/lib.rs b/ethash/src/lib.rs
index e96b98b81..982f7129b 100644
--- a/ethash/src/lib.rs
+++ b/ethash/src/lib.rs
@@ -24,7 +24,7 @@ mod compute;
 
 use std::mem;
 use compute::Light;
-pub use compute::{quick_get_difficulty, H256, ProofOfWork, ETHASH_EPOCH_LENGTH};
+pub use compute::{get_seedhash, quick_get_difficulty, H256, ProofOfWork, ETHASH_EPOCH_LENGTH};
 
 use std::sync::{Arc, Mutex};
 
@@ -35,7 +35,7 @@ struct LightCache {
 	prev: Option<Arc<Light>>,
 }
 
-/// Lighy/Full cache manager
+/// Light/Full cache manager.
 pub struct EthashManager {
 	cache: Mutex<LightCache>,
 }
diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index d81507d25..f634579ad 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -195,7 +195,7 @@ pub struct Client {
 	panic_handler: Arc<PanicHandler>,
 
 	// for sealing...
-	_sealing_block: Mutex<Option<ClosedBlock>>,
+	sealing_block: Mutex<Option<ClosedBlock>>,
 }
 
 const HISTORY: u64 = 1000;
@@ -232,7 +232,7 @@ impl Client {
 			report: RwLock::new(Default::default()),
 			import_lock: Mutex::new(()),
 			panic_handler: panic_handler,
-			_sealing_block: Mutex::new(None),
+			sealing_block: Mutex::new(None),
 		}))
 	}
 
@@ -417,9 +417,7 @@ impl Client {
 	/// New chain head event.
 	pub fn new_chain_head(&self) {
 		let h = self.chain.read().unwrap().best_block_hash();
-		info!("NEW CHAIN HEAD: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
-
-		info!("Preparing to seal.");
+		info!("New best block: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
 		let b = OpenBlock::new(
 			self.engine.deref().deref(),
 			self.state_db.lock().unwrap().clone(),
@@ -430,8 +428,11 @@ impl Client {
 		);
 		let b = b.close();
 		info!("Sealed: hash={}, diff={}, number={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
-		*self._sealing_block.lock().unwrap() = Some(b);
+		*self.sealing_block.lock().unwrap() = Some(b);
 	}
+
+	/// Grab the `ClosedBlock` that we want to be sealed. Comes as a mutex that you have to lock.
+	pub fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>> { &self.sealing_block }
 }
 
 // TODO: need MinerService MinerIoHandler
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index 54f02524d..4f1ef1ce3 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -144,9 +144,9 @@ impl Engine for Ethash {
 		}
 
 		let difficulty = Ethash::boundary_to_difficulty(&Ethash::from_ethash(quick_get_difficulty(
-				&Ethash::to_ethash(header.bare_hash()),
-				header.nonce().low_u64(),
-				&Ethash::to_ethash(header.mix_hash()))));
+			&Ethash::to_ethash(header.bare_hash()),
+			header.nonce().low_u64(),
+			&Ethash::to_ethash(header.mix_hash()) )));
 		if difficulty < header.difficulty {
 			return Err(From::from(BlockError::InvalidProofOfWork(OutOfBounds { min: Some(header.difficulty), max: None, found: difficulty })));
 		}
@@ -241,10 +241,16 @@ impl Ethash {
 		target
 	}
 
-	fn boundary_to_difficulty(boundary: &H256) -> U256 {
+	/// Convert an Ethash boundary to its original difficulty. Basically just `f(x) = 2^256 / x`.
+	pub fn boundary_to_difficulty(boundary: &H256) -> U256 {
 		U256::from((U512::one() << 256) / x!(U256::from(boundary.as_slice())))
 	}
 
+	/// Convert an Ethash difficulty to the target boundary. Basically just `f(x) = 2^256 / x`.
+	pub fn difficulty_to_boundary(difficulty: &U256) -> H256 {
+		x!(U256::from((U512::one() << 256) / x!(difficulty)))
+	}
+
 	fn to_ethash(hash: H256) -> EH256 {
 		unsafe { mem::transmute(hash) }
 	}
diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml
index b9ca9deac..c38684643 100644
--- a/rpc/Cargo.toml
+++ b/rpc/Cargo.toml
@@ -15,6 +15,7 @@ jsonrpc-core = "1.2"
 jsonrpc-http-server = "2.1"
 ethcore-util = { path = "../util" }
 ethcore = { path = "../ethcore" }
+ethash = { path = "../ethash" }
 ethsync = { path = "../sync" }
 clippy = { version = "0.0.44", optional = true }
 rustc-serialize = "0.3"
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 00bce5437..5791b7418 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -22,7 +22,11 @@ use util::hash::*;
 use util::uint::*;
 use util::sha3::*;
 use ethcore::client::*;
+use ethcore::block::{IsBlock};
 use ethcore::views::*;
+extern crate ethash;
+use self::ethash::get_seedhash;
+use ethcore::ethereum::Ethash;
 use ethcore::ethereum::denominations::shannon;
 use v1::traits::{Eth, EthFilter};
 use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, OptionalValue, Index, Filter, Log};
@@ -209,6 +213,29 @@ impl Eth for EthClient {
 				to_value(&logs)
 			})
 	}
+
+	fn work(&self, params: Params) -> Result<Value, Error> {
+		match params {
+			Params::None => {
+				let c = take_weak!(self.client);
+				let u = c.sealing_block().lock().unwrap();
+				match *u {
+					Some(ref b) => {
+						let current_hash = b.hash();
+						let target = Ethash::difficulty_to_boundary(b.block().header().difficulty());
+						let seed_hash = get_seedhash(b.block().header().number());
+						to_value(&(current_hash, seed_hash, target))
+					}
+					_ => Err(Error::invalid_params())
+				}
+			},
+			_ => Err(Error::invalid_params())
+		}
+	}
+
+//	fn submit_work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+//	fn submit_hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 }
 
 /// Eth filter rpc implementation.
diff --git a/util/src/misc.rs b/util/src/misc.rs
index 289f1c50c..35e1f3a75 100644
--- a/util/src/misc.rs
+++ b/util/src/misc.rs
@@ -69,5 +69,5 @@ pub fn contents(name: &str) -> Result<Bytes, UtilError> {
 
 /// Get the standard version string for this software.
 pub fn version() -> String {
-	format!("Parity//{}-{}-{}/{}-{}-{}/rustc{}", env!("CARGO_PKG_VERSION"), short_sha(), commit_date().replace("-", ""), Target::arch(), Target::os(), Target::env(), rustc_version::version())
+	format!("Parity//v{}-{}-{}/{}-{}-{}/rustc{}", env!("CARGO_PKG_VERSION"), short_sha(), commit_date().replace("-", ""), Target::arch(), Target::os(), Target::env(), rustc_version::version())
 }
\ No newline at end of file
diff --git a/util/src/uint.rs b/util/src/uint.rs
index 517b7a29f..7f2e3d3b1 100644
--- a/util/src/uint.rs
+++ b/util/src/uint.rs
@@ -1124,6 +1124,33 @@ impl From<U512> for U256 {
 	}
 }
 
+impl<'a> From<&'a U256> for U512 {
+	fn from(value: &'a U256) -> U512 {
+		let U256(ref arr) = *value;
+		let mut ret = [0; 8];
+		ret[0] = arr[0];
+		ret[1] = arr[1];
+		ret[2] = arr[2];
+		ret[3] = arr[3];
+		U512(ret)
+	}
+}
+
+impl<'a> From<&'a U512> for U256 {
+	fn from(value: &'a U512) -> U256 {
+		let U512(ref arr) = *value;
+		if arr[4] | arr[5] | arr[6] | arr[7] != 0 {
+			panic!("Overflow");
+		}
+		let mut ret = [0; 4];
+		ret[0] = arr[0];
+		ret[1] = arr[1];
+		ret[2] = arr[2];
+		ret[3] = arr[3];
+		U256(ret)
+	}
+}
+
 impl From<U256> for U128 {
 	fn from(value: U256) -> U128 {
 		let U256(ref arr) = value;

From d0125f3ff5ad964644080eea646f769766e952f7 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 00:21:15 +0300
Subject: [PATCH 04/37] uint to separated crate

---
 Cargo.lock                              | 13 ++++++
 ethcore/src/action_params.rs            |  4 +-
 ethcore/src/blockchain/best_block.rs    |  3 +-
 ethcore/src/blockchain/block_info.rs    |  3 +-
 ethcore/src/blockchain/bloom_indexer.rs |  4 +-
 ethcore/src/blockchain/tree_route.rs    |  2 +-
 ethcore/src/blockchain/update.rs        |  2 +-
 ethcore/src/evm/ext.rs                  | 24 +++++-----
 ethcore/src/state.rs                    |  3 +-
 rpc/src/v1/impls/eth.rs                 |  3 +-
 rpc/src/v1/types/block.rs               |  6 +--
 rpc/src/v1/types/filter.rs              |  2 +-
 rpc/src/v1/types/log.rs                 |  8 ++--
 rpc/src/v1/types/sync.rs                |  2 +-
 rpc/src/v1/types/transaction.rs         |  3 +-
 util/Cargo.toml                         |  1 +
 util/bigint/Cargo.toml                  | 23 ++++++++++
 util/bigint/build.rs                    | 25 ++++++++++
 util/bigint/src/lib.rs                  | 23 ++++++++++
 util/{ => bigint}/src/uint.rs           | 61 +++++++++++++------------
 util/build.rs                           |  6 ---
 util/src/common.rs                      |  4 +-
 util/src/crypto.rs                      |  5 +-
 util/src/from_json.rs                   | 18 ++++++++
 util/src/hash.rs                        |  6 +--
 util/src/heapsizeof.rs                  |  3 +-
 util/src/lib.rs                         |  4 +-
 util/src/numbers.rs                     | 20 ++++++++
 util/src/rlp/bytes.rs                   |  2 +-
 util/src/rlp/tests.rs                   |  2 +-
 30 files changed, 194 insertions(+), 91 deletions(-)
 create mode 100644 util/bigint/Cargo.toml
 create mode 100644 util/bigint/build.rs
 create mode 100644 util/bigint/src/lib.rs
 rename util/{ => bigint}/src/uint.rs (98%)
 create mode 100644 util/src/numbers.rs

diff --git a/Cargo.lock b/Cargo.lock
index bca236813..9ce1c4372 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -44,6 +44,18 @@ dependencies = [
  "syntex_syntax 0.29.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "bigint"
+version = "0.1.0"
+dependencies = [
+ "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "heapsize 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "bitflags"
 version = "0.3.3"
@@ -220,6 +232,7 @@ name = "ethcore-util"
 version = "0.9.99"
 dependencies = [
  "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bigint 0.1.0",
  "clippy 0.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "elastic-array 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/ethcore/src/action_params.rs b/ethcore/src/action_params.rs
index 9e2d72c73..fa40d30a0 100644
--- a/ethcore/src/action_params.rs
+++ b/ethcore/src/action_params.rs
@@ -15,9 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Evm input params.
-use util::hash::*;
-use util::uint::*;
-use util::bytes::*;
+use common::*;
 
 /// Transaction value
 #[derive(Clone, Debug)]
diff --git a/ethcore/src/blockchain/best_block.rs b/ethcore/src/blockchain/best_block.rs
index cbb219617..8dc67ed09 100644
--- a/ethcore/src/blockchain/best_block.rs
+++ b/ethcore/src/blockchain/best_block.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
-use util::uint::U256;
+use util::common::{U256,H256};
 use header::BlockNumber;
 
 /// Best block info.
diff --git a/ethcore/src/blockchain/block_info.rs b/ethcore/src/blockchain/block_info.rs
index 98dac648d..fbfc0fd96 100644
--- a/ethcore/src/blockchain/block_info.rs
+++ b/ethcore/src/blockchain/block_info.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
-use util::uint::U256;
+use util::common::{U256,H256};
 use header::BlockNumber;
 
 /// Brief info about inserted block.
diff --git a/ethcore/src/blockchain/bloom_indexer.rs b/ethcore/src/blockchain/bloom_indexer.rs
index 74c679ba8..51a4f61bf 100644
--- a/ethcore/src/blockchain/bloom_indexer.rs
+++ b/ethcore/src/blockchain/bloom_indexer.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
+use util::common::H256;
 use chainfilter::BloomIndex;
 
 /// Represents location of block bloom in extras database.
@@ -44,7 +44,7 @@ impl BloomIndexer {
 	/// Calculates bloom's position in database.
 	pub fn location(&self, bloom_index: &BloomIndex) -> BlocksBloomLocation {
 		use std::{mem, ptr};
-		
+
 		let hash = unsafe {
 			let mut hash: H256 = mem::zeroed();
 			ptr::copy(&[bloom_index.index / self.index_size] as *const usize as *const u8, hash.as_mut_ptr(), 8);
diff --git a/ethcore/src/blockchain/tree_route.rs b/ethcore/src/blockchain/tree_route.rs
index 1bd0e6f75..4532236aa 100644
--- a/ethcore/src/blockchain/tree_route.rs
+++ b/ethcore/src/blockchain/tree_route.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::H256;
+use util::common::H256;
 
 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug)]
diff --git a/ethcore/src/blockchain/update.rs b/ethcore/src/blockchain/update.rs
index f8ca06e66..526efac73 100644
--- a/ethcore/src/blockchain/update.rs
+++ b/ethcore/src/blockchain/update.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use util::hash::H256;
+use util::common::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use extras::{BlockDetails, BlockReceipts, TransactionAddress, BlocksBlooms};
diff --git a/ethcore/src/evm/ext.rs b/ethcore/src/evm/ext.rs
index ae4cff3be..f4172f10a 100644
--- a/ethcore/src/evm/ext.rs
+++ b/ethcore/src/evm/ext.rs
@@ -16,9 +16,7 @@
 
 //! Interface for Evm externalities.
 
-use common::Bytes;
-use util::hash::*;
-use util::uint::*;
+use util::common::*;
 use evm::{Schedule, Error};
 use env_info::*;
 
@@ -60,22 +58,22 @@ pub trait Ext {
 	fn blockhash(&self, number: &U256) -> H256;
 
 	/// Creates new contract.
-	/// 
+	///
 	/// Returns gas_left and contract address if contract creation was succesfull.
 	fn create(&mut self, gas: &U256, value: &U256, code: &[u8]) -> ContractCreateResult;
 
 	/// Message call.
-	/// 
+	///
 	/// Returns Err, if we run out of gas.
-	/// Otherwise returns call_result which contains gas left 
+	/// Otherwise returns call_result which contains gas left
 	/// and true if subcall was successfull.
-	fn call(&mut self, 
-			gas: &U256, 
-			sender_address: &Address, 
-			receive_address: &Address, 
+	fn call(&mut self,
+			gas: &U256,
+			sender_address: &Address,
+			receive_address: &Address,
 			value: Option<U256>,
-			data: &[u8], 
-			code_address: &Address, 
+			data: &[u8],
+			code_address: &Address,
 			output: &mut [u8]) -> MessageCallResult;
 
 	/// Returns code at given address
@@ -99,7 +97,7 @@ pub trait Ext {
 	fn env_info(&self) -> &EnvInfo;
 
 	/// Returns current depth of execution.
-	/// 
+	///
 	/// If contract A calls contract B, and contract B calls C,
 	/// then A depth is 0, B is 1, C is 2 and so on.
 	fn depth(&self) -> usize;
diff --git a/ethcore/src/state.rs b/ethcore/src/state.rs
index 8bbf317c1..83b77ece0 100644
--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@@ -335,10 +335,9 @@ impl fmt::Debug for State {
 mod tests {
 
 use super::*;
-use util::hash::*;
+use util::common::*;
 use util::trie::*;
 use util::rlp::*;
-use util::uint::*;
 use account::*;
 use tests::helpers::*;
 use devtools::*;
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 00bce5437..0dd5714d2 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -18,8 +18,7 @@
 use std::sync::{Arc, Weak};
 use ethsync::{EthSync, SyncState};
 use jsonrpc_core::*;
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use util::sha3::*;
 use ethcore::client::*;
 use ethcore::views::*;
diff --git a/rpc/src/v1/types/block.rs b/rpc/src/v1/types/block.rs
index b92111bcb..2457efcf8 100644
--- a/rpc/src/v1/types/block.rs
+++ b/rpc/src/v1/types/block.rs
@@ -15,8 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use serde::{Serialize, Serializer};
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use v1::types::{Bytes, Transaction, OptionalValue};
 
 #[derive(Debug)]
@@ -71,8 +70,7 @@ pub struct Block {
 #[cfg(test)]
 mod tests {
 	use serde_json;
-	use util::hash::*;
-	use util::uint::*;
+	use util::numbers::*;
 	use v1::types::{Transaction, Bytes, OptionalValue};
 	use super::*;
 
diff --git a/rpc/src/v1/types/filter.rs b/rpc/src/v1/types/filter.rs
index 01d322cce..16a08764b 100644
--- a/rpc/src/v1/types/filter.rs
+++ b/rpc/src/v1/types/filter.rs
@@ -17,7 +17,7 @@
 use serde::{Deserialize, Deserializer, Error};
 use serde_json::value;
 use jsonrpc_core::Value;
-use util::hash::*;
+use util::numbers::*;
 use v1::types::BlockNumber;
 use ethcore::filter::Filter as EthFilter;
 use ethcore::client::BlockId;
diff --git a/rpc/src/v1/types/log.rs b/rpc/src/v1/types/log.rs
index 0629c5534..0f5fdee15 100644
--- a/rpc/src/v1/types/log.rs
+++ b/rpc/src/v1/types/log.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use ethcore::log_entry::LocalizedLogEntry;
 use v1::types::Bytes;
 
@@ -55,8 +54,7 @@ impl From<LocalizedLogEntry> for Log {
 mod tests {
 	use serde_json;
 	use std::str::FromStr;
-	use util::hash::*;
-	use util::uint::*;
+	use util::numbers::*;
 	use v1::types::{Bytes, Log};
 
 	#[test]
@@ -66,7 +64,7 @@ mod tests {
 		let log = Log {
 			address: Address::from_str("33990122638b9132ca29c723bdf037f1a891a70c").unwrap(),
 			topics: vec![
-				H256::from_str("a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc").unwrap(), 
+				H256::from_str("a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc").unwrap(),
 				H256::from_str("4861736852656700000000000000000000000000000000000000000000000000").unwrap()
 			],
 			data: Bytes::new(vec![]),
diff --git a/rpc/src/v1/types/sync.rs b/rpc/src/v1/types/sync.rs
index b5568acda..c0e480140 100644
--- a/rpc/src/v1/types/sync.rs
+++ b/rpc/src/v1/types/sync.rs
@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use serde::{Serialize, Serializer};
-use util::uint::*;
+use util::numbers::*;
 
 #[derive(Default, Debug, Serialize, PartialEq)]
 pub struct SyncInfo {
diff --git a/rpc/src/v1/types/transaction.rs b/rpc/src/v1/types/transaction.rs
index 0e9256ada..232cf0bf3 100644
--- a/rpc/src/v1/types/transaction.rs
+++ b/rpc/src/v1/types/transaction.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use ethcore::transaction::{LocalizedTransaction, Action};
 use v1::types::{Bytes, OptionalValue};
 
diff --git a/util/Cargo.toml b/util/Cargo.toml
index b7eafd905..0c7df3f40 100644
--- a/util/Cargo.toml
+++ b/util/Cargo.toml
@@ -35,6 +35,7 @@ ethcore-devtools = { path = "../devtools" }
 libc = "0.2.7"
 vergen = "0.1"
 target_info = "0.1"
+bigint = { path = "bigint" }
 
 [features]
 default = []
diff --git a/util/bigint/Cargo.toml b/util/bigint/Cargo.toml
new file mode 100644
index 000000000..377391eeb
--- /dev/null
+++ b/util/bigint/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+description = "Rust-assembler implementation of big integers arithmetic"
+homepage = "http://ethcore.io"
+license = "GPL-3.0"
+name = "bigint"
+version = "0.1.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+build = "build.rs"
+
+[build-dependencies]
+rustc_version = "0.1"
+
+[dependencies]
+rustc-serialize = "0.3"
+arrayvec = "0.3"
+rand = "0.3.12"
+serde = "0.7.0"
+clippy = { version = "0.0.44", optional = true }
+heapsize = "0.3"
+
+[features]
+x64asm_arithmetic=[]
+rust_arithmetic=[]
diff --git a/util/bigint/build.rs b/util/bigint/build.rs
new file mode 100644
index 000000000..248823229
--- /dev/null
+++ b/util/bigint/build.rs
@@ -0,0 +1,25 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+extern crate rustc_version;
+
+use rustc_version::{version_meta, Channel};
+
+fn main() {
+	if let Channel::Nightly = version_meta().channel {
+		println!("cargo:rustc-cfg=asm_available");
+	}
+}
diff --git a/util/bigint/src/lib.rs b/util/bigint/src/lib.rs
new file mode 100644
index 000000000..149878538
--- /dev/null
+++ b/util/bigint/src/lib.rs
@@ -0,0 +1,23 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(asm_available, feature(asm))]
+
+extern crate rustc_serialize;
+extern crate serde;
+#[macro_use] extern crate heapsize;
+
+pub mod uint;
diff --git a/util/src/uint.rs b/util/bigint/src/uint.rs
similarity index 98%
rename from util/src/uint.rs
rename to util/bigint/src/uint.rs
index 88256d5f2..4cc0dfc0e 100644
--- a/util/src/uint.rs
+++ b/util/bigint/src/uint.rs
@@ -36,10 +36,26 @@
 //! The functions here are designed to be fast.
 //!
 
-use standard::*;
-use from_json::*;
-use rustc_serialize::hex::ToHex;
+use std::fmt;
+use std::cmp;
+
+use std::mem;
+use std::ops;
+use std::slice;
+use std::result;
+use std::option;
+use std::str::{FromStr};
+use std::convert::From;
+use std::hash::{Hash, Hasher};
+use std::ops::*;
+use std::cmp::*;
+use std::collections::*;
+
 use serde;
+use rustc_serialize::json::Json;
+use rustc_serialize::base64::FromBase64;
+use rustc_serialize::hex::{FromHex, FromHexError, ToHex};
+
 
 macro_rules! impl_map_from {
 	($thing:ident, $from:ty, $to:ty) => {
@@ -51,7 +67,7 @@ macro_rules! impl_map_from {
 	}
 }
 
-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_add {
 	($name:ident, $n_words:expr, $self_expr: expr, $other: expr) => ({
 		uint_overflowing_add_reg!($name, $n_words, $self_expr, $other)
@@ -88,8 +104,7 @@ macro_rules! uint_overflowing_add_reg {
 	})
 }
 
-
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_add {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@@ -165,7 +180,7 @@ macro_rules! uint_overflowing_add {
 	)
 }
 
-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_sub {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let res = overflowing!((!$other).overflowing_add(From::from(1u64)));
@@ -174,7 +189,7 @@ macro_rules! uint_overflowing_sub {
 	})
 }
 
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_sub {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@@ -250,7 +265,7 @@ macro_rules! uint_overflowing_sub {
 	})
 }
 
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_mul {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@@ -370,7 +385,7 @@ macro_rules! uint_overflowing_mul {
 	)
 }
 
-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_mul {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		uint_overflowing_mul_reg!($name, $n_words, $self_expr, $other)
@@ -381,7 +396,6 @@ macro_rules! uint_overflowing_mul_reg {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut res = $name::from(0u64);
 		let mut overflow = false;
-		// TODO: be more efficient about this
 		for i in 0..(2 * $n_words) {
 			let v = overflowing!($self_expr.overflowing_mul_u32(($other >> (32 * i)).low_u32()), overflow);
 			let res2 = overflowing!(v.overflowing_shl(32 * i as u32), overflow);
@@ -416,7 +430,7 @@ macro_rules! panic_on_overflow {
 }
 
 /// Large, fixed-length unsigned integer type.
-pub trait Uint: Sized + Default + FromStr + From<u64> + FromJson + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {
+pub trait Uint: Sized + Default + FromStr + From<u64> + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {
 
 	/// Returns new instance equalling zero.
 	fn zero() -> Self;
@@ -779,22 +793,6 @@ macro_rules! construct_uint {
 			}
 		}
 
-		impl FromJson for $name {
-			fn from_json(json: &Json) -> Self {
-				match *json {
-					Json::String(ref s) => {
-						if s.len() >= 2 && &s[0..2] == "0x" {
-							FromStr::from_str(&s[2..]).unwrap_or_else(|_| Default::default())
-						} else {
-							Uint::from_dec_str(s).unwrap_or_else(|_| Default::default())
-						}
-					},
-					Json::U64(u) => From::from(u),
-					Json::I64(i) => From::from(i as u64),
-					_ => Uint::zero(),
-				}
-			}
-		}
 
 		impl_map_from!($name, u8, u64);
 		impl_map_from!($name, u16, u64);
@@ -1100,7 +1098,7 @@ construct_uint!(U128, 2);
 impl U256 {
 	/// Multiplies two 256-bit integers to produce full 512-bit integer
 	/// No overflow possible
-	#[cfg(all(x64asm, target_arch="x86_64"))]
+	#[cfg(all(asm_available, target_arch="x86_64"))]
 	pub fn full_mul(self, other: U256) -> U512 {
 		let self_t: &[u64; 4] = unsafe { &mem::transmute(self) };
 		let other_t: &[u64; 4] = unsafe { &mem::transmute(other) };
@@ -1239,7 +1237,7 @@ impl U256 {
 
 	/// Multiplies two 256-bit integers to produce full 512-bit integer
 	/// No overflow possible
-	#[cfg(not(all(x64asm, target_arch="x86_64")))]
+	#[cfg(not(all(asm_available, target_arch="x86_64")))]
 	pub fn full_mul(self, other: U256) -> U512 {
 		let self_512 = U512::from(self);
 		let other_512 = U512::from(other);
@@ -1338,6 +1336,9 @@ pub const ZERO_U256: U256 = U256([0x00u64; 4]);
 /// Constant value of `U256::one()` that can be used for a reference saving an additional instance creation.
 pub const ONE_U256: U256 = U256([0x01u64, 0x00u64, 0x00u64, 0x00u64]);
 
+
+known_heap_size!(0, U128, U256);
+
 #[cfg(test)]
 mod tests {
 	use uint::{Uint, U128, U256, U512};
diff --git a/util/build.rs b/util/build.rs
index 2b581642b..eed080e29 100644
--- a/util/build.rs
+++ b/util/build.rs
@@ -1,13 +1,7 @@
 extern crate vergen;
-extern crate rustc_version;
 
 use vergen::*;
-use rustc_version::{version_meta, Channel};
 
 fn main() {
 	vergen(OutputFns::all()).unwrap();
-
-	if let Channel::Nightly = version_meta().channel {
-		println!("cargo:rustc-cfg=x64asm");
-	}
 }
diff --git a/util/src/common.rs b/util/src/common.rs
index 0816b72e4..a96bf5444 100644
--- a/util/src/common.rs
+++ b/util/src/common.rs
@@ -19,12 +19,12 @@
 pub use standard::*;
 pub use from_json::*;
 pub use error::*;
-pub use hash::*;
-pub use uint::*;
 pub use bytes::*;
 pub use vector::*;
+pub use numbers::*;
 pub use sha3::*;
 
+
 #[macro_export]
 macro_rules! map {
 	( $( $x:expr => $y:expr ),* ) => {
diff --git a/util/src/crypto.rs b/util/src/crypto.rs
index 2d5516b6f..48d98708b 100644
--- a/util/src/crypto.rs
+++ b/util/src/crypto.rs
@@ -16,9 +16,8 @@
 
 //! Ethcore crypto.
 
-use hash::*;
+use numbers::*;
 use bytes::*;
-use uint::*;
 use secp256k1::{key, Secp256k1};
 use rand::os::OsRng;
 
@@ -152,7 +151,7 @@ impl KeyPair {
 /// EC functions
 pub mod ec {
 	use hash::*;
-	use uint::*;
+	use bigint::uint::*;
 	use standard::*;
 	use crypto::*;
 	use crypto::{self};
diff --git a/util/src/from_json.rs b/util/src/from_json.rs
index 7d977afc9..a598ed961 100644
--- a/util/src/from_json.rs
+++ b/util/src/from_json.rs
@@ -17,6 +17,7 @@
 //! Coversion from json.
 
 use standard::*;
+use bigint::uint::*;
 
 #[macro_export]
 macro_rules! xjson {
@@ -30,3 +31,20 @@ pub trait FromJson {
 	/// Convert a JSON value to an instance of this type.
 	fn from_json(json: &Json) -> Self;
 }
+
+impl FromJson for U256 {
+	fn from_json(json: &Json) -> Self {
+		match *json {
+			Json::String(ref s) => {
+				if s.len() >= 2 && &s[0..2] == "0x" {
+					FromStr::from_str(&s[2..]).unwrap_or_else(|_| Default::default())
+				} else {
+					Uint::from_dec_str(s).unwrap_or_else(|_| Default::default())
+				}
+			},
+			Json::U64(u) => From::from(u),
+			Json::I64(i) => From::from(i as u64),
+			_ => Uint::zero(),
+		}
+	}
+}
diff --git a/util/src/hash.rs b/util/src/hash.rs
index 88c57371e..42fdff663 100644
--- a/util/src/hash.rs
+++ b/util/src/hash.rs
@@ -23,7 +23,7 @@ use rand::Rng;
 use rand::os::OsRng;
 use bytes::{BytesConvertable,Populatable};
 use from_json::*;
-use uint::{Uint, U256};
+use bigint::uint::{Uint, U256};
 use rustc_serialize::hex::ToHex;
 use serde;
 
@@ -595,7 +595,7 @@ pub fn h256_from_hex(s: &str) -> H256 {
 
 /// Convert `n` to an `H256`, setting the rightmost 8 bytes.
 pub fn h256_from_u64(n: u64) -> H256 {
-	use uint::U256;
+	use bigint::uint::U256;
 	H256::from(&U256::from(n))
 }
 
@@ -631,7 +631,7 @@ pub static ZERO_H256: H256 = H256([0x00; 32]);
 #[cfg(test)]
 mod tests {
 	use hash::*;
-	use uint::*;
+	use bigint::uint::*;
 	use std::str::FromStr;
 
 	#[test]
diff --git a/util/src/heapsizeof.rs b/util/src/heapsizeof.rs
index d7c8124cd..feb679a0b 100644
--- a/util/src/heapsizeof.rs
+++ b/util/src/heapsizeof.rs
@@ -16,8 +16,7 @@
 
 //! Calculates heapsize of util types.
 
-use uint::*;
 use hash::*;
 
 known_heap_size!(0, H32, H64, H128, Address, H256, H264, H512, H520, H1024, H2048);
-known_heap_size!(0, U128, U256);
+
diff --git a/util/src/lib.rs b/util/src/lib.rs
index 2a47eb438..dd3ef102b 100644
--- a/util/src/lib.rs
+++ b/util/src/lib.rs
@@ -16,7 +16,6 @@
 
 #![warn(missing_docs)]
 #![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(x64asm, feature(asm))]
 #![cfg_attr(feature="dev", plugin(clippy))]
 
 // Clippy settings
@@ -111,15 +110,16 @@ extern crate libc;
 extern crate rustc_version;
 extern crate target_info;
 extern crate vergen;
+extern crate bigint;
 
 pub mod standard;
 #[macro_use]
 pub mod from_json;
 #[macro_use]
 pub mod common;
+pub mod numbers;
 pub mod error;
 pub mod hash;
-pub mod uint;
 pub mod bytes;
 pub mod rlp;
 pub mod misc;
diff --git a/util/src/numbers.rs b/util/src/numbers.rs
new file mode 100644
index 000000000..b79338fc1
--- /dev/null
+++ b/util/src/numbers.rs
@@ -0,0 +1,20 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Utils number types.
+
+pub use hash::*;
+pub use bigint::uint::*;
diff --git a/util/src/rlp/bytes.rs b/util/src/rlp/bytes.rs
index 2ff6281cc..e8bfa57b0 100644
--- a/util/src/rlp/bytes.rs
+++ b/util/src/rlp/bytes.rs
@@ -21,7 +21,7 @@ use std::mem;
 use std::fmt;
 use std::cmp::Ordering;
 use std::error::Error as StdError;
-use uint::{Uint, U128, U256};
+use bigint::uint::{Uint, U128, U256};
 use hash::FixedHash;
 use elastic_array::*;
 
diff --git a/util/src/rlp/tests.rs b/util/src/rlp/tests.rs
index eb2039103..a92dd5c4a 100644
--- a/util/src/rlp/tests.rs
+++ b/util/src/rlp/tests.rs
@@ -21,7 +21,7 @@ use std::{fmt, cmp};
 use std::str::FromStr;
 use rlp;
 use rlp::{UntrustedRlp, RlpStream, View, Stream, DecoderError};
-use uint::U256;
+use bigint::uint::U256;
 
 #[test]
 fn rlp_at() {

From 16038d9555ee8b48b691e26a0be968df26bcac60 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 00:23:49 +0300
Subject: [PATCH 05/37] hash&uint -> numbers

---
 util/src/crypto.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/util/src/crypto.rs b/util/src/crypto.rs
index 48d98708b..66e9f2edb 100644
--- a/util/src/crypto.rs
+++ b/util/src/crypto.rs
@@ -150,8 +150,7 @@ impl KeyPair {
 
 /// EC functions
 pub mod ec {
-	use hash::*;
-	use bigint::uint::*;
+	use numbers::*;
 	use standard::*;
 	use crypto::*;
 	use crypto::{self};

From f528d8c50a37a04d3b1b7fa24dda9c051db3d0d1 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 00:44:45 +0300
Subject: [PATCH 06/37] common -> numbers (as most narrow)

---
 ethcore/src/blockchain/best_block.rs    | 2 +-
 ethcore/src/blockchain/block_info.rs    | 2 +-
 ethcore/src/blockchain/bloom_indexer.rs | 2 +-
 ethcore/src/blockchain/tree_route.rs    | 2 +-
 ethcore/src/blockchain/update.rs        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/ethcore/src/blockchain/best_block.rs b/ethcore/src/blockchain/best_block.rs
index 8dc67ed09..00c092713 100644
--- a/ethcore/src/blockchain/best_block.rs
+++ b/ethcore/src/blockchain/best_block.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::common::{U256,H256};
+use util::numbers::{U256,H256};
 use header::BlockNumber;
 
 /// Best block info.
diff --git a/ethcore/src/blockchain/block_info.rs b/ethcore/src/blockchain/block_info.rs
index fbfc0fd96..ce639bfed 100644
--- a/ethcore/src/blockchain/block_info.rs
+++ b/ethcore/src/blockchain/block_info.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::common::{U256,H256};
+use util::numbers::{U256,H256};
 use header::BlockNumber;
 
 /// Brief info about inserted block.
diff --git a/ethcore/src/blockchain/bloom_indexer.rs b/ethcore/src/blockchain/bloom_indexer.rs
index 51a4f61bf..a672a5445 100644
--- a/ethcore/src/blockchain/bloom_indexer.rs
+++ b/ethcore/src/blockchain/bloom_indexer.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::common::H256;
+use util::numbers::H256;
 use chainfilter::BloomIndex;
 
 /// Represents location of block bloom in extras database.
diff --git a/ethcore/src/blockchain/tree_route.rs b/ethcore/src/blockchain/tree_route.rs
index 4532236aa..3c4906449 100644
--- a/ethcore/src/blockchain/tree_route.rs
+++ b/ethcore/src/blockchain/tree_route.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::common::H256;
+use util::numbers::H256;
 
 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug)]
diff --git a/ethcore/src/blockchain/update.rs b/ethcore/src/blockchain/update.rs
index 526efac73..6be2647d3 100644
--- a/ethcore/src/blockchain/update.rs
+++ b/ethcore/src/blockchain/update.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use util::common::H256;
+use util::numbers::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use extras::{BlockDetails, BlockReceipts, TransactionAddress, BlocksBlooms};

From 82a528961bf3f69d50b11fb9f26fc8ec83c97237 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 01:13:00 +0300
Subject: [PATCH 07/37] remove line

---
 util/src/common.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/util/src/common.rs b/util/src/common.rs
index a96bf5444..b2a06c4b9 100644
--- a/util/src/common.rs
+++ b/util/src/common.rs
@@ -24,7 +24,6 @@ pub use vector::*;
 pub use numbers::*;
 pub use sha3::*;
 
-
 #[macro_export]
 macro_rules! map {
 	( $( $x:expr => $y:expr ),* ) => {

From 394e9c679bfb0e49c51a67b05001043c648a76cc Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 00:02:48 +0100
Subject: [PATCH 08/37] Reorganised ImportError to be a type of Errpr (rather
 than vice-versa). Added support for eth_submitWork.

---
 ethcore/src/block.rs           | 16 ++++++++++++--
 ethcore/src/block_queue.rs     | 24 ++++++++++----------
 ethcore/src/client.rs          | 40 +++++++++++++++++++++++++++-------
 ethcore/src/engine.rs          |  2 --
 ethcore/src/error.rs           | 34 ++++++++++++++++-------------
 ethcore/src/ethereum/ethash.rs |  9 ++++----
 ethcore/src/verification.rs    |  8 +++----
 rpc/src/v1/impls/eth.rs        | 13 ++++++++---
 sync/src/chain.rs              | 12 +++++-----
 9 files changed, 102 insertions(+), 56 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index 28005b17e..f72c2f800 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -21,7 +21,7 @@
 use common::*;
 use engine::*;
 use state::*;
-use verification::PreVerifiedBlock;
+use verification::PreverifiedBlock;
 
 /// A block, encoded as it is on the block chain.
 // TODO: rename to Block
@@ -302,6 +302,18 @@ impl ClosedBlock {
 		Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes })
 	}
 
+	/// Provide a valid seal in order to turn this into a `SealedBlock`.
+	/// This does check the validity of `seal` with the engine.
+	/// Returns the `ClosedBlock` back again if the seal is no good.
+	pub fn try_seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock> {
+		let mut s = self;
+		s.block.base.header.set_seal(seal);
+		match engine.verify_block_basic(&s.block.base.header, None).is_err() || engine.verify_block_unordered(&s.block.base.header, None).is_err() {
+			false => Err(s),
+			true => Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes }),
+		}
+	}
+
 	/// Drop this object and return the underlieing database.
 	pub fn drain(self) -> JournalDB { self.block.state.drop().1 }
 }
@@ -350,7 +362,7 @@ pub fn enact_bytes(block_bytes: &[u8], engine: &Engine, db: JournalDB, parent: &
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_verified(block: &PreVerifiedBlock, engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
+pub fn enact_verified(block: &PreverifiedBlock, engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	let view = BlockView::new(&block.bytes);
 	enact(&block.header, &block.transactions, &view.uncles(), engine, db, parent, last_hashes)
 }
diff --git a/ethcore/src/block_queue.rs b/ethcore/src/block_queue.rs
index 668c004e5..143f53647 100644
--- a/ethcore/src/block_queue.rs
+++ b/ethcore/src/block_queue.rs
@@ -28,7 +28,7 @@ use service::*;
 use client::BlockStatus;
 use util::panics::*;
 
-known_heap_size!(0, UnVerifiedBlock, VerifyingBlock, PreVerifiedBlock);
+known_heap_size!(0, UnverifiedBlock, VerifyingBlock, PreverifiedBlock);
 
 const MIN_MEM_LIMIT: usize = 16384;
 const MIN_QUEUE_LIMIT: usize = 512;
@@ -105,14 +105,14 @@ pub struct BlockQueue {
 	max_mem_use: usize,
 }
 
-struct UnVerifiedBlock {
+struct UnverifiedBlock {
 	header: Header,
 	bytes: Bytes,
 }
 
 struct VerifyingBlock {
 	hash: H256,
-	block: Option<PreVerifiedBlock>,
+	block: Option<PreverifiedBlock>,
 }
 
 struct QueueSignal {
@@ -134,8 +134,8 @@ impl QueueSignal {
 
 #[derive(Default)]
 struct Verification {
-	unverified: VecDeque<UnVerifiedBlock>,
-	verified: VecDeque<PreVerifiedBlock>,
+	unverified: VecDeque<UnverifiedBlock>,
+	verified: VecDeque<PreverifiedBlock>,
 	verifying: VecDeque<VerifyingBlock>,
 	bad: HashSet<H256>,
 }
@@ -244,7 +244,7 @@ impl BlockQueue {
 		}
 	}
 
-	fn drain_verifying(verifying: &mut VecDeque<VerifyingBlock>, verified: &mut VecDeque<PreVerifiedBlock>, bad: &mut HashSet<H256>) {
+	fn drain_verifying(verifying: &mut VecDeque<VerifyingBlock>, verified: &mut VecDeque<PreverifiedBlock>, bad: &mut HashSet<H256>) {
 		while !verifying.is_empty() && verifying.front().unwrap().block.is_some() {
 			let block = verifying.pop_front().unwrap().block.unwrap();
 			if bad.contains(&block.header.parent_hash) {
@@ -289,31 +289,31 @@ impl BlockQueue {
 		let header = BlockView::new(&bytes).header();
 		let h = header.hash();
 		if self.processing.read().unwrap().contains(&h) {
-			return Err(ImportError::AlreadyQueued);
+			return Err(x!(ImportError::AlreadyQueued));
 		}
 		{
 			let mut verification = self.verification.lock().unwrap();
 			if verification.bad.contains(&h) {
-				return Err(ImportError::Bad(None));
+				return Err(x!(ImportError::KnownBad));
 			}
 
 			if verification.bad.contains(&header.parent_hash) {
 				verification.bad.insert(h.clone());
-				return Err(ImportError::Bad(None));
+				return Err(x!(ImportError::KnownBad));
 			}
 		}
 
 		match verify_block_basic(&header, &bytes, self.engine.deref().deref()) {
 			Ok(()) => {
 				self.processing.write().unwrap().insert(h.clone());
-				self.verification.lock().unwrap().unverified.push_back(UnVerifiedBlock { header: header, bytes: bytes });
+				self.verification.lock().unwrap().unverified.push_back(UnverifiedBlock { header: header, bytes: bytes });
 				self.more_to_verify.notify_all();
 				Ok(h)
 			},
 			Err(err) => {
 				warn!(target: "client", "Stage 1 block verification failed for {}\nError: {:?}", BlockView::new(&bytes).header_view().sha3(), err);
 				self.verification.lock().unwrap().bad.insert(h.clone());
-				Err(From::from(err))
+				Err(err)
 			}
 		}
 	}
@@ -352,7 +352,7 @@ impl BlockQueue {
 	}
 
 	/// Removes up to `max` verified blocks from the queue
-	pub fn drain(&mut self, max: usize) -> Vec<PreVerifiedBlock> {
+	pub fn drain(&mut self, max: usize) -> Vec<PreverifiedBlock> {
 		let mut verification = self.verification.lock().unwrap();
 		let count = min(max, verification.verified.len());
 		let mut result = Vec::with_capacity(count);
diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index f634579ad..d4fdb66c4 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -176,7 +176,7 @@ pub struct ClientReport {
 
 impl ClientReport {
 	/// Alter internal reporting to reflect the additional `block` has been processed.
-	pub fn accrue_block(&mut self, block: &PreVerifiedBlock) {
+	pub fn accrue_block(&mut self, block: &PreverifiedBlock) {
 		self.blocks_imported += 1;
 		self.transactions_applied += block.transactions.len();
 		self.gas_processed = self.gas_processed + block.header.gas_used;
@@ -257,7 +257,7 @@ impl Client {
 		last_hashes
 	}
 
-	fn check_and_close_block(&self, block: &PreVerifiedBlock) -> Result<ClosedBlock, ()> {
+	fn check_and_close_block(&self, block: &PreverifiedBlock) -> Result<ClosedBlock, ()> {
 		let engine = self.engine.deref().deref();
 		let header = &block.header;
 
@@ -433,6 +433,28 @@ impl Client {
 
 	/// Grab the `ClosedBlock` that we want to be sealed. Comes as a mutex that you have to lock.
 	pub fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>> { &self.sealing_block }
+
+	/// Submit `seal` as a valid solution for the header of `pow_hash`.
+	pub fn submit_seal(&self, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error> {
+		let mut maybe_b = self.sealing_block.lock().unwrap();
+		match *maybe_b {
+			Some(ref b) if b.hash() == pow_hash => {}
+			_ => { return Err(Error::PowHashInvalid); }
+		}
+
+		let b = maybe_b.take();
+		match b.unwrap().try_seal(self.engine.deref().deref(), seal) {
+			Err(old) => {
+				*maybe_b = Some(old);
+				Err(Error::PowInvalid)
+			}
+			Ok(sealed) => {
+				// TODO: commit DB from `sealed.drain` and make a VerifiedBlock to skip running the transactions twice.
+				try!(self.import_block(sealed.rlp_bytes()));
+				Ok(())
+			}
+		}
+	}
 }
 
 // TODO: need MinerService MinerIoHandler
@@ -509,12 +531,14 @@ impl BlockChainClient for Client {
 	}
 
 	fn import_block(&self, bytes: Bytes) -> ImportResult {
-		let header = BlockView::new(&bytes).header();
-		if self.chain.read().unwrap().is_known(&header.hash()) {
-			return Err(ImportError::AlreadyInChain);
-		}
-		if self.block_status(BlockId::Hash(header.parent_hash)) == BlockStatus::Unknown {
-			return Err(ImportError::UnknownParent);
+		{
+			let header = BlockView::new(&bytes).header_view();
+			if self.chain.read().unwrap().is_known(&header.sha3()) {
+				return Err(x!(ImportError::AlreadyInChain));
+			}
+			if self.block_status(BlockId::Hash(header.parent_hash())) == BlockStatus::Unknown {
+				return Err(x!(BlockError::UnknownParent(header.parent_hash())));
+			}
 		}
 		self.block_queue.write().unwrap().import_block(bytes)
 	}
diff --git a/ethcore/src/engine.rs b/ethcore/src/engine.rs
index f86c943ee..c57be3cdb 100644
--- a/ethcore/src/engine.rs
+++ b/ethcore/src/engine.rs
@@ -30,8 +30,6 @@ pub trait Engine : Sync + Send {
 
 	/// The number of additional header fields required for this engine.
 	fn seal_fields(&self) -> usize { 0 }
-	/// Default values of the additional fields RLP-encoded in a raw (non-list) harness.
-	fn seal_rlp(&self) -> Bytes { vec![] }
 
 	/// Additional engine-specific information for the user/developer concerning `header`.
 	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { HashMap::new() }
diff --git a/ethcore/src/error.rs b/ethcore/src/error.rs
index f75f338bf..824d8da90 100644
--- a/ethcore/src/error.rs
+++ b/ethcore/src/error.rs
@@ -131,25 +131,14 @@ pub enum BlockError {
 #[derive(Debug)]
 /// Import to the block queue result
 pub enum ImportError {
-	/// Bad block detected
-	Bad(Option<Error>),
-	/// Already in the block chain
+	/// Already in the block chain.
 	AlreadyInChain,
-	/// Already in the block queue
+	/// Already in the block queue.
 	AlreadyQueued,
-	/// Unknown parent
-	UnknownParent,
+	/// Already marked as bad from a previous import (could mean parent is bad).
+	KnownBad,
 }
 
-impl From<Error> for ImportError {
-	fn from(err: Error) -> ImportError {
-		ImportError::Bad(Some(err))
-	}
-}
-
-/// Result of import block operation.
-pub type ImportResult = Result<H256, ImportError>;
-
 #[derive(Debug)]
 /// General error type which should be capable of representing all errors in ethcore.
 pub enum Error {
@@ -163,14 +152,29 @@ pub enum Error {
 	Execution(ExecutionError),
 	/// Error concerning transaction processing.
 	Transaction(TransactionError),
+	/// Error concerning block import.
+	Import(ImportError),
+	/// PoW hash is invalid or out of date.
+	PowHashInvalid,
+	/// The value of the nonce or mishash is invalid.
+	PowInvalid,
 }
 
+/// Result of import block operation.
+pub type ImportResult = Result<H256, Error>;
+
 impl From<TransactionError> for Error {
 	fn from(err: TransactionError) -> Error {
 		Error::Transaction(err)
 	}
 }
 
+impl From<ImportError> for Error {
+	fn from(err: ImportError) -> Error {
+		Error::Import(err)
+	}
+}
+
 impl From<BlockError> for Error {
 	fn from(err: BlockError) -> Error {
 		Error::Block(err)
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index 4f1ef1ce3..d26a7e2af 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -74,8 +74,6 @@ impl Engine for Ethash {
 	fn version(&self) -> SemanticVersion { SemanticVersion::new(1, 0, 0) }
 	// Two fields - mix
 	fn seal_fields(&self) -> usize { 2 }
-	// Two empty data items in RLP.
-	fn seal_rlp(&self) -> Bytes { encode(&H64::new()).to_vec() }
 
 	/// Additional engine-specific information for the user/developer concerning `header`.
 	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { HashMap::new() }
@@ -261,12 +259,15 @@ impl Ethash {
 }
 
 impl Header {
-	fn nonce(&self) -> H64 {
+	pub fn nonce(&self) -> H64 {
 		decode(&self.seal()[1])
 	}
-	fn mix_hash(&self) -> H256 {
+	pub fn mix_hash(&self) -> H256 {
 		decode(&self.seal()[0])
 	}
+	pub fn set_nonce_and_mix_hash(&mut self, nonce: &H64, mix_hash: &H256) {
+		self.seal = vec![encode(mix_hash).to_vec(), encode(nonce).to_vec()];
+	}
 }
 
 #[cfg(test)]
diff --git a/ethcore/src/verification.rs b/ethcore/src/verification.rs
index ad5efd24a..f52e2e1e4 100644
--- a/ethcore/src/verification.rs
+++ b/ethcore/src/verification.rs
@@ -26,7 +26,7 @@ use engine::Engine;
 use blockchain::*;
 
 /// Preprocessed block data gathered in `verify_block_unordered` call
-pub struct PreVerifiedBlock {
+pub struct PreverifiedBlock {
 	/// Populated block header
 	pub header: Header,
 	/// Populated block transactions
@@ -55,8 +55,8 @@ pub fn verify_block_basic(header: &Header, bytes: &[u8], engine: &Engine) -> Res
 
 /// Phase 2 verification. Perform costly checks such as transaction signatures and block nonce for ethash.
 /// Still operates on a individual block
-/// Returns a PreVerifiedBlock structure populated with transactions
-pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine) -> Result<PreVerifiedBlock, Error> {
+/// Returns a PreverifiedBlock structure populated with transactions
+pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine) -> Result<PreverifiedBlock, Error> {
 	try!(engine.verify_block_unordered(&header, Some(&bytes)));
 	for u in Rlp::new(&bytes).at(2).iter().map(|rlp| rlp.as_val::<Header>()) {
 		try!(engine.verify_block_unordered(&u, None));
@@ -70,7 +70,7 @@ pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine) ->
 			transactions.push(t);
 		}
 	}
-	Ok(PreVerifiedBlock {
+	Ok(PreverifiedBlock {
 		header: header,
 		transactions: transactions,
 		bytes: bytes,
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 5791b7418..1b5c4739c 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -21,6 +21,7 @@ use jsonrpc_core::*;
 use util::hash::*;
 use util::uint::*;
 use util::sha3::*;
+use util::rlp::encode;
 use ethcore::client::*;
 use ethcore::block::{IsBlock};
 use ethcore::views::*;
@@ -221,10 +222,10 @@ impl Eth for EthClient {
 				let u = c.sealing_block().lock().unwrap();
 				match *u {
 					Some(ref b) => {
-						let current_hash = b.hash();
+						let pow_hash = b.hash();
 						let target = Ethash::difficulty_to_boundary(b.block().header().difficulty());
 						let seed_hash = get_seedhash(b.block().header().number());
-						to_value(&(current_hash, seed_hash, target))
+						to_value(&(pow_hash, seed_hash, target))
 					}
 					_ => Err(Error::invalid_params())
 				}
@@ -233,7 +234,13 @@ impl Eth for EthClient {
 		}
 	}
 
-//	fn submit_work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn submit_work(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(H64, H256, H256)>(params).and_then(|(nonce, pow_hash, mix_hash)| {
+			let c = take_weak!(self.client);
+			let seal = vec![encode(&mix_hash).to_vec(), encode(&nonce).to_vec()];
+			to_value(&c.submit_seal(pow_hash, seal).is_ok())
+		})
+	}
 
 //	fn submit_hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 }
diff --git a/sync/src/chain.rs b/sync/src/chain.rs
index 6a7add27f..4b8065bc7 100644
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -477,19 +477,19 @@ impl ChainSync {
 		// TODO: Decompose block and add to self.headers and self.bodies instead
 		if header.number == From::from(self.current_base_block() + 1) {
 			match io.chain().import_block(block_rlp.as_raw().to_vec()) {
-				Err(ImportError::AlreadyInChain) => {
+				Err(Error::Import(ImportError::AlreadyInChain)) => {
 					trace!(target: "sync", "New block already in chain {:?}", h);
 				},
-				Err(ImportError::AlreadyQueued) => {
+				Err(Error::Import(ImportError::AlreadyQueued)) => {
 					trace!(target: "sync", "New block already queued {:?}", h);
 				},
 				Ok(_) => {
 					self.last_imported_block = Some(header.number);
 					trace!(target: "sync", "New block queued {:?}", h);
 				},
-				Err(ImportError::UnknownParent) => {
+				Err(Error::Block(BlockError::UnknownParent(p))) => {
 					unknown = true;
-					trace!(target: "sync", "New block with unknown parent {:?}", h);
+					trace!(target: "sync", "New block with unknown parent ({:?}) {:?}", p, h);
 				},
 				Err(e) => {
 					debug!(target: "sync", "Bad new block {:?} : {:?}", h, e);
@@ -781,12 +781,12 @@ impl ChainSync {
 				}
 
 				match io.chain().import_block(block_rlp.out()) {
-					Err(ImportError::AlreadyInChain) => {
+					Err(Error::Import(ImportError::AlreadyInChain)) => {
 						trace!(target: "sync", "Block already in chain {:?}", h);
 						self.last_imported_block = Some(headers.0 + i as BlockNumber);
 						self.last_imported_hash = Some(h.clone());
 					},
-					Err(ImportError::AlreadyQueued) => {
+					Err(Error::Import(ImportError::AlreadyQueued)) => {
 						trace!(target: "sync", "Block already queued {:?}", h);
 						self.last_imported_block = Some(headers.0 + i as BlockNumber);
 						self.last_imported_hash = Some(h.clone());

From 2266d74c2aec90949803e8721e20136ae5e79d08 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 01:15:00 +0100
Subject: [PATCH 09/37] Fix JSONRPC I/O.

---
 Cargo.lock                     |  1 +
 ethcore/src/ethereum/ethash.rs | 10 ++++++++++
 rpc/Cargo.toml                 |  1 +
 rpc/src/v1/impls/eth.rs        | 15 +++++++++++----
 4 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9c225dbbe..b8a92fc3d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -209,6 +209,7 @@ dependencies = [
  "ethsync 0.9.99",
  "jsonrpc-core 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "jsonrpc-http-server 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_codegen 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index d26a7e2af..6dabe558f 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -249,6 +249,11 @@ impl Ethash {
 		x!(U256::from((U512::one() << 256) / x!(difficulty)))
 	}
 
+	/// Given the `block_number`, determine the seed hash for Ethash.
+	pub fn get_seedhash(number: BlockNumber) -> H256 {
+		Self::from_ethash(ethash::get_seedhash(number))
+	}
+
 	fn to_ethash(hash: H256) -> EH256 {
 		unsafe { mem::transmute(hash) }
 	}
@@ -259,12 +264,17 @@ impl Ethash {
 }
 
 impl Header {
+	/// Get the none field of the header.
 	pub fn nonce(&self) -> H64 {
 		decode(&self.seal()[1])
 	}
+
+	/// Get the mix hash field of the header.
 	pub fn mix_hash(&self) -> H256 {
 		decode(&self.seal()[0])
 	}
+
+	/// Set the nonce and mix hash fields of the header.
 	pub fn set_nonce_and_mix_hash(&mut self, nonce: &H64, mix_hash: &H256) {
 		self.seal = vec![encode(mix_hash).to_vec(), encode(nonce).to_vec()];
 	}
diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml
index c38684643..086fb19c1 100644
--- a/rpc/Cargo.toml
+++ b/rpc/Cargo.toml
@@ -9,6 +9,7 @@ build = "build.rs"
 [lib]
 
 [dependencies]
+log = "0.3"
 serde = "0.7.0"
 serde_json = "0.7.0"
 jsonrpc-core = "1.2"
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 1b5c4739c..b26f38440 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -25,8 +25,7 @@ use util::rlp::encode;
 use ethcore::client::*;
 use ethcore::block::{IsBlock};
 use ethcore::views::*;
-extern crate ethash;
-use self::ethash::get_seedhash;
+//#[macro_use] extern crate log;
 use ethcore::ethereum::Ethash;
 use ethcore::ethereum::denominations::shannon;
 use v1::traits::{Eth, EthFilter};
@@ -216,6 +215,7 @@ impl Eth for EthClient {
 	}
 
 	fn work(&self, params: Params) -> Result<Value, Error> {
+		println!("Work wanted: {:?}", params);
 		match params {
 			Params::None => {
 				let c = take_weak!(self.client);
@@ -224,7 +224,7 @@ impl Eth for EthClient {
 					Some(ref b) => {
 						let pow_hash = b.hash();
 						let target = Ethash::difficulty_to_boundary(b.block().header().difficulty());
-						let seed_hash = get_seedhash(b.block().header().number());
+						let seed_hash = Ethash::get_seedhash(b.block().header().number());
 						to_value(&(pow_hash, seed_hash, target))
 					}
 					_ => Err(Error::invalid_params())
@@ -235,6 +235,7 @@ impl Eth for EthClient {
 	}
 
 	fn submit_work(&self, params: Params) -> Result<Value, Error> {
+		println!("Work submission: {:?}", params);
 		from_params::<(H64, H256, H256)>(params).and_then(|(nonce, pow_hash, mix_hash)| {
 			let c = take_weak!(self.client);
 			let seal = vec![encode(&mix_hash).to_vec(), encode(&nonce).to_vec()];
@@ -242,7 +243,13 @@ impl Eth for EthClient {
 		})
 	}
 
-//	fn submit_hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn submit_hashrate(&self, params: Params) -> Result<Value, Error> {
+		println!("Hashrate submission: {:?}", params);
+		from_params::<(Index, H256)>(params).and_then(|(rate, id)| {
+			println!("Miner {} reports a hash rate of {} H/s", id, rate.value());
+			to_value(&true)
+		})
+	}
 }
 
 /// Eth filter rpc implementation.

From 5ccb172e73a1bf0b7b16545c0560184beef8d9d8 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 01:52:22 +0100
Subject: [PATCH 10/37] Hashrate now reported correctly.

---
 ethcore/src/client.rs   |  4 ++--
 rpc/src/v1/impls/eth.rs | 16 +++++++++-------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index d4fdb66c4..c5aa987f6 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -417,7 +417,7 @@ impl Client {
 	/// New chain head event.
 	pub fn new_chain_head(&self) {
 		let h = self.chain.read().unwrap().best_block_hash();
-		info!("New best block: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
+		debug!("New best block: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
 		let b = OpenBlock::new(
 			self.engine.deref().deref(),
 			self.state_db.lock().unwrap().clone(),
@@ -427,7 +427,7 @@ impl Client {
 			b"Parity".to_vec()
 		);
 		let b = b.close();
-		info!("Sealed: hash={}, diff={}, number={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
+		debug!("Sealing: hash={}, diff={}, number={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
 		*self.sealing_block.lock().unwrap() = Some(b);
 	}
 
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index b26f38440..f96d69ce7 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -15,12 +15,12 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Eth rpc implementation.
-use std::sync::{Arc, Weak};
 use ethsync::{EthSync, SyncState};
 use jsonrpc_core::*;
 use util::hash::*;
 use util::uint::*;
 use util::sha3::*;
+use util::standard::{RwLock, HashMap, Arc, Weak};
 use util::rlp::encode;
 use ethcore::client::*;
 use ethcore::block::{IsBlock};
@@ -34,7 +34,8 @@ use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncIn
 /// Eth rpc implementation.
 pub struct EthClient {
 	client: Weak<Client>,
-	sync: Weak<EthSync>
+	sync: Weak<EthSync>,
+	hashrates: RwLock<HashMap<H256, u64>>,
 }
 
 impl EthClient {
@@ -42,7 +43,8 @@ impl EthClient {
 	pub fn new(client: &Arc<Client>, sync: &Arc<EthSync>) -> Self {
 		EthClient {
 			client: Arc::downgrade(client),
-			sync: Arc::downgrade(sync)
+			sync: Arc::downgrade(sync),
+			hashrates: RwLock::new(HashMap::new()),
 		}
 	}
 
@@ -137,7 +139,7 @@ impl Eth for EthClient {
 	// TODO: return real hashrate once we have mining
 	fn hashrate(&self, params: Params) -> Result<Value, Error> {
 		match params {
-			Params::None => to_value(&U256::zero()),
+			Params::None => to_value(&self.hashrates.read().unwrap().iter().fold(0u64, |sum, (_, v)| sum + v)),
 			_ => Err(Error::invalid_params())
 		}
 	}
@@ -215,7 +217,6 @@ impl Eth for EthClient {
 	}
 
 	fn work(&self, params: Params) -> Result<Value, Error> {
-		println!("Work wanted: {:?}", params);
 		match params {
 			Params::None => {
 				let c = take_weak!(self.client);
@@ -235,6 +236,7 @@ impl Eth for EthClient {
 	}
 
 	fn submit_work(&self, params: Params) -> Result<Value, Error> {
+		// TODO: println! should be debug!
 		println!("Work submission: {:?}", params);
 		from_params::<(H64, H256, H256)>(params).and_then(|(nonce, pow_hash, mix_hash)| {
 			let c = take_weak!(self.client);
@@ -244,9 +246,9 @@ impl Eth for EthClient {
 	}
 
 	fn submit_hashrate(&self, params: Params) -> Result<Value, Error> {
-		println!("Hashrate submission: {:?}", params);
+		// TODO: Index should be U256.
 		from_params::<(Index, H256)>(params).and_then(|(rate, id)| {
-			println!("Miner {} reports a hash rate of {} H/s", id, rate.value());
+			self.hashrates.write().unwrap().insert(id, rate.value() as u64);
 			to_value(&true)
 		})
 	}

From 1eca9acffb2f952678d7135f059139b650eec289 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 02:33:41 +0100
Subject: [PATCH 11/37] Fix is_mining.

---
 rpc/src/v1/impls/eth.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index f96d69ce7..24ecbe5f1 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -131,7 +131,7 @@ impl Eth for EthClient {
 	// TODO: return real value of mining once it's implemented.
 	fn is_mining(&self, params: Params) -> Result<Value, Error> {
 		match params {
-			Params::None => Ok(Value::Bool(false)),
+			Params::None => to_value(&!self.hashrates.read().unwrap().is_empty()),
 			_ => Err(Error::invalid_params())
 		}
 	}

From 3e2366b38b7d467ec4badafcee4d45bfc370a644 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Tue, 1 Mar 2016 16:22:06 +0100
Subject: [PATCH 12/37] improved chain generator

---
 ethcore/src/blockchain/blockchain.rs         |  32 ++---
 ethcore/src/blockchain/helpers/generators.rs | 119 +++++++++++++------
 2 files changed, 102 insertions(+), 49 deletions(-)

diff --git a/ethcore/src/blockchain/blockchain.rs b/ethcore/src/blockchain/blockchain.rs
index 0aba36a8e..53dcfb62c 100644
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@@ -770,14 +770,14 @@ mod tests {
 	use blockchain::{BlockProvider, BlockChain, BlockChainConfig};
 	use tests::helpers::*;
 	use devtools::*;
-	use blockchain::helpers::generators::ChainGenerator;
+	use blockchain::helpers::generators::{ChainGenerator, ChainIterator};
 	use views::BlockView;
 
 	#[test]
 	fn basic_blockchain_insert() {
 		let mut canon_chain = ChainGenerator::default();
-		let genesis = canon_chain.next().unwrap();
-		let first = canon_chain.next().unwrap();
+		let genesis = canon_chain.next().unwrap().rlp();
+		let first = canon_chain.next().unwrap().rlp();
 		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
 		let first_hash = BlockView::new(&first).header_view().sha3();
 
@@ -805,20 +805,24 @@ mod tests {
 	#[test]
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn test_small_fork() {
-		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a07dba07d6b448a186e9612e5f737d1c909dce473e53199901a302c00646d523c1a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808454c98c8142a059262c330941f3fe2a34d16d6e3c7b30d2ceb37c6a0e9a994c494ee1a61d2410885aa4c8bf8e56e264c0c0".from_hex().unwrap();
-		let b1 = "f90261f901f9a05716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0cb52de543653d86ccd13ba3ddf8b052525b04231c6884a4db3188a184681d878a0e78628dd45a1f8dc495594d83b76c588a3ee67463260f8b7d4a42f574aeab29aa0e9244cf7503b79c03d3a099e07a80d2dbc77bb0b502d8a89d51ac0d68dd31313b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001832fefd882520884562791e580a051b3ecba4e3f2b49c11d42dd0851ec514b1be3138080f72a2b6e83868275d98f8877671f479c414b47f862f86080018304cb2f94095e7baea6a6c7c4c2dfeb977efac326af552d870a801ca09e2709d7ec9bbe6b1bbbf0b2088828d14cd5e8642a1fee22dc74bfa89761a7f9a04bd8813dee4be989accdb708b1c2e325a7e9c695a8024e30e89d6c644e424747c0".from_hex().unwrap();
-		let b2 = "f902ccf901f9a0437e51676ff10756fcfee5edd9159fa41dbcb1b2c592850450371cbecd54ee4fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0c70a5dc56146e5ef025e4e5726a6373c6f12fd2f6784093a19ead0a7d17fb292a040645cbce4fd399e7bb9160b4c30c40d7ee616a030d4e18ef0ed3b02bdb65911a086e608555f63628417032a011d107b36427af37d153f0da02ce3f90fdd5e8c08b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004002832fefd882c0e384562791e880a0e3cc39ff775cc0a32f175995b92e84b729e5c9a3563ff899e3555b908bc21d75887c3cde283f4846a6f8cdf8cb01018304cb2f8080b87e6060604052606e8060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c0406226146037576035565b005b60406004506056565b6040518082815260200191505060405180910390f35b6000600560006000508190555060059050606b565b90561ba05258615c63503c0a600d6994b12ea5750d45b3c69668e2a371b4fbfb9eeff6b8a0a11be762bc90491231274a2945be35a43f23c27775b1ff24dd521702fe15f73ec0".from_hex().unwrap();
-		let b3a = "f90261f901f9a036fde1253128666fcb95a5956da14a73489e988bb72738717ec1d31e1cee781aa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a09dc4b1357c0b7b8108f8a098f4f9a1a274957bc9ebc22a9ae67ae81739e5b19ca007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefd882524d84562791eb80a074861666bd346c025889745c793b91ab9cd1e2ca19b5cf3c50d04d135b0a4d2b8809fe9587ea4cdc04f862f86002018304cb2f94ec0e71ad0a90ffe1909d27dac207f7680abba42d01801ba06fd84874d36d5de9e8e48978c03619b53a96b7ae0a4cd1ac118f103098b44801a00572596974dd7df4f9f69bd7456585618c568d8434ef6453391b89281ce12ae1c0".from_hex().unwrap();
-		let b3b = "f90265f901f9a036fde1253128666fcb95a5956da14a73489e988bb72738717ec1d31e1cee781aa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ab87dc338bfd6f662b1cd90bc0c9e40a1b2146a095312393c9e13ce3a5008b09a0e609b7a7d4b8a2403ec1268627ecd98783627246e8f1b26addb3ff504f76a054a0592fabf92476512952db3a69a2481a42912e668a1ee28c4c322e703bb665f8beb90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefd882a1f084562791ee80a0fe7098fa7e4ac5d637eea81fb23f8f78346826dbab430068dd9a249d0afa99818853e1a6b201ae3545f866f86402018304cb2f94ec0e71ad0a90ffe1909d27dac207f7680abba42d0284c04062261ca06edc9ce8e7da4cc34067beb325dcad59e5655a164a5100a50bc3eb681b12c716a0abf9053d5de65b1be81fe50d327b84de685efbeecea34e7b747180a6c6023e44c0".from_hex().unwrap();
+		let mut canon_chain = ChainGenerator::default();
+		let genesis = canon_chain.next().unwrap().rlp();
+		let blocks = canon_chain.clone().take(3).map(|block| block.rlp()).collect::<Vec<_>>();
+		let fork = canon_chain.skip(2).fork(1).take(1).next().unwrap().rlp();
 
-		let genesis_hash = H256::from_str("5716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2").unwrap();
-		let b1_hash = H256::from_str("437e51676ff10756fcfee5edd9159fa41dbcb1b2c592850450371cbecd54ee4f").unwrap();
-		let b2_hash = H256::from_str("36fde1253128666fcb95a5956da14a73489e988bb72738717ec1d31e1cee781a").unwrap();
-		let b3a_hash = H256::from_str("c208f88c9f5bf7e00840439742c12e5226d9752981f3ec0521bdcb6dd08af277").unwrap();
-		let b3b_hash = H256::from_str("bf72270ae0d95c9ea39a6adab994793fddb8c10fba7391e26279474124605d54").unwrap();
+		let b1 = blocks[0].clone();
+		let b2 = blocks[1].clone();
+		let b3a = blocks[2].clone();
+		let b3b = fork;
+
+		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
+		let b1_hash= BlockView::new(&b1).header_view().sha3();
+		let b2_hash= BlockView::new(&b2).header_view().sha3();
+		let b3a_hash= BlockView::new(&b3a).header_view().sha3();
+		let b3b_hash= BlockView::new(&b3b).header_view().sha3();
 
 		// b3a is a part of canon chain, whereas b3b is part of sidechain
-		let best_block_hash = H256::from_str("c208f88c9f5bf7e00840439742c12e5226d9752981f3ec0521bdcb6dd08af277").unwrap();
+		let best_block_hash = b3a_hash.clone();
 
 		let temp = RandomTempPath::new();
 		let bc = BlockChain::new(BlockChainConfig::default(), &genesis, temp.as_path());
diff --git a/ethcore/src/blockchain/helpers/generators.rs b/ethcore/src/blockchain/helpers/generators.rs
index 75e7655eb..a20b0cf79 100644
--- a/ethcore/src/blockchain/helpers/generators.rs
+++ b/ethcore/src/blockchain/helpers/generators.rs
@@ -21,23 +21,81 @@ use util::bytes::Bytes;
 use header::{BlockNumber, Header};
 use transaction::SignedTransaction;
 
+pub trait Forkable {
+	fn fork(self, fork_number: usize) -> Self where Self: Sized;
+}
+
+pub struct Fork<I> {
+	iter: I,
+	fork_number: usize,
+}
+
+impl<I> Iterator for Fork<I> where I: Iterator, <I as Iterator>::Item: Forkable {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.fork(self.fork_number))
+	}
+}
+
+pub trait WithBloom {
+	fn with_bloom(self, bloom: H2048) -> Self where Self: Sized;
+}
+
+pub struct Bloom<I> {
+	iter: I,
+	bloom: H2048,
+}
+
+impl<I> Iterator for Bloom<I> where I: Iterator, <I as Iterator>::Item: WithBloom {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.with_bloom(self.bloom.clone()))
+	}
+}
+
 /// Chain iterator interface.
 pub trait ChainIterator: Iterator {
 	/// Should be called to create a fork of current iterator.
 	/// Blocks generated by fork will have lower difficulty than current chain.
-	fn fork(&mut self) -> Self;
-	/// Should be called to create new block with given bloom.
-	fn next_with_bloom(&mut self, bloom: H2048) -> Option<Self::Item>;
+	fn fork(&mut self, fork_number: usize) -> Fork<Self> where Self: Sized;
+	/// Should be called to make every consecutive block have given bloom.
+	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self> where Self: Sized;
+}
+
+impl<I> ChainIterator for I where I: Iterator + Sized + Clone {
+	fn fork(&mut self, fork_number: usize) -> Fork<Self> {
+		Fork {
+			iter: self.clone(),
+			fork_number: fork_number
+		}
+	}
+
+	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self> {
+		Bloom {
+			iter: self.clone(),
+			bloom: bloom
+		}
+	}
 }
 
 /// Helper structure, used for encoding blocks.
 #[derive(Default)]
-struct Block {
+pub struct Block {
 	header: Header,
 	transactions: Vec<SignedTransaction>,
 	uncles: Vec<Header>
 }
 
+impl Block {
+	pub fn rlp(&self) -> Bytes {
+		encode(self).to_vec()
+	}
+}
+
 impl Encodable for Block {
 	fn rlp_append(&self, s: &mut RlpStream) {
 		s.begin_list(3);
@@ -47,7 +105,22 @@ impl Encodable for Block {
 	}
 }
 
+impl Forkable for Block {
+	fn fork(mut self, fork_number: usize) -> Self where Self: Sized {
+		self.header.difficulty = self.header.difficulty - U256::from(fork_number);
+		self
+	}
+}
+
+impl WithBloom for Block {
+	fn with_bloom(mut self, bloom: H2048) -> Self where Self: Sized {
+		self.header.log_bloom = bloom;
+		self
+	}
+}
+
 /// Blockchain generator.
+#[derive(Clone)]
 pub struct ChainGenerator {
 	/// Next block number.
 	number: BlockNumber,
@@ -55,8 +128,6 @@ pub struct ChainGenerator {
 	parent_hash: H256,
 	/// Next block difficulty.
 	difficulty: U256,
-	/// Number of forks of current block.
-	number_of_forks: usize,
 }
 
 impl ChainGenerator {
@@ -75,43 +146,21 @@ impl Default for ChainGenerator {
 			number: 0,
 			parent_hash: H256::default(),
 			difficulty: U256::from(1000),
-			number_of_forks: 0
 		}
 	}
 }
 
 impl Iterator for ChainGenerator {
-	type Item = Bytes;
+	type Item = Block;
 
 	fn next(&mut self) -> Option<Self::Item> {
 		let block = self.prepare_block();
 		self.number += 1;
 		self.parent_hash = block.header.hash();
-		self.number_of_forks = 0;
-		Some(encode(&block).to_vec())
+		Some(block)
 	}
 }
 
-impl ChainIterator for ChainGenerator {
-	fn fork(&mut self) -> Self {
-		self.number_of_forks += 1;
-		ChainGenerator {
-			number: self.number,
-			parent_hash: self.parent_hash.clone(),
-			difficulty: self.difficulty - U256::from(self.number_of_forks),
-			number_of_forks: 0
-		}
-	}
-
-	fn next_with_bloom(&mut self, bloom: H2048) -> Option<Self::Item> {
-		let mut block = self.prepare_block();
-		block.header.log_bloom = bloom;
-		self.number += 1;
-		self.parent_hash = block.header.hash();
-		self.number_of_forks = 0;
-		Some(encode(&block).to_vec())
-	}
-}
 
 #[cfg(test)]
 mod tests {
@@ -124,27 +173,27 @@ mod tests {
 	fn canon_chain_generator() {
 		let mut canon_chain = ChainGenerator::default();
 
-		let genesis_rlp = canon_chain.next().unwrap();
+		let genesis_rlp = canon_chain.next().unwrap().rlp();
 		let genesis = BlockView::new(&genesis_rlp);
 
 		assert_eq!(genesis.header_view().parent_hash(), H256::default());
 		assert_eq!(genesis.header_view().number(), 0);
 
-		let b1_rlp = canon_chain.next().unwrap();
+		let b1_rlp = canon_chain.next().unwrap().rlp();
 		let b1 = BlockView::new(&b1_rlp);
 
 		assert_eq!(b1.header_view().parent_hash(), genesis.header_view().sha3());
 		assert_eq!(b1.header_view().number(), 1);
 
-		let mut fork_chain = canon_chain.fork();
+		let mut fork_chain = canon_chain.fork(1);
 
-		let b2_rlp_fork = fork_chain.next().unwrap();
+		let b2_rlp_fork = fork_chain.next().unwrap().rlp();
 		let b2_fork = BlockView::new(&b2_rlp_fork);
 
 		assert_eq!(b2_fork.header_view().parent_hash(), b1.header_view().sha3());
 		assert_eq!(b2_fork.header_view().number(), 2);
 
-		let b2_rlp = canon_chain.next().unwrap();
+		let b2_rlp = canon_chain.next().unwrap().rlp();
 		let b2 = BlockView::new(&b2_rlp);
 
 		assert_eq!(b2.header_view().parent_hash(), b1.header_view().sha3());

From 48df869202571360b4554544bf4400f19a0236d3 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 16:58:14 +0100
Subject: [PATCH 13/37] --author and --extra-data options. Fixed null
 parent-hash.

---
 ethcore/src/block.rs    | 12 +++++++---
 ethcore/src/client.rs   | 50 +++++++++++++++++++++++++++++++++--------
 ethcore/src/header.rs   | 10 ++++++---
 parity/main.rs          | 20 +++++++++++++++++
 rpc/src/v1/impls/eth.rs |  6 ++---
 util/src/misc.rs        | 15 +++++++++++++
 6 files changed, 95 insertions(+), 18 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index f72c2f800..16d3e2216 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -182,6 +182,7 @@ impl<'x> OpenBlock<'x> {
 		r.block.base.header.set_author(author);
 		r.block.base.header.set_extra_data(extra_data);
 		r.block.base.header.set_timestamp_now(parent.timestamp());
+		r.block.base.header.set_parent_hash(parent.hash());
 
 		engine.populate_from_parent(&mut r.block.base.header, parent);
 		engine.on_new_block(&mut r.block);
@@ -308,10 +309,15 @@ impl ClosedBlock {
 	pub fn try_seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock> {
 		let mut s = self;
 		s.block.base.header.set_seal(seal);
-		match engine.verify_block_basic(&s.block.base.header, None).is_err() || engine.verify_block_unordered(&s.block.base.header, None).is_err() {
-			false => Err(s),
-			true => Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes }),
+		if let Err(e) = engine.verify_block_basic(&s.block.base.header, None) {
+			debug!("Failed to try_seal: {:?}", e);
+			return Err(s);
 		}
+		if let Err(e) = engine.verify_block_unordered(&s.block.base.header, None) {
+			debug!("Failed to try_seal: {:?}", e);
+			return Err(s);
+		}
+		Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes })
 	}
 
 	/// Drop this object and return the underlieing database.
diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index c5aa987f6..de875348a 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -196,6 +196,8 @@ pub struct Client {
 
 	// for sealing...
 	sealing_block: Mutex<Option<ClosedBlock>>,
+	author: RwLock<Address>,
+	extra_data: RwLock<Bytes>,
 }
 
 const HISTORY: u64 = 1000;
@@ -233,6 +235,8 @@ impl Client {
 			import_lock: Mutex::new(()),
 			panic_handler: panic_handler,
 			sealing_block: Mutex::new(None),
+			author: RwLock::new(Address::new()),
+			extra_data: RwLock::new(Vec::new()),
 		}))
 	}
 
@@ -364,7 +368,7 @@ impl Client {
 		}
 
 		if self.chain_info().best_block_hash != original_best {
-			self.new_chain_head();
+			self.prepare_sealing();
 		}
 
 		imported
@@ -414,27 +418,55 @@ impl Client {
 		}
 	}
 
-	/// New chain head event.
-	pub fn new_chain_head(&self) {
+	/// Set the author that we will seal blocks as.
+	pub fn author(&self) -> Address {
+		self.author.read().unwrap().clone()
+	}
+
+	/// Set the author that we will seal blocks as.
+	pub fn set_author(&self, author: Address) {
+		*self.author.write().unwrap() = author;
+	}
+
+	/// Set the extra_data that we will seal blocks wuth.
+	pub fn extra_data(&self) -> Bytes {
+		self.extra_data.read().unwrap().clone()
+	}
+
+	/// Set the extra_data that we will seal blocks with.
+	pub fn set_extra_data(&self, extra_data: Bytes) {
+		*self.extra_data.write().unwrap() = extra_data;
+	}
+
+	/// New chain head event. Restart mining operation.
+	pub fn prepare_sealing(&self) {
 		let h = self.chain.read().unwrap().best_block_hash();
-		debug!("New best block: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
 		let b = OpenBlock::new(
 			self.engine.deref().deref(),
 			self.state_db.lock().unwrap().clone(),
 			match self.chain.read().unwrap().block_header(&h) { Some(ref x) => x, None => {return;} },
-			self.build_last_hashes(h.clone()),
-			x!("0037a6b811ffeb6e072da21179d11b1406371c63"),
-			b"Parity".to_vec()
+			self.build_last_hashes(h),
+			self.author(),
+			self.extra_data()
 		);
+		// TODO: push uncles.
+		// TODO: push transactions.
 		let b = b.close();
-		debug!("Sealing: hash={}, diff={}, number={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
+		trace!("Sealing: number={}, hash={}, diff={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
+		debug!("Header: {:?}", b.block().header());
 		*self.sealing_block.lock().unwrap() = Some(b);
 	}
 
 	/// Grab the `ClosedBlock` that we want to be sealed. Comes as a mutex that you have to lock.
-	pub fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>> { &self.sealing_block }
+	pub fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>> {
+		if self.sealing_block.lock().unwrap().is_none() {
+			self.prepare_sealing();
+		}
+		&self.sealing_block
+	}
 
 	/// Submit `seal` as a valid solution for the header of `pow_hash`.
+	/// Will check the seal, but not actually insert the block into the chain.
 	pub fn submit_seal(&self, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error> {
 		let mut maybe_b = self.sealing_block.lock().unwrap();
 		match *maybe_b {
diff --git a/ethcore/src/header.rs b/ethcore/src/header.rs
index 3db0be5ff..cc02d84db 100644
--- a/ethcore/src/header.rs
+++ b/ethcore/src/header.rs
@@ -102,10 +102,12 @@ impl Header {
 		Self::default()
 	}
 
-	/// Get the number field of the header.
-	pub fn number(&self) -> BlockNumber { self.number }
+	/// Get the parent_hash field of the header.
+	pub fn parent_hash(&self) -> &H256 { &self.parent_hash }
 	/// Get the timestamp field of the header.
 	pub fn timestamp(&self) -> u64 { self.timestamp }
+	/// Get the number field of the header.
+	pub fn number(&self) -> BlockNumber { self.number }
 	/// Get the author field of the header.
 	pub fn author(&self) -> &Address { &self.author }
 
@@ -127,11 +129,13 @@ impl Header {
 	// TODO: seal_at, set_seal_at &c.
 
 	/// Set the number field of the header.
-	pub fn set_number(&mut self, a: BlockNumber) { self.number = a; self.note_dirty(); }
+	pub fn set_parent_hash(&mut self, a: H256) { self.parent_hash = a; self.note_dirty(); }
 	/// Set the timestamp field of the header.
 	pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
 	/// Set the timestamp field of the header to the current time.
 	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = max(now_utc().to_timespec().sec as u64, but_later_than + 1); self.note_dirty(); }
+	/// Set the number field of the header.
+	pub fn set_number(&mut self, a: BlockNumber) { self.number = a; self.note_dirty(); }
 	/// Set the author field of the header.
 	pub fn set_author(&mut self, a: Address) { if a != self.author { self.author = a; self.note_dirty(); } }
 
diff --git a/parity/main.rs b/parity/main.rs
index 7241a2ac4..b991f36cd 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -85,6 +85,10 @@ Options:
   --jsonrpc-url URL        Specify URL for JSON-RPC API server [default: 127.0.0.1:8545].
   --jsonrpc-cors URL       Specify CORS header for JSON-RPC API responses [default: null].
 
+  --author ADDRESS         Specify the block author (aka "coinbase") address for sending block rewards
+                           from sealed blocks [default: 0037a6b811ffeb6e072da21179d11b1406371c63].
+  --extra-data STRING      Specify a custom extra-data for authored blocks, no more than 32 characters.
+
   -l --logging LOGGING     Specify the logging level.
   -v --version             Show information about version.
   -h --help                Show this screen.
@@ -114,6 +118,8 @@ struct Args {
 	flag_jsonrpc_cors: String,
 	flag_logging: Option<String>,
 	flag_version: bool,
+	flag_author: String,
+	flag_extra_data: Option<String>,
 }
 
 fn setup_log(init: &Option<String>) {
@@ -196,6 +202,18 @@ impl Configuration {
 		self.args.flag_db_path.replace("$HOME", env::home_dir().unwrap().to_str().unwrap())
 	}
 
+	fn author(&self) -> Address {
+		Address::from_str(&self.args.flag_author).unwrap_or_else(|_| die!("{}: Invalid address for --author. Must be 40 hex characters, without the 0x at the beginning.", self.args.flag_author))
+	}
+
+	fn extra_data(&self) -> Bytes {
+		match self.args.flag_extra_data {
+			Some(ref x) if x.len() <= 32 => x.as_bytes().to_owned(),
+			None => version_data(),
+			Some(ref x) => { die!("{}: Extra data must be at most 32 characters.", x); }
+		}
+	}
+
 	fn _keys_path(&self) -> String {
 		self.args.flag_keys_path.replace("$HOME", env::home_dir().unwrap().to_str().unwrap())
 	}
@@ -296,6 +314,8 @@ impl Configuration {
 		client_config.queue.max_mem_use = self.args.flag_queue_max_size;
 		let mut service = ClientService::start(client_config, spec, net_settings, &Path::new(&self.path())).unwrap();
 		let client = service.client().clone();
+		client.set_author(self.author());
+		client.set_extra_data(self.extra_data());
 
 		// Sync
 		let sync = EthSync::register(service.network(), sync_config, client);
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 24ecbe5f1..a7583ddf7 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -236,12 +236,12 @@ impl Eth for EthClient {
 	}
 
 	fn submit_work(&self, params: Params) -> Result<Value, Error> {
-		// TODO: println! should be debug!
-		println!("Work submission: {:?}", params);
 		from_params::<(H64, H256, H256)>(params).and_then(|(nonce, pow_hash, mix_hash)| {
+//			trace!("Decoded: nonce={}, pow_hash={}, mix_hash={}", nonce, pow_hash, mix_hash);
 			let c = take_weak!(self.client);
 			let seal = vec![encode(&mix_hash).to_vec(), encode(&nonce).to_vec()];
-			to_value(&c.submit_seal(pow_hash, seal).is_ok())
+			let r = c.submit_seal(pow_hash, seal);
+			to_value(&r.is_ok())
 		})
 	}
 
diff --git a/util/src/misc.rs b/util/src/misc.rs
index 35e1f3a75..d9f52fd71 100644
--- a/util/src/misc.rs
+++ b/util/src/misc.rs
@@ -18,6 +18,7 @@
 
 use std::fs::File;
 use common::*;
+use rlp::{Stream, RlpStream};
 use target_info::Target;
 use rustc_version;
 
@@ -70,4 +71,18 @@ pub fn contents(name: &str) -> Result<Bytes, UtilError> {
 /// Get the standard version string for this software.
 pub fn version() -> String {
 	format!("Parity//v{}-{}-{}/{}-{}-{}/rustc{}", env!("CARGO_PKG_VERSION"), short_sha(), commit_date().replace("-", ""), Target::arch(), Target::os(), Target::env(), rustc_version::version())
+}
+
+/// Get the standard version data for this software.
+pub fn version_data() -> Bytes {
+	let mut s = RlpStream::new_list(4);
+	let v =
+		(u32::from_str(env!("CARGO_PKG_VERSION_MAJOR")).unwrap() << 16) +
+		(u32::from_str(env!("CARGO_PKG_VERSION_MINOR")).unwrap() << 8) +
+		u32::from_str(env!("CARGO_PKG_VERSION_PATCH")).unwrap();
+	s.append(&v);
+	s.append(&"Parity");
+	s.append(&format!("rustc{}", rustc_version::version()));
+	s.append(&Target::os());
+	s.out()
 }
\ No newline at end of file

From a5c65b2a3d1aa9a13d680a7efb122be28e47f9b0 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 16:59:01 +0100
Subject: [PATCH 14/37] Reduce spam.

---
 ethcore/src/client.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index de875348a..e5d9f8fcf 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -453,7 +453,6 @@ impl Client {
 		// TODO: push transactions.
 		let b = b.close();
 		trace!("Sealing: number={}, hash={}, diff={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
-		debug!("Header: {:?}", b.block().header());
 		*self.sealing_block.lock().unwrap() = Some(b);
 	}
 

From afc06050807867ee27a6830aaf15eee29042c60d Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 17:23:44 +0100
Subject: [PATCH 15/37] Refactor engine to make it clear that we're actually
 checking the seal.

---
 ethcore/src/block.rs  | 11 +++--------
 ethcore/src/engine.rs |  7 +++++++
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index 16d3e2216..eb9d66124 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -309,15 +309,10 @@ impl ClosedBlock {
 	pub fn try_seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock> {
 		let mut s = self;
 		s.block.base.header.set_seal(seal);
-		if let Err(e) = engine.verify_block_basic(&s.block.base.header, None) {
-			debug!("Failed to try_seal: {:?}", e);
-			return Err(s);
+		match engine.verify_block_seal(&s.block.base.header) {
+			Err(_) => Err(s),
+			_ => Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes }),
 		}
-		if let Err(e) = engine.verify_block_unordered(&s.block.base.header, None) {
-			debug!("Failed to try_seal: {:?}", e);
-			return Err(s);
-		}
-		Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes })
 	}
 
 	/// Drop this object and return the underlieing database.
diff --git a/ethcore/src/engine.rs b/ethcore/src/engine.rs
index c57be3cdb..a05c78ff5 100644
--- a/ethcore/src/engine.rs
+++ b/ethcore/src/engine.rs
@@ -74,6 +74,13 @@ pub trait Engine : Sync + Send {
 	/// Verify a particular transaction is valid.
 	fn verify_transaction(&self, _t: &SignedTransaction, _header: &Header) -> Result<(), Error> { Ok(()) }
 
+	/// Verify the seal of a block. This is an auxilliary method that actually just calls other `verify_` methods
+	/// to get the job done. By default it must pass `verify_basic` and `verify_block_unordered`. If more or fewer
+	/// methods are needed for an Engine, this may be overridden.
+	fn verify_block_seal(&self, header: &Header) -> Result<(), Error> {
+		self.verify_block_basic(header, None).and_then(|_| self.verify_block_unordered(header, None))
+	}
+
 	/// Don't forget to call Super::populateFromParent when subclassing & overriding.
 	// TODO: consider including State in the params.
 	fn populate_from_parent(&self, _header: &mut Header, _parent: &Header) {}

From 140711dd8ac6dbd55d3210bc6609711fae73f5a1 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 19:59:12 +0100
Subject: [PATCH 16/37] Fixups from review. Reduce size of default extra-data.
 Introduce find_uncle_headers.

---
 ethcore/src/block.rs                 |  2 +-
 ethcore/src/block_queue.rs           |  2 +-
 ethcore/src/blockchain/blockchain.rs |  6 ++++++
 ethcore/src/client.rs                | 13 ++++++++-----
 util/src/misc.rs                     |  4 ++--
 5 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index eb9d66124..582b8669a 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -404,7 +404,7 @@ mod tests {
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
 		engine.spec().ensure_db_good(&mut db);
-		let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(&engine, vec![]).unwrap();
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();
 
diff --git a/ethcore/src/block_queue.rs b/ethcore/src/block_queue.rs
index 143f53647..490a17995 100644
--- a/ethcore/src/block_queue.rs
+++ b/ethcore/src/block_queue.rs
@@ -455,7 +455,7 @@ mod tests {
 		match duplicate_import {
 			Err(e) => {
 				match e {
-					ImportError::AlreadyQueued => {},
+					Error::Import(ImportError::AlreadyQueued) => {},
 					_ => { panic!("must return AlreadyQueued error"); }
 				}
 			}
diff --git a/ethcore/src/blockchain/blockchain.rs b/ethcore/src/blockchain/blockchain.rs
index 0aba36a8e..88a6504ac 100644
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@@ -473,6 +473,12 @@ impl BlockChain {
 		self.extras_db.write(batch).unwrap();
 	}
 
+	/// Given a block's `parent`, find every block header which represents a valid uncle.
+	pub fn find_uncle_headers(&self, _parent: &H256) -> Vec<Header> {
+		// TODO
+		Vec::new()
+	}
+
 	/// Get inserted block info which is critical to preapre extras updates.
 	fn block_info(&self, block_bytes: &[u8]) -> BlockInfo {
 		let block = BlockView::new(block_bytes);
diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index e5d9f8fcf..4b109c8a3 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -418,7 +418,7 @@ impl Client {
 		}
 	}
 
-	/// Set the author that we will seal blocks as.
+	/// Get the author that we will seal blocks as.
 	pub fn author(&self) -> Address {
 		self.author.read().unwrap().clone()
 	}
@@ -428,7 +428,7 @@ impl Client {
 		*self.author.write().unwrap() = author;
 	}
 
-	/// Set the extra_data that we will seal blocks wuth.
+	/// Get the extra_data that we will seal blocks wuth.
 	pub fn extra_data(&self) -> Bytes {
 		self.extra_data.read().unwrap().clone()
 	}
@@ -441,16 +441,19 @@ impl Client {
 	/// New chain head event. Restart mining operation.
 	pub fn prepare_sealing(&self) {
 		let h = self.chain.read().unwrap().best_block_hash();
-		let b = OpenBlock::new(
+		let mut b = OpenBlock::new(
 			self.engine.deref().deref(),
 			self.state_db.lock().unwrap().clone(),
 			match self.chain.read().unwrap().block_header(&h) { Some(ref x) => x, None => {return;} },
-			self.build_last_hashes(h),
+			self.build_last_hashes(h.clone()),
 			self.author(),
 			self.extra_data()
 		);
-		// TODO: push uncles.
+
+		self.chain.read().unwrap().find_uncle_headers(&h).into_iter().foreach(|h| { b.push_uncle(h).unwrap(); });
+
 		// TODO: push transactions.
+
 		let b = b.close();
 		trace!("Sealing: number={}, hash={}, diff={}", b.hash(), b.block().header().difficulty(), b.block().header().number());
 		*self.sealing_block.lock().unwrap() = Some(b);
diff --git a/util/src/misc.rs b/util/src/misc.rs
index d9f52fd71..6cd506d02 100644
--- a/util/src/misc.rs
+++ b/util/src/misc.rs
@@ -82,7 +82,7 @@ pub fn version_data() -> Bytes {
 		u32::from_str(env!("CARGO_PKG_VERSION_PATCH")).unwrap();
 	s.append(&v);
 	s.append(&"Parity");
-	s.append(&format!("rustc{}", rustc_version::version()));
-	s.append(&Target::os());
+	s.append(&format!("{}", rustc_version::version()));
+	s.append(&&Target::os()[0..2]);
 	s.out()
 }
\ No newline at end of file

From 628a53cceca9ad2b66d8c7510331ad23cc50134c Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 20:02:59 +0100
Subject: [PATCH 17/37] Update tests. Fix our tests.

---
 ethcore/res/ethereum/tests | 2 +-
 ethcore/src/block.rs       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/ethcore/res/ethereum/tests b/ethcore/res/ethereum/tests
index f32954b3d..99afe8f5a 160000
--- a/ethcore/res/ethereum/tests
+++ b/ethcore/res/ethereum/tests
@@ -1 +1 @@
-Subproject commit f32954b3ddb5af2dc3dc9ec6d9a28bee848fdf70
+Subproject commit 99afe8f5aad7bca5d0f1b1685390a4dea32d73c3
diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index 582b8669a..0ca6e88be 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -404,7 +404,7 @@ mod tests {
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
 		engine.spec().ensure_db_good(&mut db);
-		let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(&engine, vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), vec![]).close().seal(engine.deref(), vec![]).unwrap();
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();
 

From a21fda23a6e1c954f284bfff6cf7ac2797dbec4b Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 20:14:28 +0100
Subject: [PATCH 18/37] Enable transition test.

---
 ethcore/src/json_tests/state.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ethcore/src/json_tests/state.rs b/ethcore/src/json_tests/state.rs
index b5f28444a..f6b5751a7 100644
--- a/ethcore/src/json_tests/state.rs
+++ b/ethcore/src/json_tests/state.rs
@@ -115,7 +115,7 @@ declare_test!{StateTests_stSolidityTest, "StateTests/stSolidityTest"}
 declare_test!{StateTests_stSpecialTest, "StateTests/stSpecialTest"}
 declare_test!{StateTests_stSystemOperationsTest, "StateTests/stSystemOperationsTest"}
 declare_test!{StateTests_stTransactionTest, "StateTests/stTransactionTest"}
-//declare_test!{StateTests_stTransitionTest, "StateTests/stTransitionTest"}
+declare_test!{StateTests_stTransitionTest, "StateTests/stTransitionTest"}
 declare_test!{StateTests_stWalletTest, "StateTests/stWalletTest"}
 
 

From aab274d3ef4478120167e1076a0324580cffd516 Mon Sep 17 00:00:00 2001
From: Tomusdrw <tomusdrw@gmail.com>
Date: Thu, 18 Feb 2016 23:01:35 +0100
Subject: [PATCH 19/37] Changing RefCell to Cell in transaction. Implementing
 Copy on Uints.

---
 ethcore/src/transaction.rs | 52 ++++++++++++++++++++------------------
 util/src/hash.rs           |  2 ++
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/ethcore/src/transaction.rs b/ethcore/src/transaction.rs
index fc9886a4d..a51824494 100644
--- a/ethcore/src/transaction.rs
+++ b/ethcore/src/transaction.rs
@@ -100,10 +100,10 @@ impl FromJson for SignedTransaction {
 				v: match json.find("v") { Some(ref j) => u16::from_json(j) as u8, None => 0 },
 				r: match json.find("r") { Some(j) => xjson!(j), None => x!(0) },
 				s: match json.find("s") { Some(j) => xjson!(j), None => x!(0) },
-				hash: RefCell::new(None),
+				hash: Cell::new(None),
 				sender: match json.find("sender") {
-					Some(&Json::String(ref sender)) => RefCell::new(Some(address_from_hex(clean(sender)))),
-					_ => RefCell::new(None),
+					Some(&Json::String(ref sender)) => Cell::new(Some(address_from_hex(clean(sender)))),
+					_ => Cell::new(None),
 				}
 			}
 		}
@@ -127,8 +127,8 @@ impl Transaction {
 			r: r,
 			s: s,
 			v: v + 27,
-			hash: RefCell::new(None),
-			sender: RefCell::new(None)
+			hash: Cell::new(None),
+			sender: Cell::new(None),
 		}
 	}
 
@@ -140,8 +140,8 @@ impl Transaction {
 			r: U256::zero(),
 			s: U256::zero(),
 			v: 0,
-			hash: RefCell::new(None),
-			sender: RefCell::new(None)
+			hash: Cell::new(None),
+			sender: Cell::new(None),
 		}
 	}
 
@@ -171,9 +171,9 @@ pub struct SignedTransaction {
 	/// The S field of the signature; helps describe the point on the curve.
 	s: U256,
 	/// Cached hash.
-	hash: RefCell<Option<H256>>,
+	hash: Cell<Option<H256>>,
 	/// Cached sender.
-	sender: RefCell<Option<Address>>
+	sender: Cell<Option<Address>>,
 }
 
 impl PartialEq for SignedTransaction {
@@ -208,8 +208,8 @@ impl Decodable for SignedTransaction {
 			v: try!(d.val_at(6)),
 			r: try!(d.val_at(7)),
 			s: try!(d.val_at(8)),
-			hash: RefCell::new(None),
-			sender: RefCell::new(None),
+			hash: Cell::new(None),
+			sender: Cell::new(None),
 		})
 	}
 }
@@ -238,13 +238,14 @@ impl SignedTransaction {
 
 	/// Get the hash of this header (sha3 of the RLP).
 	pub fn hash(&self) -> H256 {
- 		let mut hash = self.hash.borrow_mut();
- 		match &mut *hash {
- 			&mut Some(ref h) => h.clone(),
- 			hash @ &mut None => {
- 				*hash = Some(self.rlp_sha3());
- 				hash.as_ref().unwrap().clone()
- 			}
+		let hash = self.hash.get();
+		match hash {
+			Some(h) => h,
+			None => {
+				let h = self.rlp_sha3();
+				self.hash.set(Some(h));
+				h
+			}
 		}
 	}
 
@@ -265,13 +266,14 @@ impl SignedTransaction {
 
 	/// Returns transaction sender.
 	pub fn sender(&self) -> Result<Address, Error> {
- 		let mut sender = self.sender.borrow_mut();
- 		match &mut *sender {
- 			&mut Some(ref h) => Ok(h.clone()),
- 			sender @ &mut None => {
- 				*sender = Some(From::from(try!(ec::recover(&self.signature(), &self.unsigned.hash())).sha3()));
- 				Ok(sender.as_ref().unwrap().clone())
- 			}
+		let sender = self.sender.get();
+		match sender {
+			Some(s) => Ok(s),
+			None => {
+				let s = Address::from(try!(ec::recover(&self.signature(), &self.unsigned.hash())).sha3());
+				self.sender.set(Some(s));
+				Ok(s)
+			}
 		}
 	}
 
diff --git a/util/src/hash.rs b/util/src/hash.rs
index 88c57371e..3f708631a 100644
--- a/util/src/hash.rs
+++ b/util/src/hash.rs
@@ -304,6 +304,8 @@ macro_rules! impl_hash {
 			}
 		}
 
+		impl Copy for $from {}
+		#[cfg_attr(feature="dev", allow(expl_impl_clone_on_copy))]
 		impl Clone for $from {
 			fn clone(&self) -> $from {
 				unsafe {

From 8c9c701de551d8c9d9af71991fd8ca10064f36ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Tue, 1 Mar 2016 21:31:58 +0100
Subject: [PATCH 20/37] Fixing spelling in propagade->propagate

---
 sync/src/chain.rs       | 34 +++++++++++++++++-----------------
 sync/src/tests/chain.rs |  4 ++--
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/sync/src/chain.rs b/sync/src/chain.rs
index 6a7add27f..85380f3cd 100644
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -249,14 +249,14 @@ impl ChainSync {
 			blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
 			num_peers: self.peers.len(),
 			num_active_peers: self.peers.values().filter(|p| p.asking != PeerAsking::Nothing).count(),
-			mem_used: 
+			mem_used:
 				//  TODO: https://github.com/servo/heapsize/pull/50
-				//  self.downloading_hashes.heap_size_of_children() 
-				//+ self.downloading_bodies.heap_size_of_children() 
-				//+ self.downloading_hashes.heap_size_of_children() 
-				self.headers.heap_size_of_children() 
-				+ self.bodies.heap_size_of_children() 
-				+ self.peers.heap_size_of_children() 
+				//  self.downloading_hashes.heap_size_of_children()
+				//+ self.downloading_bodies.heap_size_of_children()
+				//+ self.downloading_hashes.heap_size_of_children()
+				self.headers.heap_size_of_children()
+				+ self.bodies.heap_size_of_children()
+				+ self.peers.heap_size_of_children()
 				+ self.header_ids.heap_size_of_children(),
 		}
 	}
@@ -1171,8 +1171,8 @@ impl ChainSync {
 			.collect::<Vec<_>>()
 	}
 
-	/// propagades latest block to lagging peers
-	fn propagade_blocks(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
+	/// propagates latest block to lagging peers
+	fn propagate_blocks(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
 		let updated_peers = {
 			let lagging_peers = self.get_lagging_peers(io);
 
@@ -1198,8 +1198,8 @@ impl ChainSync {
 		sent
 	}
 
-	/// propagades new known hashes to all peers
-	fn propagade_new_hashes(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
+	/// propagates new known hashes to all peers
+	fn propagate_new_hashes(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
 		let updated_peers = self.get_lagging_peers(io);
 		let mut sent = 0;
 		let last_parent = HeaderView::new(&io.chain().block_header(BlockId::Hash(local_best.clone())).unwrap()).parent_hash();
@@ -1234,8 +1234,8 @@ impl ChainSync {
 	pub fn chain_blocks_verified(&mut self, io: &mut SyncIo) {
 		let chain = io.chain().chain_info();
 		if (((chain.best_block_number as i64) - (self.last_send_block_number as i64)).abs() as BlockNumber) < MAX_PEER_LAG_PROPAGATION {
-			let blocks = self.propagade_blocks(&chain.best_block_hash, chain.best_block_number, io);
-			let hashes = self.propagade_new_hashes(&chain.best_block_hash, chain.best_block_number, io);
+			let blocks = self.propagate_blocks(&chain.best_block_hash, chain.best_block_number, io);
+			let hashes = self.propagate_new_hashes(&chain.best_block_hash, chain.best_block_number, io);
 			if blocks != 0 || hashes != 0 {
 				trace!(target: "sync", "Sent latest {} blocks and {} hashes to peers.", blocks, hashes);
 			}
@@ -1419,7 +1419,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);
 
-		let peer_count = sync.propagade_new_hashes(&best_hash, best_number, &mut io);
+		let peer_count = sync.propagate_new_hashes(&best_hash, best_number, &mut io);
 
 		// 1 message should be send
 		assert_eq!(1, io.queue.len());
@@ -1439,7 +1439,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);
 
-		let peer_count = sync.propagade_blocks(&best_hash, best_number, &mut io);
+		let peer_count = sync.propagate_blocks(&best_hash, best_number, &mut io);
 
 		// 1 message should be send
 		assert_eq!(1, io.queue.len());
@@ -1545,7 +1545,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);
 
-		sync.propagade_new_hashes(&best_hash, best_number, &mut io);
+		sync.propagate_new_hashes(&best_hash, best_number, &mut io);
 
 		let data = &io.queue[0].data.clone();
 		let result = sync.on_peer_new_hashes(&mut io, 0, &UntrustedRlp::new(&data));
@@ -1564,7 +1564,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);
 
-		sync.propagade_blocks(&best_hash, best_number, &mut io);
+		sync.propagate_blocks(&best_hash, best_number, &mut io);
 
 		let data = &io.queue[0].data.clone();
 		let result = sync.on_peer_new_block(&mut io, 0, &UntrustedRlp::new(&data));
diff --git a/sync/src/tests/chain.rs b/sync/src/tests/chain.rs
index 1dd9a1e78..b01c894a0 100644
--- a/sync/src/tests/chain.rs
+++ b/sync/src/tests/chain.rs
@@ -121,7 +121,7 @@ fn status_packet() {
 }
 
 #[test]
-fn propagade_hashes() {
+fn propagate_hashes() {
 	let mut net = TestNet::new(6);
 	net.peer_mut(1).chain.add_blocks(10, false);
 	net.sync();
@@ -147,7 +147,7 @@ fn propagade_hashes() {
 }
 
 #[test]
-fn propagade_blocks() {
+fn propagate_blocks() {
 	let mut net = TestNet::new(2);
 	net.peer_mut(1).chain.add_blocks(10, false);
 	net.sync();

From 30e7ac8d6d4a9f0f6553d48bedd82083266aaa7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Tue, 1 Mar 2016 21:54:53 +0100
Subject: [PATCH 21/37] Fixing trivial warnings

---
 util/src/table.rs | 2 +-
 util/src/uint.rs  | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/util/src/table.rs b/util/src/table.rs
index f04a498f8..e41209608 100644
--- a/util/src/table.rs
+++ b/util/src/table.rs
@@ -111,7 +111,7 @@ impl<Row, Col, Val> Table<Row, Col, Val>
 	///
 	/// Returns previous value (if any)
 	pub fn insert(&mut self, row: Row, col: Col, val: Val) -> Option<Val> {
-		self.map.entry(row).or_insert_with(|| HashMap::new()).insert(col, val)
+		self.map.entry(row).or_insert_with(HashMap::new).insert(col, val)
 	}
 }
 
diff --git a/util/src/uint.rs b/util/src/uint.rs
index 88256d5f2..068456334 100644
--- a/util/src/uint.rs
+++ b/util/src/uint.rs
@@ -1982,6 +1982,7 @@ mod tests {
 
 
 	#[test]
+	#[cfg_attr(feature = "dev", allow(cyclomatic_complexity))]
 	fn u256_multi_full_mul() {
 		let result = U256([0, 0, 0, 0]).full_mul(U256([0, 0, 0, 0]));
 		assert_eq!(U512([0, 0, 0, 0, 0, 0, 0, 0]), result);

From 083747dc674c63739cdde254ca9731e2fb784343 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Tue, 1 Mar 2016 22:03:29 +0100
Subject: [PATCH 22/37] Lowering complexity of request_blocks

---
 sync/src/chain.rs | 159 ++++++++++++++++++++++++----------------------
 1 file changed, 82 insertions(+), 77 deletions(-)

diff --git a/sync/src/chain.rs b/sync/src/chain.rs
index 6a7add27f..1d90e2d03 100644
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -249,14 +249,14 @@ impl ChainSync {
 			blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
 			num_peers: self.peers.len(),
 			num_active_peers: self.peers.values().filter(|p| p.asking != PeerAsking::Nothing).count(),
-			mem_used: 
+			mem_used:
 				//  TODO: https://github.com/servo/heapsize/pull/50
-				//  self.downloading_hashes.heap_size_of_children() 
-				//+ self.downloading_bodies.heap_size_of_children() 
-				//+ self.downloading_hashes.heap_size_of_children() 
-				self.headers.heap_size_of_children() 
-				+ self.bodies.heap_size_of_children() 
-				+ self.peers.heap_size_of_children() 
+				//  self.downloading_hashes.heap_size_of_children()
+				//+ self.downloading_bodies.heap_size_of_children()
+				//+ self.downloading_hashes.heap_size_of_children()
+				self.headers.heap_size_of_children()
+				+ self.bodies.heap_size_of_children()
+				+ self.peers.heap_size_of_children()
 				+ self.header_ids.heap_size_of_children(),
 		}
 	}
@@ -635,16 +635,7 @@ impl ChainSync {
 		match self.last_imported_block { None => 0, Some(x) => x }
 	}
 
-	/// Find some headers or blocks to download for a peer.
-	fn request_blocks(&mut self, io: &mut SyncIo, peer_id: PeerId, ignore_others: bool) {
-		self.clear_peer_download(peer_id);
-
-		if io.chain().queue_info().is_full() {
-			self.pause_sync();
-			return;
-		}
-
-		// check to see if we need to download any block bodies first
+	fn find_block_bodies_hashes_to_request(&self, ignore_others: bool) -> (Vec<H256>, Vec<BlockNumber>) {
 		let mut needed_bodies: Vec<H256> = Vec::new();
 		let mut needed_numbers: Vec<BlockNumber> = Vec::new();
 
@@ -664,74 +655,88 @@ impl ChainSync {
 				}
 			}
 		}
+		(needed_bodies, needed_numbers)
+	}
+
+	/// Find some headers or blocks to download for a peer.
+	fn request_blocks(&mut self, io: &mut SyncIo, peer_id: PeerId, ignore_others: bool) {
+		self.clear_peer_download(peer_id);
+
+		if io.chain().queue_info().is_full() {
+			self.pause_sync();
+			return;
+		}
+
+		// check to see if we need to download any block bodies first
+		let (needed_bodies, needed_numbers) = self.find_block_bodies_hashes_to_request(ignore_others);
 		if !needed_bodies.is_empty() {
 			let (head, _) = self.headers.range_iter().next().unwrap();
 			if needed_numbers.first().unwrap() - head > self.max_download_ahead_blocks as BlockNumber {
 				trace!(target: "sync", "{}: Stalled download ({} vs {}), helping with downloading block bodies", peer_id, needed_numbers.first().unwrap(), head);
 				self.request_blocks(io, peer_id, true);
-				return;
+			} else {
+				self.downloading_bodies.extend(needed_numbers.iter());
+				replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, needed_numbers);
+				self.request_bodies(io, peer_id, needed_bodies);
+			}
+			return;
+		}
+
+		// check if need to download headers
+		let mut start = 0;
+		if !self.have_common_block {
+			// download backwards until common block is found 1 header at a time
+			let chain_info = io.chain().chain_info();
+			start = chain_info.best_block_number;
+			if !self.headers.is_empty() {
+				start = min(start, self.headers.range_iter().next().unwrap().0 - 1);
+			}
+			if start == 0 {
+				self.have_common_block = true; //reached genesis
+				self.last_imported_hash = Some(chain_info.genesis_hash);
+				self.last_imported_block = Some(0);
+			}
+		}
+		if self.have_common_block {
+			let mut headers: Vec<BlockNumber> = Vec::new();
+			let mut prev = self.current_base_block() + 1;
+			let head = self.headers.range_iter().next().map(|(h, _)| h);
+			for (next, ref items) in self.headers.range_iter() {
+				if !headers.is_empty() {
+					break;
+				}
+				if next <= prev {
+					prev = next + items.len() as BlockNumber;
+					continue;
+				}
+				let mut block = prev;
+				while block < next && headers.len() < MAX_HEADERS_TO_REQUEST {
+					if ignore_others || !self.downloading_headers.contains(&(block as BlockNumber)) {
+						headers.push(block as BlockNumber);
+					}
+					block += 1;
+				}
+				prev = next + items.len() as BlockNumber;
+			}
+
+			if !headers.is_empty() {
+				start = headers[0];
+				if head.is_some() && start > head.unwrap() && start - head.unwrap() > self.max_download_ahead_blocks as BlockNumber {
+					trace!(target: "sync", "{}: Stalled download ({} vs {}), helping with downloading headers", peer_id, start, head.unwrap());
+					self.request_blocks(io, peer_id, true);
+					return;
+				}
+				let count = headers.len();
+				self.downloading_headers.extend(headers.iter());
+				replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, headers);
+				assert!(!self.headers.have_item(&start));
+				self.request_headers_by_number(io, peer_id, start, count, 0, false);
 			}
-			self.downloading_bodies.extend(needed_numbers.iter());
-			replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, needed_numbers);
-			self.request_bodies(io, peer_id, needed_bodies);
 		}
 		else {
-			// check if need to download headers
-			let mut start = 0;
-			if !self.have_common_block {
-				// download backwards until common block is found 1 header at a time
-				let chain_info = io.chain().chain_info();
-				start = chain_info.best_block_number;
-				if !self.headers.is_empty() {
-					start = min(start, self.headers.range_iter().next().unwrap().0 - 1);
-				}
-				if start == 0 {
-					self.have_common_block = true; //reached genesis
-					self.last_imported_hash = Some(chain_info.genesis_hash);
-					self.last_imported_block = Some(0);
-				}
-			}
-			if self.have_common_block {
-				let mut headers: Vec<BlockNumber> = Vec::new();
-				let mut prev = self.current_base_block() + 1;
-				let head = self.headers.range_iter().next().map(|(h, _)| h);
-				for (next, ref items) in self.headers.range_iter() {
-					if !headers.is_empty() {
-						break;
-					}
-					if next <= prev {
-						prev = next + items.len() as BlockNumber;
-						continue;
-					}
-					let mut block = prev;
-					while block < next && headers.len() < MAX_HEADERS_TO_REQUEST {
-						if ignore_others || !self.downloading_headers.contains(&(block as BlockNumber)) {
-							headers.push(block as BlockNumber);
-						}
-						block += 1;
-					}
-					prev = next + items.len() as BlockNumber;
-				}
-
-				if !headers.is_empty() {
-					start = headers[0];
-					if head.is_some() && start > head.unwrap() && start - head.unwrap() > self.max_download_ahead_blocks as BlockNumber {
-						trace!(target: "sync", "{}: Stalled download ({} vs {}), helping with downloading headers", peer_id, start, head.unwrap());
-						self.request_blocks(io, peer_id, true);
-						return;
-					}
-					let count = headers.len();
-					self.downloading_headers.extend(headers.iter());
-					replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, headers);
-					assert!(!self.headers.have_item(&start));
-					self.request_headers_by_number(io, peer_id, start, count, 0, false);
-				}
-			}
-			else {
-				// continue search for common block
-				self.downloading_headers.insert(start);
-				self.request_headers_by_number(io, peer_id, start, 1, 0, false);
-			}
+			// continue search for common block
+			self.downloading_headers.insert(start);
+			self.request_headers_by_number(io, peer_id, start, 1, 0, false);
 		}
 	}
 

From 929f44fe4f62910fc0eba95257953b09ccd52b24 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Wed, 2 Mar 2016 00:34:38 +0100
Subject: [PATCH 23/37] Tests for Client sealing.

---
 ethcore/src/engine.rs          |  9 +++++++--
 ethcore/src/ethereum/ethash.rs |  3 ++-
 ethcore/src/tests/client.rs    | 20 ++++++++++++++++++++
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/ethcore/src/engine.rs b/ethcore/src/engine.rs
index a05c78ff5..6806fcce3 100644
--- a/ethcore/src/engine.rs
+++ b/ethcore/src/engine.rs
@@ -81,9 +81,14 @@ pub trait Engine : Sync + Send {
 		self.verify_block_basic(header, None).and_then(|_| self.verify_block_unordered(header, None))
 	}
 
-	/// Don't forget to call Super::populateFromParent when subclassing & overriding.
+	/// Don't forget to call Super::populate_from_parent when subclassing & overriding.
 	// TODO: consider including State in the params.
-	fn populate_from_parent(&self, _header: &mut Header, _parent: &Header) {}
+	fn populate_from_parent(&self, header: &mut Header, parent: &Header) {
+		header.parent_hash = parent.hash;
+		header.difficulty = parent.difficulty;
+		header.gas_limit = parent.gas_limit;
+		header.number = parent.number + 1;
+	}
 
 	// TODO: builtin contract routing - to do this properly, it will require removing the built-in configuration-reading logic
 	// from Spec into here and removing the Spec::builtins field.
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index 6dabe558f..bf0c1d188 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -144,7 +144,8 @@ impl Engine for Ethash {
 		let difficulty = Ethash::boundary_to_difficulty(&Ethash::from_ethash(quick_get_difficulty(
 			&Ethash::to_ethash(header.bare_hash()),
 			header.nonce().low_u64(),
-			&Ethash::to_ethash(header.mix_hash()) )));
+			&Ethash::to_ethash(header.mix_hash())
+		)));
 		if difficulty < header.difficulty {
 			return Err(From::from(BlockError::InvalidProofOfWork(OutOfBounds { min: Some(header.difficulty), max: None, found: difficulty })));
 		}
diff --git a/ethcore/src/tests/client.rs b/ethcore/src/tests/client.rs
index 83df81fa2..65c9d7358 100644
--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use client::{BlockChainClient, Client, ClientConfig, BlockId};
+use block::IsBlock;
 use tests::helpers::*;
 use common::*;
 use devtools::*;
@@ -106,3 +107,22 @@ fn can_collect_garbage() {
 	client.tick();
 	assert!(client.blockchain_cache_info().blocks < 100 * 1024);
 }
+
+#[test]
+fn can_mine() {
+	let dummy_blocks = get_good_dummy_block_seq(2);
+	let client_result = get_test_client_with_blocks(vec![dummy_blocks[0].clone()]);
+	let client = client_result.reference();
+	let b = client.sealing_block();
+	let pow_hash = {
+		let u = b.lock().unwrap();
+		match *u {
+			Some(ref b) => {
+				assert_eq!(*b.block().header().parent_hash(), BlockView::new(&dummy_blocks[0]).header_view().sha3());
+				b.hash()
+			}
+			None => { panic!(); }
+		}	
+	};
+	assert!(client.submit_seal(pow_hash, vec![]).is_ok());
+}
\ No newline at end of file

From 30c68204377742dbd7cda4bd5ac3114713de5cb1 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Wed, 2 Mar 2016 00:52:18 +0100
Subject: [PATCH 24/37] Refactor and cleanup.

---
 ethcore/src/block.rs           | 9 +++++----
 ethcore/src/engine.rs          | 3 +--
 ethcore/src/ethereum/ethash.rs | 2 +-
 rpc/src/v1/impls/web3.rs       | 2 +-
 util/src/misc.rs               | 2 +-
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index 0ca6e88be..f5788baba 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -178,11 +178,12 @@ impl<'x> OpenBlock<'x> {
 			last_hashes: last_hashes,
 		};
 
-		r.block.base.header.set_number(parent.number() + 1);
-		r.block.base.header.set_author(author);
-		r.block.base.header.set_extra_data(extra_data);
+		r.block.base.header.parent_hash = parent.hash();
+		r.block.base.header.number = parent.number + 1;
+		r.block.base.header.author = author;
 		r.block.base.header.set_timestamp_now(parent.timestamp());
-		r.block.base.header.set_parent_hash(parent.hash());
+		r.block.base.header.extra_data = extra_data;
+		r.block.base.header.note_dirty();
 
 		engine.populate_from_parent(&mut r.block.base.header, parent);
 		engine.on_new_block(&mut r.block);
diff --git a/ethcore/src/engine.rs b/ethcore/src/engine.rs
index 6806fcce3..d607ce2e2 100644
--- a/ethcore/src/engine.rs
+++ b/ethcore/src/engine.rs
@@ -84,10 +84,9 @@ pub trait Engine : Sync + Send {
 	/// Don't forget to call Super::populate_from_parent when subclassing & overriding.
 	// TODO: consider including State in the params.
 	fn populate_from_parent(&self, header: &mut Header, parent: &Header) {
-		header.parent_hash = parent.hash;
 		header.difficulty = parent.difficulty;
 		header.gas_limit = parent.gas_limit;
-		header.number = parent.number + 1;
+		header.note_dirty();
 	}
 
 	// TODO: builtin contract routing - to do this properly, it will require removing the built-in configuration-reading logic
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index bf0c1d188..f9810b964 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -104,7 +104,7 @@ impl Engine for Ethash {
 				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + x!(1) + (header.gas_used * x!(6) / x!(5)) / bound_divisor)
 			}
 		};
-
+		header.note_dirty();
 //		info!("ethash: populate_from_parent #{}: difficulty={} and gas_limit={}", header.number, header.difficulty, header.gas_limit);
 	}
 
diff --git a/rpc/src/v1/impls/web3.rs b/rpc/src/v1/impls/web3.rs
index 0a237d56b..4d31f73ae 100644
--- a/rpc/src/v1/impls/web3.rs
+++ b/rpc/src/v1/impls/web3.rs
@@ -31,7 +31,7 @@ impl Web3 for Web3Client {
 	fn client_version(&self, params: Params) -> Result<Value, Error> {
 		match params {
 			Params::None => {
-				Ok(Value::String(version())),
+				Ok(Value::String(version().to_owned().replace("Parity/", "Parity//"))),
 			}
 			_ => Err(Error::invalid_params())
 		}
diff --git a/util/src/misc.rs b/util/src/misc.rs
index 6cd506d02..39ccbf2da 100644
--- a/util/src/misc.rs
+++ b/util/src/misc.rs
@@ -70,7 +70,7 @@ pub fn contents(name: &str) -> Result<Bytes, UtilError> {
 
 /// Get the standard version string for this software.
 pub fn version() -> String {
-	format!("Parity//v{}-{}-{}/{}-{}-{}/rustc{}", env!("CARGO_PKG_VERSION"), short_sha(), commit_date().replace("-", ""), Target::arch(), Target::os(), Target::env(), rustc_version::version())
+	format!("Parity/v{}-{}-{}/{}-{}-{}/rustc{}", env!("CARGO_PKG_VERSION"), short_sha(), commit_date().replace("-", ""), Target::arch(), Target::os(), Target::env(), rustc_version::version())
 }
 
 /// Get the standard version data for this software.

From 68ba0162792dee1ec350ae2ede8dc254f941a18e Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Wed, 2 Mar 2016 04:25:03 +0100
Subject: [PATCH 25/37] improved blockchain generator

---
 ethcore/src/blockchain/blockchain.rs          |  66 ++++----
 ethcore/src/blockchain/generator/block.rs     |  64 ++++++++
 ethcore/src/blockchain/generator/bloom.rs     |  35 ++++
 ethcore/src/blockchain/generator/complete.rs  |  53 ++++++
 ethcore/src/blockchain/generator/fork.rs      |  42 +++++
 .../generators.rs => generator/generator.rs}  | 154 +++++++-----------
 .../blockchain/{helpers => generator}/mod.rs  |   9 +-
 ethcore/src/blockchain/mod.rs                 |   2 +-
 8 files changed, 294 insertions(+), 131 deletions(-)
 create mode 100644 ethcore/src/blockchain/generator/block.rs
 create mode 100644 ethcore/src/blockchain/generator/bloom.rs
 create mode 100644 ethcore/src/blockchain/generator/complete.rs
 create mode 100644 ethcore/src/blockchain/generator/fork.rs
 rename ethcore/src/blockchain/{helpers/generators.rs => generator/generator.rs} (51%)
 rename ethcore/src/blockchain/{helpers => generator}/mod.rs (81%)

diff --git a/ethcore/src/blockchain/blockchain.rs b/ethcore/src/blockchain/blockchain.rs
index 53dcfb62c..10e844192 100644
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@@ -770,14 +770,15 @@ mod tests {
 	use blockchain::{BlockProvider, BlockChain, BlockChainConfig};
 	use tests::helpers::*;
 	use devtools::*;
-	use blockchain::helpers::generators::{ChainGenerator, ChainIterator};
+	use blockchain::generator::{ChainGenerator, ChainIterator, BlockFinalizer};
 	use views::BlockView;
 
 	#[test]
 	fn basic_blockchain_insert() {
 		let mut canon_chain = ChainGenerator::default();
-		let genesis = canon_chain.next().unwrap().rlp();
-		let first = canon_chain.next().unwrap().rlp();
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+		let first = canon_chain.generate(&mut finalizer).unwrap();
 		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
 		let first_hash = BlockView::new(&first).header_view().sha3();
 
@@ -806,14 +807,12 @@ mod tests {
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn test_small_fork() {
 		let mut canon_chain = ChainGenerator::default();
-		let genesis = canon_chain.next().unwrap().rlp();
-		let blocks = canon_chain.clone().take(3).map(|block| block.rlp()).collect::<Vec<_>>();
-		let fork = canon_chain.skip(2).fork(1).take(1).next().unwrap().rlp();
-
-		let b1 = blocks[0].clone();
-		let b2 = blocks[1].clone();
-		let b3a = blocks[2].clone();
-		let b3b = fork;
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+		let b1 = canon_chain.generate(&mut finalizer).unwrap();
+		let b2 = canon_chain.generate(&mut finalizer).unwrap();
+		let b3b = canon_chain.fork(1).generate(&mut finalizer.fork()).unwrap();
+		let b3a = canon_chain.generate(&mut finalizer).unwrap();
 
 		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
 		let b1_hash= BlockView::new(&b1).header_view().sha3();
@@ -897,22 +896,24 @@ mod tests {
 
 	#[test]
 	fn test_reopen_blockchain_db() {
-		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a07dba07d6b448a186e9612e5f737d1c909dce473e53199901a302c00646d523c1a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808454c98c8142a059262c330941f3fe2a34d16d6e3c7b30d2ceb37c6a0e9a994c494ee1a61d2410885aa4c8bf8e56e264c0c0".from_hex().unwrap();
-		let b1 = "f90261f901f9a05716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0cb52de543653d86ccd13ba3ddf8b052525b04231c6884a4db3188a184681d878a0e78628dd45a1f8dc495594d83b76c588a3ee67463260f8b7d4a42f574aeab29aa0e9244cf7503b79c03d3a099e07a80d2dbc77bb0b502d8a89d51ac0d68dd31313b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001832fefd882520884562791e580a051b3ecba4e3f2b49c11d42dd0851ec514b1be3138080f72a2b6e83868275d98f8877671f479c414b47f862f86080018304cb2f94095e7baea6a6c7c4c2dfeb977efac326af552d870a801ca09e2709d7ec9bbe6b1bbbf0b2088828d14cd5e8642a1fee22dc74bfa89761a7f9a04bd8813dee4be989accdb708b1c2e325a7e9c695a8024e30e89d6c644e424747c0".from_hex().unwrap();
-		let genesis_hash = H256::from_str("5716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2").unwrap();
-		let b1_hash = H256::from_str("437e51676ff10756fcfee5edd9159fa41dbcb1b2c592850450371cbecd54ee4f").unwrap();
+		let mut canon_chain = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+		let first = canon_chain.generate(&mut finalizer).unwrap();
+		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
+		let first_hash = BlockView::new(&first).header_view().sha3();
 
 		let temp = RandomTempPath::new();
 		{
 			let bc = BlockChain::new(BlockChainConfig::default(), &genesis, temp.as_path());
 			assert_eq!(bc.best_block_hash(), genesis_hash);
-			bc.insert_block(&b1, vec![]);
-			assert_eq!(bc.best_block_hash(), b1_hash);
+			bc.insert_block(&first, vec![]);
+			assert_eq!(bc.best_block_hash(), first_hash);
 		}
 
 		{
 			let bc = BlockChain::new(BlockChainConfig::default(), &genesis, temp.as_path());
-			assert_eq!(bc.best_block_hash(), b1_hash);
+			assert_eq!(bc.best_block_hash(), first_hash);
 		}
 	}
 
@@ -976,29 +977,24 @@ mod tests {
 
 	#[test]
 	fn test_bloom_filter_simple() {
-		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a07dba07d6b448a186e9612e5f737d1c909dce473e53199901a302c00646d523c1a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808454c98c8142a059262c330941f3fe2a34d16d6e3c7b30d2ceb37c6a0e9a994c494ee1a61d2410885aa4c8bf8e56e264c0c0".from_hex().unwrap();
-
-		// block b1 (child of genesis)
-		let b1 = "f90261f901f9a05716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0cb52de543653d86ccd13ba3ddf8b052525b04231c6884a4db3188a184681d878a0e78628dd45a1f8dc495594d83b76c588a3ee67463260f8b7d4a42f574aeab29aa0e9244cf7503b79c03d3a099e07a80d2dbc77bb0b502d8a89d51ac0d68dd31313b90100000000200000000000000000000000000000000000000000020000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080004000000000000000000000020008302000001832fefd882520884562791e580a051b3ecba4e3f2b49c11d42dd0851ec514b1be3138080f72a2b6e83868275d98f8877671f479c414b47f862f86080018304cb2f94095e7baea6a6c7c4c2dfeb977efac326af552d870a801ca09e2709d7ec9bbe6b1bbbf0b2088828d14cd5e8642a1fee22dc74bfa89761a7f9a04bd8813dee4be989accdb708b1c2e325a7e9c695a8024e30e89d6c644e424747c0".from_hex().unwrap();
-
-		// block b2 (child of b1)
-		let b2 = "f902ccf901f9a04ef46c05763fffc5f7e59f92a7ef438ffccbb578e6e5d0f04e3df8a7fa6c02f6a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0c70a5dc56146e5ef025e4e5726a6373c6f12fd2f6784093a19ead0a7d17fb292a040645cbce4fd399e7bb9160b4c30c40d7ee616a030d4e18ef0ed3b02bdb65911a086e608555f63628417032a011d107b36427af37d153f0da02ce3f90fdd5e8c08b90100000000000000000000000000000000000000000000000200000010000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000080000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004002832fefd882c0e384562791e880a0e3cc39ff775cc0a32f175995b92e84b729e5c9a3563ff899e3555b908bc21d75887c3cde283f4846a6f8cdf8cb01018304cb2f8080b87e6060604052606e8060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c0406226146037576035565b005b60406004506056565b6040518082815260200191505060405180910390f35b6000600560006000508190555060059050606b565b90561ba05258615c63503c0a600d6994b12ea5750d45b3c69668e2a371b4fbfb9eeff6b8a0a11be762bc90491231274a2945be35a43f23c27775b1ff24dd521702fe15f73ec0".from_hex().unwrap();
-
-		// prepare for fork (b1a, child of genesis)
-		let b1a = "f902ccf901f9a05716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0c70a5dc56146e5ef025e4e5726a6373c6f12fd2f6784093a19ead0a7d17fb292a040645cbce4fd399e7bb9160b4c30c40d7ee616a030d4e18ef0ed3b02bdb65911a086e608555f63628417032a011d107b36427af37d153f0da02ce3f90fdd5e8c08b90100000000000000000000000000000000000000000000000200000008000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000080000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004001832fefd882c0e384562791e880a0e3cc39ff775cc0a32f175995b92e84b729e5c9a3563ff899e3555b908bc21d75887c3cde283f4846a6f8cdf8cb01018304cb2f8080b87e6060604052606e8060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c0406226146037576035565b005b60406004506056565b6040518082815260200191505060405180910390f35b6000600560006000508190555060059050606b565b90561ba05258615c63503c0a600d6994b12ea5750d45b3c69668e2a371b4fbfb9eeff6b8a0a11be762bc90491231274a2945be35a43f23c27775b1ff24dd521702fe15f73ec0".from_hex().unwrap();
-
-		// fork (b2a, child of b1a, with higher total difficulty)
-		let b2a = "f902ccf901f9a0626b0774a7cbdad7bdce07b87d74b6fa91c1c359d725076215d76348f8399f56a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0c70a5dc56146e5ef025e4e5726a6373c6f12fd2f6784093a19ead0a7d17fb292a040645cbce4fd399e7bb9160b4c30c40d7ee616a030d4e18ef0ed3b02bdb65911a086e608555f63628417032a011d107b36427af37d153f0da02ce3f90fdd5e8c08b90100000000000000000000000000000000000000000000000200000008000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000080000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004002832fefd882c0e384562791e880a0e3cc39ff775cc0a32f175995b92e84b729e5c9a3563ff899e3555b908bc21d75887c3cde283f4846a6f8cdf8cb01018304cb2f8080b87e6060604052606e8060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c0406226146037576035565b005b60406004506056565b6040518082815260200191505060405180910390f35b6000600560006000508190555060059050606b565b90561ba05258615c63503c0a600d6994b12ea5750d45b3c69668e2a371b4fbfb9eeff6b8a0a11be762bc90491231274a2945be35a43f23c27775b1ff24dd521702fe15f73ec0".from_hex().unwrap();
-
-		// fork back :)
-		let b3 = "f902ccf901f9a0e6cd7250e4c32b33c906aca30280911c560ac67bd0a05fbeb874f99ac7e7e47aa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0c70a5dc56146e5ef025e4e5726a6373c6f12fd2f6784093a19ead0a7d17fb292a040645cbce4fd399e7bb9160b4c30c40d7ee616a030d4e18ef0ed3b02bdb65911a086e608555f63628417032a011d107b36427af37d153f0da02ce3f90fdd5e8c08b90100000000000000000000000000000000000000000000000200000008000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000080000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004003832fefd882c0e384562791e880a0e3cc39ff775cc0a32f175995b92e84b729e5c9a3563ff899e3555b908bc21d75887c3cde283f4846a6f8cdf8cb01018304cb2f8080b87e6060604052606e8060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c0406226146037576035565b005b60406004506056565b6040518082815260200191505060405180910390f35b6000600560006000508190555060059050606b565b90561ba05258615c63503c0a600d6994b12ea5750d45b3c69668e2a371b4fbfb9eeff6b8a0a11be762bc90491231274a2945be35a43f23c27775b1ff24dd521702fe15f73ec0".from_hex().unwrap();
-
+		// TODO: From here
 		let bloom_b1 = H2048::from_str("00000020000000000000000000000000000000000000000002000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000400000000000000000000002000").unwrap();
 
 		let bloom_b2 = H2048::from_str("00000000000000000000000000000000000000000000020000001000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
 
 		let bloom_ba = H2048::from_str("00000000000000000000000000000000000000000000020000000800000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
 
+		let mut canon_chain = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+		let mut fork = canon_chain.fork(1);
+		let mut fork_finalizer = finalizer.fork();
+		let b1 = fork.with_bloom(bloom_b1.clone()).generate(&mut fork_finalizer).unwrap();
+		let b2 = fork.with_bloom(bloom_b2.clone()).generate(&mut fork_finalizer).unwrap();
+		let b3 = fork.with_bloom(bloom_ba.clone()).generate(&mut fork_finalizer).unwrap();
+		let b1a = canon_chain.with_bloom(bloom_ba.clone()).generate(&mut finalizer).unwrap();
+		let b2a = canon_chain.with_bloom(bloom_ba.clone()).generate(&mut finalizer).unwrap();
+
 		let temp = RandomTempPath::new();
 		let bc = BlockChain::new(BlockChainConfig::default(), &genesis, temp.as_path());
 
diff --git a/ethcore/src/blockchain/generator/block.rs b/ethcore/src/blockchain/generator/block.rs
new file mode 100644
index 000000000..0a3dad399
--- /dev/null
+++ b/ethcore/src/blockchain/generator/block.rs
@@ -0,0 +1,64 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use util::rlp::*;
+use util::{H256, H2048};
+use util::U256;
+use util::bytes::Bytes;
+use header::Header;
+use transaction::SignedTransaction;
+
+use super::fork::Forkable;
+use super::bloom::WithBloom;
+use super::complete::CompleteBlock;
+
+/// Helper structure, used for encoding blocks.
+#[derive(Default)]
+pub struct Block {
+	pub header: Header,
+	pub transactions: Vec<SignedTransaction>,
+	pub uncles: Vec<Header>
+}
+
+impl Encodable for Block {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(3);
+		s.append(&self.header);
+		s.append(&self.transactions);
+		s.append(&self.uncles);
+	}
+}
+
+impl Forkable for Block {
+	fn fork(mut self, fork_number: usize) -> Self where Self: Sized {
+		self.header.difficulty = self.header.difficulty - U256::from(fork_number);
+		self
+	}
+}
+
+impl WithBloom for Block {
+	fn with_bloom(mut self, bloom: H2048) -> Self where Self: Sized {
+		self.header.log_bloom = bloom;
+		self
+	}
+}
+
+impl CompleteBlock for Block {
+	fn complete(mut self, parent_hash: H256) -> Bytes {
+		self.header.parent_hash = parent_hash;
+		encode(&self).to_vec()
+	}
+}
diff --git a/ethcore/src/blockchain/generator/bloom.rs b/ethcore/src/blockchain/generator/bloom.rs
new file mode 100644
index 000000000..f61c9d1ff
--- /dev/null
+++ b/ethcore/src/blockchain/generator/bloom.rs
@@ -0,0 +1,35 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use util::hash::H2048;
+
+pub trait WithBloom {
+	fn with_bloom(self, bloom: H2048) -> Self where Self: Sized;
+}
+
+pub struct Bloom<'a, I> where I: 'a {
+	pub iter: &'a mut I,
+	pub bloom: H2048,
+}
+
+impl<'a, I> Iterator for Bloom<'a, I> where I: Iterator, <I as Iterator>::Item: WithBloom {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.with_bloom(self.bloom.clone()))
+	}
+}
diff --git a/ethcore/src/blockchain/generator/complete.rs b/ethcore/src/blockchain/generator/complete.rs
new file mode 100644
index 000000000..39bd587a0
--- /dev/null
+++ b/ethcore/src/blockchain/generator/complete.rs
@@ -0,0 +1,53 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use util::hash::H256;
+use util::bytes::Bytes;
+use util::sha3::Hashable;
+use views::BlockView;
+
+#[derive(Default, Clone)]
+pub struct BlockFinalizer {
+	parent_hash: H256
+}
+
+impl BlockFinalizer {
+	pub fn fork(&self) -> Self {
+		self.clone()
+	}
+}
+
+pub trait CompleteBlock {
+	fn complete(self, parent_hash: H256) -> Bytes;
+}
+
+pub struct Complete<'a, I> where I: 'a {
+	pub iter: &'a mut I,
+	pub finalizer: &'a mut BlockFinalizer,
+}
+
+impl<'a, I> Iterator for Complete<'a, I> where I: Iterator, <I as Iterator>::Item: CompleteBlock {
+	type Item = Bytes;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| {
+			let rlp = item.complete(self.finalizer.parent_hash.clone());
+			self.finalizer.parent_hash = BlockView::new(&rlp).header_view().sha3();
+			rlp
+		})
+	}
+}
diff --git a/ethcore/src/blockchain/generator/fork.rs b/ethcore/src/blockchain/generator/fork.rs
new file mode 100644
index 000000000..f3a4eb267
--- /dev/null
+++ b/ethcore/src/blockchain/generator/fork.rs
@@ -0,0 +1,42 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+pub trait Forkable {
+	fn fork(self, fork_number: usize) -> Self where Self: Sized;
+}
+
+pub struct Fork<I> {
+	pub iter: I,
+	pub fork_number: usize,
+}
+
+impl<I> Clone for Fork<I> where I: Iterator + Clone {
+	fn clone(&self) -> Self {
+		Fork {
+			iter: self.iter.clone(),
+			fork_number: self.fork_number
+		}
+	}
+}
+
+impl<I> Iterator for Fork<I> where I: Iterator, <I as Iterator>::Item: Forkable {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.fork(self.fork_number))
+	}
+}
diff --git a/ethcore/src/blockchain/helpers/generators.rs b/ethcore/src/blockchain/generator/generator.rs
similarity index 51%
rename from ethcore/src/blockchain/helpers/generators.rs
rename to ethcore/src/blockchain/generator/generator.rs
index a20b0cf79..d73b81733 100644
--- a/ethcore/src/blockchain/helpers/generators.rs
+++ b/ethcore/src/blockchain/generator/generator.rs
@@ -14,108 +14,52 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::rlp::*;
-use util::hash::{H256, H2048};
-use util::uint::{U256};
+use util::hash::H2048;
+use util::uint::U256;
 use util::bytes::Bytes;
-use header::{BlockNumber, Header};
-use transaction::SignedTransaction;
-
-pub trait Forkable {
-	fn fork(self, fork_number: usize) -> Self where Self: Sized;
-}
-
-pub struct Fork<I> {
-	iter: I,
-	fork_number: usize,
-}
-
-impl<I> Iterator for Fork<I> where I: Iterator, <I as Iterator>::Item: Forkable {
-	type Item = <I as Iterator>::Item;
-
-	#[inline]
-	fn next(&mut self) -> Option<Self::Item> {
-		self.iter.next().map(|item| item.fork(self.fork_number))
-	}
-}
-
-pub trait WithBloom {
-	fn with_bloom(self, bloom: H2048) -> Self where Self: Sized;
-}
-
-pub struct Bloom<I> {
-	iter: I,
-	bloom: H2048,
-}
-
-impl<I> Iterator for Bloom<I> where I: Iterator, <I as Iterator>::Item: WithBloom {
-	type Item = <I as Iterator>::Item;
-
-	#[inline]
-	fn next(&mut self) -> Option<Self::Item> {
-		self.iter.next().map(|item| item.with_bloom(self.bloom.clone()))
-	}
-}
+use header::BlockNumber;
+use super::fork::Fork;
+use super::bloom::Bloom;
+use super::complete::{BlockFinalizer, CompleteBlock, Complete};
+use super::block::Block;
 
 /// Chain iterator interface.
-pub trait ChainIterator: Iterator {
+pub trait ChainIterator: Iterator + Sized {
 	/// Should be called to create a fork of current iterator.
 	/// Blocks generated by fork will have lower difficulty than current chain.
-	fn fork(&mut self, fork_number: usize) -> Fork<Self> where Self: Sized;
+	fn fork(&self, fork_number: usize) -> Fork<Self> where Self: Clone;
 	/// Should be called to make every consecutive block have given bloom.
-	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self> where Self: Sized;
+	fn with_bloom<'a>(&'a mut self, bloom: H2048) -> Bloom<'a, Self>;
+	/// Should be called to complete block. Without complete block may have incorrect hash.
+	fn complete<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Complete<'a, Self>;
+	/// Completes and generates block.
+	fn generate<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Option<Bytes> where Self::Item: CompleteBlock;
 }
 
-impl<I> ChainIterator for I where I: Iterator + Sized + Clone {
-	fn fork(&mut self, fork_number: usize) -> Fork<Self> {
+impl<I> ChainIterator for I where I: Iterator + Sized {
+	fn fork(&self, fork_number: usize) -> Fork<Self> where I: Clone {
 		Fork {
 			iter: self.clone(),
 			fork_number: fork_number
 		}
 	}
 
-	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self> {
+	fn with_bloom<'a>(&'a mut self, bloom: H2048) -> Bloom<'a, Self> {
 		Bloom {
-			iter: self.clone(),
+			iter: self,
 			bloom: bloom
 		}
 	}
-}
 
-/// Helper structure, used for encoding blocks.
-#[derive(Default)]
-pub struct Block {
-	header: Header,
-	transactions: Vec<SignedTransaction>,
-	uncles: Vec<Header>
-}
-
-impl Block {
-	pub fn rlp(&self) -> Bytes {
-		encode(self).to_vec()
+	fn complete<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Complete<'a, Self> {
+		Complete {
+			iter: self,
+			finalizer: finalizer
+		}
 	}
-}
 
-impl Encodable for Block {
-	fn rlp_append(&self, s: &mut RlpStream) {
-		s.begin_list(3);
-		s.append(&self.header);
-		s.append(&self.transactions);
-		s.append(&self.uncles);
-	}
-}
-
-impl Forkable for Block {
-	fn fork(mut self, fork_number: usize) -> Self where Self: Sized {
-		self.header.difficulty = self.header.difficulty - U256::from(fork_number);
-		self
-	}
-}
-
-impl WithBloom for Block {
-	fn with_bloom(mut self, bloom: H2048) -> Self where Self: Sized {
-		self.header.log_bloom = bloom;
-		self
+	fn generate<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Option<Bytes> where <I as Iterator>::Item: CompleteBlock {
+		self.complete(finalizer).next()
 	}
 }
 
@@ -124,8 +68,6 @@ impl WithBloom for Block {
 pub struct ChainGenerator {
 	/// Next block number.
 	number: BlockNumber,
-	/// Next block parent hash.
-	parent_hash: H256,
 	/// Next block difficulty.
 	difficulty: U256,
 }
@@ -133,7 +75,6 @@ pub struct ChainGenerator {
 impl ChainGenerator {
 	fn prepare_block(&self) -> Block {
 		let mut block = Block::default();
-		block.header.parent_hash = self.parent_hash.clone();
 		block.header.number = self.number;
 		block.header.difficulty = self.difficulty;
 		block
@@ -144,7 +85,6 @@ impl Default for ChainGenerator {
 	fn default() -> Self {
 		ChainGenerator {
 			number: 0,
-			parent_hash: H256::default(),
 			difficulty: U256::from(1000),
 		}
 	}
@@ -156,30 +96,28 @@ impl Iterator for ChainGenerator {
 	fn next(&mut self) -> Option<Self::Item> {
 		let block = self.prepare_block();
 		self.number += 1;
-		self.parent_hash = block.header.hash();
 		Some(block)
 	}
 }
 
-
-#[cfg(test)]
 mod tests {
-	use util::hash::H256;
+	use util::hash::{H256, H2048};
 	use util::sha3::Hashable;
 	use views::BlockView;
-	use super::{ChainIterator, ChainGenerator};
+	use blockchain::generator::{ChainIterator, ChainGenerator, BlockFinalizer};
 
 	#[test]
 	fn canon_chain_generator() {
 		let mut canon_chain = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
 
-		let genesis_rlp = canon_chain.next().unwrap().rlp();
+		let genesis_rlp = canon_chain.generate(&mut finalizer).unwrap();
 		let genesis = BlockView::new(&genesis_rlp);
 
 		assert_eq!(genesis.header_view().parent_hash(), H256::default());
 		assert_eq!(genesis.header_view().number(), 0);
 
-		let b1_rlp = canon_chain.next().unwrap().rlp();
+		let b1_rlp = canon_chain.generate(&mut finalizer).unwrap();
 		let b1 = BlockView::new(&b1_rlp);
 
 		assert_eq!(b1.header_view().parent_hash(), genesis.header_view().sha3());
@@ -187,17 +125,45 @@ mod tests {
 
 		let mut fork_chain = canon_chain.fork(1);
 
-		let b2_rlp_fork = fork_chain.next().unwrap().rlp();
+		let b2_rlp_fork = fork_chain.generate(&mut finalizer.fork()).unwrap();
 		let b2_fork = BlockView::new(&b2_rlp_fork);
 
 		assert_eq!(b2_fork.header_view().parent_hash(), b1.header_view().sha3());
 		assert_eq!(b2_fork.header_view().number(), 2);
 
-		let b2_rlp = canon_chain.next().unwrap().rlp();
+		let b2_rlp = canon_chain.generate(&mut finalizer).unwrap();
 		let b2 = BlockView::new(&b2_rlp);
 
 		assert_eq!(b2.header_view().parent_hash(), b1.header_view().sha3());
 		assert_eq!(b2.header_view().number(), 2);
 		assert!(b2.header_view().difficulty() > b2_fork.header_view().difficulty());
 	}
+
+	#[test]
+	fn with_bloom_generator() {
+		let bloom = H2048([0x1; 256]);
+		let mut gen = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+
+		let block0_rlp = gen.with_bloom(bloom).generate(&mut finalizer).unwrap();
+		let block1_rlp = gen.generate(&mut finalizer).unwrap();
+		let block0 = BlockView::new(&block0_rlp);
+		let block1 = BlockView::new(&block1_rlp);
+
+		assert_eq!(block0.header_view().number(), 0);
+		assert_eq!(block0.header_view().parent_hash(), H256::default());
+
+		assert_eq!(block1.header_view().number(), 1);
+		assert_eq!(block1.header_view().parent_hash(), block0.header_view().sha3());
+
+	}
+
+	#[test]
+	fn generate_1000_blocks() {
+		let generator = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+		let blocks: Vec<_> = generator.take(1000).complete(&mut finalizer).collect();
+		assert_eq!(blocks.len(), 1000);
+	}
 }
+
diff --git a/ethcore/src/blockchain/helpers/mod.rs b/ethcore/src/blockchain/generator/mod.rs
similarity index 81%
rename from ethcore/src/blockchain/helpers/mod.rs
rename to ethcore/src/blockchain/generator/mod.rs
index 233f8f1f8..88fdec0e4 100644
--- a/ethcore/src/blockchain/helpers/mod.rs
+++ b/ethcore/src/blockchain/generator/mod.rs
@@ -14,4 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-pub mod generators;
+mod bloom;
+mod block;
+mod complete;
+mod fork;
+pub mod generator;
+
+pub use self::complete::BlockFinalizer;
+pub use self::generator::{ChainIterator, ChainGenerator};
diff --git a/ethcore/src/blockchain/mod.rs b/ethcore/src/blockchain/mod.rs
index 60a1aeb33..b0679b563 100644
--- a/ethcore/src/blockchain/mod.rs
+++ b/ethcore/src/blockchain/mod.rs
@@ -24,7 +24,7 @@ mod cache;
 mod tree_route;
 mod update;
 #[cfg(test)]
-mod helpers;
+mod generator;
 
 pub use self::blockchain::{BlockProvider, BlockChain, BlockChainConfig};
 pub use self::cache::CacheSize;

From 010659cf12b0accaa678232176d60f338f15f1a9 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Wed, 2 Mar 2016 04:54:47 +0100
Subject: [PATCH 26/37] added missing , in comment

---
 ethcore/src/blockchain/generator/generator.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ethcore/src/blockchain/generator/generator.rs b/ethcore/src/blockchain/generator/generator.rs
index d73b81733..16f2330c2 100644
--- a/ethcore/src/blockchain/generator/generator.rs
+++ b/ethcore/src/blockchain/generator/generator.rs
@@ -30,7 +30,7 @@ pub trait ChainIterator: Iterator + Sized {
 	fn fork(&self, fork_number: usize) -> Fork<Self> where Self: Clone;
 	/// Should be called to make every consecutive block have given bloom.
 	fn with_bloom<'a>(&'a mut self, bloom: H2048) -> Bloom<'a, Self>;
-	/// Should be called to complete block. Without complete block may have incorrect hash.
+	/// Should be called to complete block. Without complete, block may have incorrect hash.
 	fn complete<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Complete<'a, Self>;
 	/// Completes and generates block.
 	fn generate<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Option<Bytes> where Self::Item: CompleteBlock;

From 32074cc420edf2f450e29c89a7ef64a58d2c6d6a Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Wed, 2 Mar 2016 05:55:42 +0100
Subject: [PATCH 27/37] fixed compilation issue caused by incorrect merge

---
 ethcore/src/blockchain/generator/generator.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ethcore/src/blockchain/generator/generator.rs b/ethcore/src/blockchain/generator/generator.rs
index 16f2330c2..51e6294fc 100644
--- a/ethcore/src/blockchain/generator/generator.rs
+++ b/ethcore/src/blockchain/generator/generator.rs
@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::hash::H2048;
-use util::uint::U256;
+use util::numbers::U256;
 use util::bytes::Bytes;
 use header::BlockNumber;
 use super::fork::Fork;

From 67a1f2065e2611c73e64bbf74c0812b224b64fd7 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Wed, 2 Mar 2016 06:00:00 +0100
Subject: [PATCH 28/37] fixed broken master

---
 ethcore/src/blockchain/helpers/generators.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ethcore/src/blockchain/helpers/generators.rs b/ethcore/src/blockchain/helpers/generators.rs
index a20b0cf79..2fd517e50 100644
--- a/ethcore/src/blockchain/helpers/generators.rs
+++ b/ethcore/src/blockchain/helpers/generators.rs
@@ -16,7 +16,7 @@
 
 use util::rlp::*;
 use util::hash::{H256, H2048};
-use util::uint::{U256};
+use util::numbers::{U256};
 use util::bytes::Bytes;
 use header::{BlockNumber, Header};
 use transaction::SignedTransaction;

From feff1f9e6e8837d1783ff307caa195af9ab63554 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Wed, 2 Mar 2016 06:09:27 +0100
Subject: [PATCH 29/37] chainfilter shouldnt exclude to_block from results

---
 ethcore/src/chainfilter/chainfilter.rs | 24 ++++++++++++------------
 ethcore/src/chainfilter/tests.rs       | 16 ++++++++--------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/ethcore/src/chainfilter/chainfilter.rs b/ethcore/src/chainfilter/chainfilter.rs
index fb6df877a..387d750fd 100644
--- a/ethcore/src/chainfilter/chainfilter.rs
+++ b/ethcore/src/chainfilter/chainfilter.rs
@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Multilevel blockchain bloom filter.
-//! 
+//!
 //! ```not_run
 //! extern crate ethcore_util as util;
 //! extern crate ethcore;
@@ -23,33 +23,33 @@
 //! use util::sha3::*;
 //! use util::hash::*;
 //! use ethcore::chainfilter::*;
-//! 
+//!
 //! fn main() {
 //!		let (index_size, bloom_levels) = (16, 3);
 //!		let mut cache = MemoryCache::new();
-//!		
+//!
 //!		let address = Address::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap();
-//!		
+//!
 //!		// borrow cache for reading inside the scope
 //!		let modified_blooms = {
-//!			let filter = ChainFilter::new(&cache, index_size, bloom_levels);	
+//!			let filter = ChainFilter::new(&cache, index_size, bloom_levels);
 //!			let block_number = 39;
 //!			let mut bloom = H2048::new();
 //!			bloom.shift_bloomed(&address.sha3());
 //!			filter.add_bloom(&bloom, block_number)
 //!		};
-//!		
+//!
 //!		// number of updated blooms is equal number of levels
 //!		assert_eq!(modified_blooms.len(), bloom_levels as usize);
 //!
 //!		// lets inserts modified blooms into the cache
 //!		cache.insert_blooms(modified_blooms);
-//!		
+//!
 //!		// borrow cache for another reading operations
 //!		{
-//!			let filter = ChainFilter::new(&cache, index_size, bloom_levels);	
+//!			let filter = ChainFilter::new(&cache, index_size, bloom_levels);
 //!			let blocks = filter.blocks_with_address(&address, 10, 40);
-//!			assert_eq!(blocks.len(), 1);	
+//!			assert_eq!(blocks.len(), 1);
 //!			assert_eq!(blocks[0], 39);
 //!		}
 //! }
@@ -71,7 +71,7 @@ pub struct ChainFilter<'a, D>
 impl<'a, D> ChainFilter<'a, D> where D: FilterDataSource
 {
 	/// Creates new filter instance.
-	/// 
+	///
 	/// Borrows `FilterDataSource` for reading.
 	pub fn new(data_source: &'a D, index_size: usize, levels: u8) -> Self {
 		ChainFilter {
@@ -88,7 +88,7 @@ impl<'a, D> ChainFilter<'a, D> where D: FilterDataSource
 			None => return None,
 			Some(level_bloom) => match level {
 				// if we are on the lowest level
-				0 => return match offset < to_block {
+				0 => return match offset <= to_block {
 					// take the value if its smaller than to_block
 					true if level_bloom.contains(bloom) => Some(vec![offset]),
 					// return None if it is is equal to to_block
@@ -153,7 +153,7 @@ impl<'a, D> ChainFilter<'a, D> where D: FilterDataSource
 			for i in 0..blooms.len() {
 
 				let index = self.indexer.bloom_index(block_number + i, level);
-				let new_bloom = {	
+				let new_bloom = {
 					// use new blooms before db blooms where necessary
 					let bloom_at = | index | { result.get(&index).cloned().or_else(|| self.data_source.bloom_at_index(&index)) };
 
diff --git a/ethcore/src/chainfilter/tests.rs b/ethcore/src/chainfilter/tests.rs
index 2baa93e55..08af44720 100644
--- a/ethcore/src/chainfilter/tests.rs
+++ b/ethcore/src/chainfilter/tests.rs
@@ -22,7 +22,7 @@ use util::sha3::*;
 use chainfilter::{BloomIndex, FilterDataSource, ChainFilter};
 
 /// In memory cache for blooms.
-/// 
+///
 /// Stores all blooms in HashMap, which indexes them by `BloomIndex`.
 pub struct MemoryCache {
 	blooms: HashMap<BloomIndex, H2048>,
@@ -35,7 +35,7 @@ impl MemoryCache {
 	}
 
 	/// inserts all blooms into cache
-	/// 
+	///
 	/// if bloom at given index already exists, overwrites it
 	pub fn insert_blooms(&mut self, blooms: HashMap<BloomIndex, H2048>) {
 		self.blooms.extend(blooms);
@@ -81,13 +81,13 @@ fn test_topic_basic_search() {
 
 	{
 		let filter = ChainFilter::new(&cache, index_size, bloom_levels);
-		let blocks = filter.blocks_with_bloom(&to_bloom(&topic), 0, 23);
+		let blocks = filter.blocks_with_bloom(&to_bloom(&topic), 0, 22);
 		assert_eq!(blocks.len(), 0);
 	}
 
 	{
 		let filter = ChainFilter::new(&cache, index_size, bloom_levels);
-		let blocks = filter.blocks_with_bloom(&to_bloom(&topic), 23, 24);
+		let blocks = filter.blocks_with_bloom(&to_bloom(&topic), 23, 23);
 		assert_eq!(blocks.len(), 1);
 		assert_eq!(blocks[0], 23);
 	}
@@ -144,7 +144,7 @@ fn test_reset_chain_head_simple() {
 
 	cache.insert_blooms(modified_blooms_3);
 
-	
+
 	let reset_modified_blooms = {
 		let filter = ChainFilter::new(&cache, index_size, bloom_levels);
 		filter.reset_chain_head(&[to_bloom(&topic_4), to_bloom(&topic_5)], 15, 17)
@@ -183,7 +183,7 @@ fn for_each_bloom<F>(bytes: &[u8], mut f: F) where F: FnMut(usize, &H2048) {
 }
 
 fn for_each_log<F>(bytes: &[u8], mut f: F) where F: FnMut(usize, &Address, &[H256]) {
-	let mut reader = BufReader::new(bytes);	
+	let mut reader = BufReader::new(bytes);
 	let mut line = String::new();
 	while reader.read_line(&mut line).unwrap() > 0 {
 		{
@@ -235,11 +235,11 @@ fn test_chainfilter_real_data_short_searches() {
 	for_each_log(include_bytes!("logs.txt"), | block_number, address, topics | {
 		println!("block_number: {:?}", block_number);
 		let filter = ChainFilter::new(&cache, index_size, bloom_levels);
-		let blocks = filter.blocks_with_bloom(&to_bloom(address), block_number, block_number + 1);
+		let blocks = filter.blocks_with_bloom(&to_bloom(address), block_number, block_number);
 		assert_eq!(blocks.len(), 1);
 		for (i, topic) in topics.iter().enumerate() {
 			println!("topic: {:?}", i);
-			let blocks = filter.blocks_with_bloom(&to_bloom(topic), block_number, block_number + 1);
+			let blocks = filter.blocks_with_bloom(&to_bloom(topic), block_number, block_number);
 			assert_eq!(blocks.len(), 1);
 		}
 	});

From 34b812696b24427f3eb3bbb1c9f67119acf87230 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Wed, 2 Mar 2016 08:49:48 +0300
Subject: [PATCH 30/37] remove unused imports

---
 util/bigint/src/uint.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/util/bigint/src/uint.rs b/util/bigint/src/uint.rs
index 4cc0dfc0e..5b67ba41d 100644
--- a/util/bigint/src/uint.rs
+++ b/util/bigint/src/uint.rs
@@ -40,20 +40,13 @@ use std::fmt;
 use std::cmp;
 
 use std::mem;
-use std::ops;
-use std::slice;
-use std::result;
-use std::option;
 use std::str::{FromStr};
 use std::convert::From;
 use std::hash::{Hash, Hasher};
 use std::ops::*;
 use std::cmp::*;
-use std::collections::*;
 
 use serde;
-use rustc_serialize::json::Json;
-use rustc_serialize::base64::FromBase64;
 use rustc_serialize::hex::{FromHex, FromHexError, ToHex};
 
 

From 5dfc3d28491e0e98b54e34a027031e6a54163832 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Wed, 2 Mar 2016 13:01:38 +0300
Subject: [PATCH 31/37] resolving path at runtime

---
 util/cov.sh                  |  2 +-
 util/src/keys/geth_import.rs | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/util/cov.sh b/util/cov.sh
index 19aa3b892..121f9629d 100755
--- a/util/cov.sh
+++ b/util/cov.sh
@@ -5,5 +5,5 @@ fi
 
 cargo test --no-run || exit $?
 mkdir -p target/coverage
-kcov --exclude-pattern ~/.multirust,rocksdb,secp256k1 --include-pattern src --verify target/coverage target/debug/ethcore_util*
+./kcov --exclude-pattern ~/.multirust,rocksdb,secp256k1 --include-pattern src --verify target/coverage target/debug/ethcore_util*
 xdg-open target/coverage/index.html
diff --git a/util/src/keys/geth_import.rs b/util/src/keys/geth_import.rs
index cdbd9b213..dbd9f0fe0 100644
--- a/util/src/keys/geth_import.rs
+++ b/util/src/keys/geth_import.rs
@@ -99,10 +99,20 @@ mod tests {
 	use common::*;
 	use keys::store::SecretStore;
 
+	fn test_path() -> &'static str {
+		match ::std::fs::metadata("res") {
+			Ok(_) => "res/geth_keystore",
+			Err(_) => "util/res/geth_keystore"
+		}
+	}
+
+	fn test_path_param(param_val: &'static str) -> String {
+		test_path().to_owned() + param_val
+	}
 
 	#[test]
 	fn can_enumerate() {
-		let keys = enumerate_geth_keys(Path::new("res/geth_keystore")).unwrap();
+		let keys = enumerate_geth_keys(Path::new(test_path())).unwrap();
 		assert_eq!(2, keys.len());
 	}
 
@@ -110,7 +120,7 @@ mod tests {
 	fn can_import() {
 		let temp = ::devtools::RandomTempPath::create_dir();
 		let mut secret_store = SecretStore::new_in(temp.as_path());
-		import_geth_key(&mut secret_store, Path::new("res/geth_keystore/UTC--2016-02-17T09-20-45.721400158Z--3f49624084b67849c7b4e805c5988c21a430f9d9")).unwrap();
+		import_geth_key(&mut secret_store, Path::new(&test_path_param("/UTC--2016-02-17T09-20-45.721400158Z--3f49624084b67849c7b4e805c5988c21a430f9d9"))).unwrap();
 		let key = secret_store.account(&Address::from_str("3f49624084b67849c7b4e805c5988c21a430f9d9").unwrap());
 		assert!(key.is_some());
 	}
@@ -119,7 +129,7 @@ mod tests {
 	fn can_import_directory() {
 		let temp = ::devtools::RandomTempPath::create_dir();
 		let mut secret_store = SecretStore::new_in(temp.as_path());
-		import_geth_keys(&mut secret_store, Path::new("res/geth_keystore")).unwrap();
+		import_geth_keys(&mut secret_store, Path::new(test_path())).unwrap();
 
 		let key = secret_store.account(&Address::from_str("3f49624084b67849c7b4e805c5988c21a430f9d9").unwrap());
 		assert!(key.is_some());
@@ -134,7 +144,7 @@ mod tests {
 		let temp = ::devtools::RandomTempPath::create_dir();
 		{
 			let mut secret_store = SecretStore::new_in(temp.as_path());
-			import_geth_keys(&mut secret_store, Path::new("res/geth_keystore")).unwrap();
+			import_geth_keys(&mut secret_store, Path::new(test_path())).unwrap();
 		}
 
 		let key_directory = KeyDirectory::new(&temp.as_path());
@@ -156,7 +166,7 @@ mod tests {
 
 		let temp = ::devtools::RandomTempPath::create_dir();
 		let mut secret_store = SecretStore::new_in(temp.as_path());
-		import_geth_keys(&mut secret_store, Path::new("res/geth_keystore")).unwrap();
+		import_geth_keys(&mut secret_store, Path::new(test_path())).unwrap();
 
 		let val = secret_store.get::<Bytes>(&H128::from_str("62a0ad73556d496a8e1c0783d30d3ace").unwrap(), "123");
 		assert!(val.is_ok());

From 771fbcbd27bd900902f7705bd9d107f129e0ca2b Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Wed, 2 Mar 2016 13:02:33 +0300
Subject: [PATCH 32/37] remove redundant modification

---
 util/cov.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/util/cov.sh b/util/cov.sh
index 121f9629d..19aa3b892 100755
--- a/util/cov.sh
+++ b/util/cov.sh
@@ -5,5 +5,5 @@ fi
 
 cargo test --no-run || exit $?
 mkdir -p target/coverage
-./kcov --exclude-pattern ~/.multirust,rocksdb,secp256k1 --include-pattern src --verify target/coverage target/debug/ethcore_util*
+kcov --exclude-pattern ~/.multirust,rocksdb,secp256k1 --include-pattern src --verify target/coverage target/debug/ethcore_util*
 xdg-open target/coverage/index.html

From 3309959139cd8308367e83cf80d3639866beb268 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Wed, 2 Mar 2016 12:57:34 +0100
Subject: [PATCH 33/37] Additional check to ancient enactments.

---
 ethcore/src/client.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index f2894decb..803f5c9db 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -257,6 +257,14 @@ impl Client {
 		let engine = self.engine.deref().deref();
 		let header = &block.header;
 
+		// Check the block isn't so old we won't be able to enact it.
+		let best_block_number = self.chain.read().unwrap().best_block_number();
+		debug!("Best: {}, importing: {}", best_block_number, header.number());
+		if header.number() <= best_block_number - HISTORY {
+			warn!(target: "client", "Block import failed for #{} ({})\nBlock is ancient (current best block: #{}).", header.number(), header.hash(), best_block_number);
+			return Err(());
+		}
+
 		// Verify Block Family
 		let verify_family_result = verify_block_family(&header, &block.bytes, engine, self.chain.read().unwrap().deref());
 		if let Err(e) = verify_family_result {

From 041cfda80badaf98f4828121a28fabae7591abd1 Mon Sep 17 00:00:00 2001
From: arkpar <arkady.paronyan@gmail.com>
Date: Wed, 2 Mar 2016 13:21:33 +0100
Subject: [PATCH 34/37] Improved journaldb logging

---
 util/src/journaldb.rs | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/util/src/journaldb.rs b/util/src/journaldb.rs
index cfcff6ea4..5e6ca47c2 100644
--- a/util/src/journaldb.rs
+++ b/util/src/journaldb.rs
@@ -121,6 +121,7 @@ impl JournalDB {
 		// and the key is safe to delete.
 
 		// record new commit's details.
+		debug!("commit: #{} ({}), end era: {:?}", now, id, end);
 		let batch = DBTransaction::new();
 		let mut counters = self.counters.write().unwrap();
 		{
@@ -167,15 +168,18 @@ impl JournalDB {
 				&last
 			})) {
 				let rlp = Rlp::new(&rlp_data);
-				let inserts: Vec<H256> = rlp.val_at(1);
+				let mut inserts: Vec<H256> = rlp.val_at(1);
 				JournalDB::decrease_counters(&inserts, &mut counters);
 				// Collect keys to be removed. These are removed keys for canonical block, inserted for non-canonical
 				if canon_id == rlp.val_at(0) {
-					to_remove.extend(rlp.at(2).iter().map(|r| r.as_val::<H256>()));
+					let mut canon_deletes: Vec<H256> = rlp.val_at(2);
+					trace!("Purging nodes deleted from canon: {:?}", canon_deletes);
+					to_remove.append(&mut canon_deletes);
 					canon_inserts = inserts;
 				}
 				else {
-					to_remove.extend(inserts);
+					trace!("Purging nodes inserted in non-canon: {:?}", inserts);
+					to_remove.append(&mut inserts);
 				}
 				try!(batch.delete(&last));
 				index += 1;
@@ -188,7 +192,7 @@ impl JournalDB {
 				try!(batch.delete(&h));
 				deletes += 1;
 			}
-			trace!("JournalDB: delete journal for time #{}.{}, (canon was {}): {} entries", end_era, index, canon_id, deletes);
+			debug!("commit: Delete journal for time #{}.{}, (canon was {}): {} entries", end_era, index, canon_id, deletes);
 		}
 
 		// Commit overlay insertions
@@ -209,7 +213,7 @@ impl JournalDB {
 		}
 
 		try!(self.backing.write(batch));
-		trace!("JournalDB::commit() deleted {} nodes", deletes);
+		debug!("commit: Deleted {} nodes", deletes);
 		Ok(ret)
 	}
 
@@ -258,7 +262,7 @@ impl JournalDB {
 				era -= 1;
 			}
 		}
-		trace!("Recovered {} counters", res.len());
+		debug!("Recovered {} counters", res.len());
 		res
 	}
 }

From 47b47293323074f812a713477e435e18219c971f Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Wed, 2 Mar 2016 13:28:51 +0100
Subject: [PATCH 35/37] Fix check.

---
 ethcore/src/client.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index 268d99229..bf6f4bd71 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -268,7 +268,7 @@ impl Client {
 		// Check the block isn't so old we won't be able to enact it.
 		let best_block_number = self.chain.read().unwrap().best_block_number();
 		debug!("Best: {}, importing: {}", best_block_number, header.number());
-		if header.number() <= best_block_number - HISTORY {
+		if best_block_number >= HISTORY && header.number() <= best_block_number - HISTORY {
 			warn!(target: "client", "Block import failed for #{} ({})\nBlock is ancient (current best block: #{}).", header.number(), header.hash(), best_block_number);
 			return Err(());
 		}

From 1ae573bf21cc183bbffe06e1c2c84bc8c17c7e85 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Wed, 2 Mar 2016 13:40:11 +0100
Subject: [PATCH 36/37] Fix install-deps.sh.

---
 install-deps.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/install-deps.sh b/install-deps.sh
index 6cc7de002..7a5db1003 100755
--- a/install-deps.sh
+++ b/install-deps.sh
@@ -569,7 +569,7 @@ function run_installer()
 			if [[ $isSudo == false ]]; then
 				apt-get install -q -y sudo
 			fi
-			curl -sf https://raw.githubusercontent.com/brson/multirust/master/blastoff.sh | sudo sh -s -- --yes
+			curl -sf https://raw.githubusercontent.com/brson/multirust/master/quick-install.sh | sudo sh -s -- --yes
 			echo
 		fi
 

From 3c7814c8ac6882e3c9fe8b54e10c7ee2e14e5518 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Wed, 2 Mar 2016 15:43:48 +0100
Subject: [PATCH 37/37] Remove debug line.

---
 ethcore/src/client.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs
index bf6f4bd71..cc5e23869 100644
--- a/ethcore/src/client.rs
+++ b/ethcore/src/client.rs
@@ -267,7 +267,6 @@ impl Client {
 
 		// Check the block isn't so old we won't be able to enact it.
 		let best_block_number = self.chain.read().unwrap().best_block_number();
-		debug!("Best: {}, importing: {}", best_block_number, header.number());
 		if best_block_number >= HISTORY && header.number() <= best_block_number - HISTORY {
 			warn!(target: "client", "Block import failed for #{} ({})\nBlock is ancient (current best block: #{}).", header.number(), header.hash(), best_block_number);
 			return Err(());