Merge branch 'master' into ui-2

ethcore/Cargo.toml

@@ -49,6 +49,7 @@ num = "0.1"
 num_cpus = "1.2"
 parking_lot = "0.4"
 price-info = { path = "../price-info" }
+rayon = "0.8"
 rand = "0.3"
 rlp = { path = "../util/rlp" }
 rlp_derive = { path = "../util/rlp_derive" }

ethcore/evm/Cargo.toml

@@ -16,11 +16,10 @@ lazy_static = "0.2"
 log = "0.3"
 rlp = { path = "../../util/rlp" }
 vm = { path = "../vm" }
-parity-wasm = "0.12"
-parking_lot = "0.4"
 ethcore-logger = { path = "../../logger" }
 wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
 hash = { path = "../../util/hash" }
+parking_lot = "0.4"
 
 [dev-dependencies]
 rustc-hex = "1.0"

ethcore/evm/src/lib.rs

@@ -23,7 +23,6 @@ extern crate ethcore_util as util;
 extern crate ethcore_bigint as bigint;
 extern crate ethjson;
 extern crate rlp;
-extern crate parity_wasm;
 extern crate parking_lot;
 extern crate wasm_utils;
 extern crate ethcore_logger;

ethcore/light/src/client/fetch.rs

@@ -0,0 +1,74 @@
+// Copyright 2015-2017 Parity Technologies (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/>.
+
+//! Trait for fetching chain data.
+
+use std::sync::Arc;
+
+use ethcore::encoded;
+use ethcore::engines::{Engine, StateDependentProof};
+use ethcore::header::Header;
+use ethcore::receipt::Receipt;
+use futures::future::IntoFuture;
+use bigint::hash::H256;
+
+/// Provides full chain data.
+pub trait ChainDataFetcher: Send + Sync + 'static {
+	/// Error type when data unavailable.
+	type Error: ::std::fmt::Debug;
+
+	/// Future for fetching block body.
+	type Body: IntoFuture<Item=encoded::Block, Error=Self::Error>;
+	/// Future for fetching block receipts.
+	type Receipts: IntoFuture<Item=Vec<Receipt>, Error=Self::Error>;
+	/// Future for fetching epoch transition
+	type Transition: IntoFuture<Item=Vec<u8>, Error=Self::Error>;
+
+	/// Fetch a block body.
+	fn block_body(&self, header: &Header) -> Self::Body;
+
+	/// Fetch block receipts.
+	fn block_receipts(&self, header: &Header) -> Self::Receipts;
+
+	/// Fetch epoch transition proof at given header.
+	fn epoch_transition(&self, hash: H256, engine: Arc<Engine>, checker: Arc<StateDependentProof>) -> Self::Transition;
+}
+
+/// Fetcher implementation which cannot fetch anything.
+pub struct Unavailable;
+
+/// Create a fetcher which has all data unavailable.
+pub fn unavailable() -> Unavailable { Unavailable }
+
+impl ChainDataFetcher for Unavailable {
+	type Error = &'static str;
+
+	type Body = Result<encoded::Block, &'static str>;
+	type Receipts = Result<Vec<Receipt>, &'static str>;
+	type Transition = Result<Vec<u8>, &'static str>;
+
+	fn block_body(&self, _header: &Header) -> Self::Body {
+		Err("fetching block bodies unavailable")
+	}
+
+	fn block_receipts(&self, _header: &Header) -> Self::Receipts {
+		Err("fetching block receipts unavailable")
+	}
+
+	fn epoch_transition(&self, _h: H256, _e: Arc<Engine>, _check: Arc<StateDependentProof>) -> Self::Transition {
+		Err("fetching epoch transition proofs unavailable")
+	}
+}

ethcore/light/src/client/header_chain.rs

@@ -18,11 +18,12 @@
 //!
 //! Unlike a full node's `BlockChain` this doesn't store much in the database.
 //! It stores candidates for the last 2048-4096 blocks as well as CHT roots for
-//! historical blocks all the way to the genesis.
+//! historical blocks all the way to the genesis. If the engine makes use
+//! of epoch transitions, those are stored as well.
 //!
 //! This is separate from the `BlockChain` for two reasons:
 //!   - It stores only headers (and a pruned subset of them)
-//!   - To allow for flexibility in the database layout once that's incorporated.
+//!   - To allow for flexibility in the database layout..
 
 use std::collections::BTreeMap;
 use std::sync::Arc;
@@ -30,15 +31,20 @@ use std::sync::Arc;
 use cht;
 
 use ethcore::block_status::BlockStatus;
-use ethcore::error::BlockError;
+use ethcore::error::{BlockImportError, BlockError};
 use ethcore::encoded;
 use ethcore::header::Header;
 use ethcore::ids::BlockId;
+use ethcore::spec::Spec;
+use ethcore::engines::epoch::{
+	Transition as EpochTransition,
+	PendingTransition as PendingEpochTransition
+};
 
 use rlp::{Encodable, Decodable, DecoderError, RlpStream, Rlp, UntrustedRlp};
 use heapsize::HeapSizeOf;
 use bigint::prelude::U256;
-use bigint::hash::H256;
+use bigint::hash::{H256, H256FastMap, H264};
 use util::kvdb::{DBTransaction, KeyValueDB};
 
 use cache::Cache;
@@ -54,6 +60,9 @@ const HISTORY: u64 = 2048;
 /// The best block key. Maps to an RLP list: [best_era, last_era]
 const CURRENT_KEY: &'static [u8] = &*b"best_and_latest";
 
+/// Key storing the last canonical epoch transition.
+const LAST_CANONICAL_TRANSITION: &'static [u8] = &*b"canonical_transition";
+
 /// Information about a block.
 #[derive(Debug, Clone)]
 pub struct BlockDescriptor {
@@ -101,7 +110,6 @@ impl Encodable for Entry {
 
 impl Decodable for Entry {
 	fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
-
 		let mut candidates = SmallVec::<[Candidate; 3]>::new();
 
 		for item in rlp.iter() {
@@ -131,6 +139,42 @@ fn era_key(number: u64) -> String {
 	format!("candidates_{}", number)
 }
 
+fn pending_transition_key(block_hash: H256) -> H264 {
+	const LEADING: u8 = 1;
+
+	let mut key = H264::default();
+
+	key[0] = LEADING;
+	key.0[1..].copy_from_slice(&block_hash.0[..]);
+
+	key
+}
+
+fn transition_key(block_hash: H256) -> H264 {
+	const LEADING: u8 = 2;
+
+	let mut key = H264::default();
+
+	key[0] = LEADING;
+	key.0[1..].copy_from_slice(&block_hash.0[..]);
+
+	key
+}
+
+// encode last canonical transition entry: header and proof.
+fn encode_canonical_transition(header: &Header, proof: &[u8]) -> Vec<u8> {
+	let mut stream = RlpStream::new_list(2);
+	stream.append(header).append(&proof);
+	stream.out()
+}
+
+// decode last canonical transition entry.
+fn decode_canonical_transition(t: &[u8]) -> Result<(Header, &[u8]), DecoderError> {
+	let rlp = UntrustedRlp::new(t);
+
+	Ok((rlp.val_at(0)?, rlp.at(1)?.data()?))
+}
+
 /// Pending changes from `insert` to be applied after the database write has finished.
 pub struct PendingChanges {
 	best_block: Option<BlockDescriptor>, // new best block.
@@ -141,6 +185,7 @@ pub struct HeaderChain {
 	genesis_header: encoded::Header, // special-case the genesis.
 	candidates: RwLock<BTreeMap<u64, Entry>>,
 	best_block: RwLock<BlockDescriptor>,
+	live_epoch_proofs: RwLock<H256FastMap<EpochTransition>>,
 	db: Arc<KeyValueDB>,
 	col: Option<u32>,
 	cache: Arc<Mutex<Cache>>,
@@ -148,8 +193,16 @@ pub struct HeaderChain {
 
 impl HeaderChain {
 	/// Create a new header chain given this genesis block and database to read from.
-	pub fn new(db: Arc<KeyValueDB>, col: Option<u32>, genesis: &[u8], cache: Arc<Mutex<Cache>>) -> Result<Self, String> {
-		use ethcore::views::HeaderView;
+	pub fn new(
+		db: Arc<KeyValueDB>,
+		col: Option<u32>,
+		spec: &Spec,
+		cache: Arc<Mutex<Cache>>,
+	) -> Result<Self, String> {
+		let mut live_epoch_proofs = ::std::collections::HashMap::default();
+
+		let genesis = ::rlp::encode(&spec.genesis_header()).into_vec();
+		let decoded_header = spec.genesis_header();
 
 		let chain = if let Some(current) = db.get(col, CURRENT_KEY)? {
 			let (best_number, highest_number) = {
@@ -160,12 +213,24 @@ impl HeaderChain {
 			let mut cur_number = highest_number;
 			let mut candidates = BTreeMap::new();
 
-			// load all era entries and referenced headers within them.
+			// load all era entries, referenced headers within them,
+			// and live epoch proofs.
 			while let Some(entry) = db.get(col, era_key(cur_number).as_bytes())? {
 				let entry: Entry = ::rlp::decode(&entry);
 				trace!(target: "chain", "loaded header chain entry for era {} with {} candidates",
 					cur_number, entry.candidates.len());
 
+				for c in &entry.candidates {
+					let key = transition_key(c.hash);
+
+					if let Some(proof) = db.get(col, &*key)? {
+						live_epoch_proofs.insert(c.hash, EpochTransition {
+							block_hash: c.hash,
+							block_number: cur_number,
+							proof: proof.into_vec(),
+						});
+					}
+				}
 				candidates.insert(cur_number, entry);
 
 				cur_number -= 1;
@@ -187,29 +252,42 @@ impl HeaderChain {
 			};
 
 			HeaderChain {
-				genesis_header: encoded::Header::new(genesis.to_owned()),
+				genesis_header: encoded::Header::new(genesis),
 				best_block: RwLock::new(best_block),
 				candidates: RwLock::new(candidates),
+				live_epoch_proofs: RwLock::new(live_epoch_proofs),
 				db: db,
 				col: col,
 				cache: cache,
 			}
 		} else {
-			let g_view = HeaderView::new(genesis);
 			HeaderChain {
-				genesis_header: encoded::Header::new(genesis.to_owned()),
+				genesis_header: encoded::Header::new(genesis),
 				best_block: RwLock::new(BlockDescriptor {
-					hash: g_view.hash(),
+					hash: decoded_header.hash(),
 					number: 0,
-					total_difficulty: g_view.difficulty(),
+					total_difficulty: *decoded_header.difficulty(),
 				}),
 				candidates: RwLock::new(BTreeMap::new()),
+				live_epoch_proofs: RwLock::new(live_epoch_proofs),
 				db: db,
 				col: col,
 				cache: cache,
 			}
 		};
 
+		// instantiate genesis epoch data if it doesn't exist.
+		if let None = chain.db.get(col, LAST_CANONICAL_TRANSITION)? {
+			let genesis_data = spec.genesis_epoch_data()?;
+
+			{
+				let mut batch = chain.db.transaction();
+				let data = encode_canonical_transition(&decoded_header, &genesis_data);
+				batch.put_vec(col, LAST_CANONICAL_TRANSITION, data);
+				chain.db.write(batch)?;
+			}
+		}
+
 		Ok(chain)
 	}
 
@@ -218,10 +296,24 @@ impl HeaderChain {
 	/// This blindly trusts that the data given to it is sensible.
 	/// Returns a set of pending changes to be applied with `apply_pending`
 	/// before the next call to insert and after the transaction has been written.
-	pub fn insert(&self, transaction: &mut DBTransaction, header: Header) -> Result<PendingChanges, BlockError> {
+	///
+	/// If the block is an epoch transition, provide the transition along with
+	/// the header.
+	pub fn insert(
+		&self,
+		transaction: &mut DBTransaction,
+		header: Header,
+		transition_proof: Option<Vec<u8>>,
+	) -> Result<PendingChanges, BlockImportError> {
 		let hash = header.hash();
 		let number = header.number();
 		let parent_hash = *header.parent_hash();
+		let transition = transition_proof.map(|proof| EpochTransition {
+			block_hash: hash,
+			block_number: number,
+			proof: proof,
+		});
+
 		let mut pending = PendingChanges {
 			best_block: None,
 		};
@@ -237,7 +329,8 @@ impl HeaderChain {
 				candidates.get(&(number - 1))
 					.and_then(|entry| entry.candidates.iter().find(|c| c.hash == parent_hash))
 					.map(|c| c.total_difficulty)
-					.ok_or_else(|| BlockError::UnknownParent(parent_hash))?
+					.ok_or_else(|| BlockError::UnknownParent(parent_hash))
+					.map_err(BlockImportError::Block)?
 			};
 
 		let total_difficulty = parent_td + *header.difficulty();
@@ -262,8 +355,13 @@ impl HeaderChain {
 			transaction.put(self.col, era_key(number).as_bytes(), &::rlp::encode(&*cur_era))
 		}
 
-		let raw = ::rlp::encode(&header);
-		transaction.put(self.col, &hash[..], &*raw);
+		if let Some(transition) = transition {
+			transaction.put(self.col, &*transition_key(hash), &transition.proof);
+			self.live_epoch_proofs.write().insert(hash, transition);
+		}
+
+		let raw = header.encoded().into_inner();
+		transaction.put_vec(self.col, &hash[..], raw);
 
 		let (best_num, is_new_best) = {
 			let cur_best = self.best_block.read();
@@ -316,8 +414,10 @@ impl HeaderChain {
 				let cht_num = cht::block_to_cht_number(earliest_era)
 					.expect("fails only for number == 0; genesis never imported; qed");
 
+				let mut last_canonical_transition = None;
 				let cht_root = {
 					let mut i = earliest_era;
+					let mut live_epoch_proofs = self.live_epoch_proofs.write();
 
 					// iterable function which removes the candidates as it goes
 					// along. this will only be called until the CHT is complete.
@@ -328,7 +428,25 @@ impl HeaderChain {
 
 						i += 1;
 
+						// prune old blocks and epoch proofs.
 						for ancient in &era_entry.candidates {
+							let maybe_transition = live_epoch_proofs.remove(&ancient.hash);
+							if let Some(epoch_transition) = maybe_transition {
+								transaction.delete(self.col, &*transition_key(ancient.hash));
+
+								if ancient.hash == era_entry.canonical_hash {
+									last_canonical_transition = match self.db.get(self.col, &ancient.hash) {
+										Err(e) => {
+											warn!(target: "chain", "Error reading from DB: {}\n
+												", e);
+											None
+										}
+										Ok(None) => panic!("stored candidates always have corresponding headers; qed"),
+										Ok(Some(header)) => Some((epoch_transition, ::rlp::decode(&header))),
+									};
+								}
+							}
+
 							transaction.delete(self.col, &ancient.hash);
 						}
 
@@ -342,6 +460,12 @@ impl HeaderChain {
 				// write the CHT root to the database.
 				debug!(target: "chain", "Produced CHT {} root: {:?}", cht_num, cht_root);
 				transaction.put(self.col, cht_key(cht_num).as_bytes(), &::rlp::encode(&cht_root));
+
+				// update the last canonical transition proof
+				if let Some((epoch_transition, header)) = last_canonical_transition {
+					let x = encode_canonical_transition(&header, &epoch_transition.proof);
+					transaction.put_vec(self.col, LAST_CANONICAL_TRANSITION, x);
+				}
 			}
 		}
 
@@ -367,7 +491,7 @@ impl HeaderChain {
 	/// will be returned.
 	pub fn block_hash(&self, id: BlockId) -> Option<H256> {
 		match id {
-			BlockId::Earliest => Some(self.genesis_hash()),
+			BlockId::Earliest | BlockId::Number(0) => Some(self.genesis_hash()),
 			BlockId::Hash(hash) => Some(hash),
 			BlockId::Number(num) => {
 				if self.best_block.read().number < num { return None }
@@ -518,6 +642,56 @@ impl HeaderChain {
 			false => BlockStatus::Unknown,
 		}
 	}
+
+	/// Insert a pending transition.
+	pub fn insert_pending_transition(&self, batch: &mut DBTransaction, hash: H256, t: PendingEpochTransition) {
+		let key = pending_transition_key(hash);
+		batch.put(self.col, &*key, &*::rlp::encode(&t));
+	}
+
+	/// Get pending transition for a specific block hash.
+	pub fn pending_transition(&self, hash: H256) -> Option<PendingEpochTransition> {
+		let key = pending_transition_key(hash);
+		match self.db.get(self.col, &*key) {
+			Ok(val) => val.map(|x| ::rlp::decode(&x)),
+			Err(e) => {
+				warn!(target: "chain", "Error reading from database: {}", e);
+				None
+			}
+		}
+	}
+
+	/// Get the transition to the epoch the given parent hash is part of
+	/// or transitions to.
+	/// This will give the epoch that any children of this parent belong to.
+	///
+	/// The header corresponding the the parent hash must be stored already.
+	pub fn epoch_transition_for(&self, parent_hash: H256) -> Option<(Header, Vec<u8>)> {
+		// slow path: loop back block by block
+		let live_proofs = self.live_epoch_proofs.read();
+
+		for hdr in self.ancestry_iter(BlockId::Hash(parent_hash)) {
+			if let Some(transition) = live_proofs.get(&hdr.hash()).cloned() {
+				return Some((hdr.decode(), transition.proof))
+			}
+		}
+
+		// any blocks left must be descendants of the last canonical transition block.
+		match self.db.get(self.col, LAST_CANONICAL_TRANSITION) {
+			Ok(x) => {
+				let x = x.expect("last canonical transition always instantiated; qed");
+
+				let (hdr, proof) = decode_canonical_transition(&x)
+					.expect("last canonical transition always encoded correctly; qed");
+
+				Some((hdr, proof.to_vec()))
+			}
+			Err(e) => {
+				warn!("Error reading from DB: {}", e);
+				None
+			}
+		}
+	}
 }
 
 impl HeapSizeOf for HeaderChain {
@@ -570,7 +744,7 @@ mod tests {
 
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
-		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache).unwrap();
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
 
 		let mut parent_hash = genesis_header.hash();
 		let mut rolling_timestamp = genesis_header.timestamp();
@@ -583,7 +757,7 @@ mod tests {
 			parent_hash = header.hash();
 
 			let mut tx = db.transaction();
-			let pending = chain.insert(&mut tx, header).unwrap();
+			let pending = chain.insert(&mut tx, header, None).unwrap();
 			db.write(tx).unwrap();
 			chain.apply_pending(pending);
 
@@ -603,7 +777,7 @@ mod tests {
 		let db = make_db();
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
-		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache).unwrap();
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
 
 		let mut parent_hash = genesis_header.hash();
 		let mut rolling_timestamp = genesis_header.timestamp();
@@ -616,7 +790,7 @@ mod tests {
 			parent_hash = header.hash();
 
 			let mut tx = db.transaction();
-			let pending = chain.insert(&mut tx, header).unwrap();
+			let pending = chain.insert(&mut tx, header, None).unwrap();
 			db.write(tx).unwrap();
 			chain.apply_pending(pending);
 
@@ -635,7 +809,7 @@ mod tests {
 				parent_hash = header.hash();
 
 				let mut tx = db.transaction();
-				let pending = chain.insert(&mut tx, header).unwrap();
+				let pending = chain.insert(&mut tx, header, None).unwrap();
 				db.write(tx).unwrap();
 				chain.apply_pending(pending);
 
@@ -659,7 +833,7 @@ mod tests {
 				parent_hash = header.hash();
 
 				let mut tx = db.transaction();
-				let pending = chain.insert(&mut tx, header).unwrap();
+				let pending = chain.insert(&mut tx, header, None).unwrap();
 				db.write(tx).unwrap();
 				chain.apply_pending(pending);
 
@@ -682,12 +856,10 @@ mod tests {
 	#[test]
 	fn earliest_is_latest() {
 		let spec = Spec::new_test();
-		let genesis_header = spec.genesis_header();
 		let db = make_db();
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
-		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache).unwrap();
-
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
 
 		assert!(chain.block_header(BlockId::Earliest).is_some());
 		assert!(chain.block_header(BlockId::Latest).is_some());
@@ -702,7 +874,7 @@ mod tests {
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
 		{
-			let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
+			let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
 			let mut parent_hash = genesis_header.hash();
 			let mut rolling_timestamp = genesis_header.timestamp();
 			for i in 1..10000 {
@@ -714,7 +886,7 @@ mod tests {
 				parent_hash = header.hash();
 
 				let mut tx = db.transaction();
-				let pending = chain.insert(&mut tx, header).unwrap();
+				let pending = chain.insert(&mut tx, header, None).unwrap();
 				db.write(tx).unwrap();
 				chain.apply_pending(pending);
 
@@ -722,7 +894,7 @@ mod tests {
 			}
 		}
 
-		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
 		assert!(chain.block_header(BlockId::Number(10)).is_none());
 		assert!(chain.block_header(BlockId::Number(9000)).is_some());
 		assert!(chain.cht_root(2).is_some());
@@ -738,7 +910,7 @@ mod tests {
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
 		{
-			let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
+			let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
 			let mut parent_hash = genesis_header.hash();
 			let mut rolling_timestamp = genesis_header.timestamp();
 
@@ -752,7 +924,7 @@ mod tests {
 				parent_hash = header.hash();
 
 				let mut tx = db.transaction();
-				let pending = chain.insert(&mut tx, header).unwrap();
+				let pending = chain.insert(&mut tx, header, None).unwrap();
 				db.write(tx).unwrap();
 				chain.apply_pending(pending);
 
@@ -769,7 +941,7 @@ mod tests {
 				parent_hash = header.hash();
 
 				let mut tx = db.transaction();
-				let pending = chain.insert(&mut tx, header).unwrap();
+				let pending = chain.insert(&mut tx, header, None).unwrap();
 				db.write(tx).unwrap();
 				chain.apply_pending(pending);
 
@@ -780,7 +952,7 @@ mod tests {
 		}
 
 		// after restoration, non-canonical eras should still be loaded.
-		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
 		assert_eq!(chain.block_header(BlockId::Latest).unwrap().number(), 10);
 		assert!(chain.candidates.read().get(&100).is_some())
 	}
@@ -792,10 +964,76 @@ mod tests {
 		let db = make_db();
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
-		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
 
 		assert!(chain.block_header(BlockId::Earliest).is_some());
 		assert!(chain.block_header(BlockId::Number(0)).is_some());
 		assert!(chain.block_header(BlockId::Hash(genesis_header.hash())).is_some());
 	}
+
+	#[test]
+	fn epoch_transitions_available_after_cht() {
+		let spec = Spec::new_test();
+		let genesis_header = spec.genesis_header();
+		let db = make_db();
+		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
+
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
+
+		let mut parent_hash = genesis_header.hash();
+		let mut rolling_timestamp = genesis_header.timestamp();
+		for i in 1..6 {
+			let mut header = Header::new();
+			header.set_parent_hash(parent_hash);
+			header.set_number(i);
+			header.set_timestamp(rolling_timestamp);
+			header.set_difficulty(*genesis_header.difficulty() * i.into());
+			parent_hash = header.hash();
+
+			let mut tx = db.transaction();
+			let epoch_proof = if i == 3 {
+				Some(vec![1, 2, 3, 4])
+			} else {
+				None
+			};
+
+			let pending = chain.insert(&mut tx, header, epoch_proof).unwrap();
+			db.write(tx).unwrap();
+			chain.apply_pending(pending);
+
+			rolling_timestamp += 10;
+		}
+
+		// these 3 should end up falling back to the genesis epoch proof in DB
+		for i in 0..3 {
+			let hash = chain.block_hash(BlockId::Number(i)).unwrap();
+			assert_eq!(chain.epoch_transition_for(hash).unwrap().1, Vec::<u8>::new());
+		}
+
+		// these are live.
+		for i in 3..6 {
+			let hash = chain.block_hash(BlockId::Number(i)).unwrap();
+			assert_eq!(chain.epoch_transition_for(hash).unwrap().1, vec![1, 2, 3, 4]);
+		}
+
+		for i in 6..10000 {
+			let mut header = Header::new();
+			header.set_parent_hash(parent_hash);
+			header.set_number(i);
+			header.set_timestamp(rolling_timestamp);
+			header.set_difficulty(*genesis_header.difficulty() * i.into());
+			parent_hash = header.hash();
+
+			let mut tx = db.transaction();
+			let pending = chain.insert(&mut tx, header, None).unwrap();
+			db.write(tx).unwrap();
+			chain.apply_pending(pending);
+
+			rolling_timestamp += 10;
+		}
+
+		// no live blocks have associated epoch proofs -- make sure we aren't leaking memory.
+		assert!(chain.live_epoch_proofs.read().is_empty());
+		assert_eq!(chain.epoch_transition_for(parent_hash).unwrap().1, vec![1, 2, 3, 4]);
+	}
 }

ethcore/light/src/client/mod.rs

@@ -20,10 +20,10 @@ use std::sync::{Weak, Arc};
 
 use ethcore::block_status::BlockStatus;
 use ethcore::client::{ClientReport, EnvInfo};
-use ethcore::engines::Engine;
+use ethcore::engines::{epoch, Engine, EpochChange, EpochTransition, Proof, Unsure};
 use ethcore::error::BlockImportError;
 use ethcore::ids::BlockId;
-use ethcore::header::Header;
+use ethcore::header::{BlockNumber, Header};
 use ethcore::verification::queue::{self, HeaderQueue};
 use ethcore::blockchain_info::BlockChainInfo;
 use ethcore::spec::Spec;
@@ -33,9 +33,11 @@ use io::IoChannel;
 use parking_lot::{Mutex, RwLock};
 use bigint::prelude::U256;
 use bigint::hash::H256;
+use futures::{IntoFuture, Future};
 
 use util::kvdb::{KeyValueDB, CompactionProfile};
 
+use self::fetch::ChainDataFetcher;
 use self::header_chain::{AncestryIter, HeaderChain};
 
 use cache::Cache;
@@ -45,6 +47,8 @@ pub use self::service::Service;
 mod header_chain;
 mod service;
 
+pub mod fetch;
+
 /// Configuration for the light client.
 #[derive(Debug, Clone)]
 pub struct Config {
@@ -80,6 +84,9 @@ impl Default for Config {
 
 /// Trait for interacting with the header chain abstractly.
 pub trait LightChainClient: Send + Sync {
+	/// Adds a new `LightChainNotify` listener.
+	fn add_listener(&self, listener: Weak<LightChainNotify>);
+
 	/// Get chain info.
 	fn chain_info(&self) -> BlockChainInfo;
 
@@ -128,7 +135,7 @@ pub trait LightChainClient: Send + Sync {
 	fn cht_root(&self, i: usize) -> Option<H256>;
 
 	/// Get the EIP-86 transition block number.
-	fn eip86_transition(&self) -> u64;
+	fn eip86_transition(&self) -> BlockNumber;
 
 	/// Get a report of import activity since the last call.
 	fn report(&self) -> ClientReport;
@@ -156,7 +163,7 @@ impl<T: LightChainClient> AsLightClient for T {
 }
 
 /// Light client implementation.
-pub struct Client {
+pub struct Client<T> {
 	queue: HeaderQueue,
 	engine: Arc<Engine>,
 	chain: HeaderChain,
@@ -164,22 +171,30 @@ pub struct Client {
 	import_lock: Mutex<()>,
 	db: Arc<KeyValueDB>,
 	listeners: RwLock<Vec<Weak<LightChainNotify>>>,
+	fetcher: T,
 	verify_full: bool,
 }
 
-impl Client {
+impl<T: ChainDataFetcher> Client<T> {
 	/// Create a new `Client`.
-	pub fn new(config: Config, db: Arc<KeyValueDB>, chain_col: Option<u32>, spec: &Spec, io_channel: IoChannel<ClientIoMessage>, cache: Arc<Mutex<Cache>>) -> Result<Self, String> {
-		let gh = ::rlp::encode(&spec.genesis_header());
-
+	pub fn new(
+		config: Config,
+		db: Arc<KeyValueDB>,
+		chain_col: Option<u32>,
+		spec: &Spec,
+		fetcher: T,
+		io_channel: IoChannel<ClientIoMessage>,
+		cache: Arc<Mutex<Cache>>
+	) -> Result<Self, String> {
 		Ok(Client {
 			queue: HeaderQueue::new(config.queue, spec.engine.clone(), io_channel, config.check_seal),
 			engine: spec.engine.clone(),
-			chain: HeaderChain::new(db.clone(), chain_col, &gh, cache)?,
+			chain: HeaderChain::new(db.clone(), chain_col, &spec, cache)?,
 			report: RwLock::new(ClientReport::default()),
 			import_lock: Mutex::new(()),
 			db: db,
 			listeners: RwLock::new(vec![]),
+			fetcher: fetcher,
 			verify_full: config.verify_full,
 		})
 	}
@@ -191,10 +206,24 @@ impl Client {
 
 	/// Create a new `Client` backed purely in-memory.
 	/// This will ignore all database options in the configuration.
-	pub fn in_memory(config: Config, spec: &Spec, io_channel: IoChannel<ClientIoMessage>, cache: Arc<Mutex<Cache>>) -> Self {
+	pub fn in_memory(
+		config: Config,
+		spec: &Spec,
+		fetcher: T,
+		io_channel: IoChannel<ClientIoMessage>,
+		cache: Arc<Mutex<Cache>>
+	) -> Self {
 		let db = ::util::kvdb::in_memory(0);
 
-		Client::new(config, Arc::new(db), None, spec, io_channel, cache).expect("New DB creation infallible; qed")
+		Client::new(
+			config,
+			Arc::new(db),
+			None,
+			spec,
+			fetcher,
+			io_channel,
+			cache
+		).expect("New DB creation infallible; qed")
 	}
 
 	/// Import a header to the queue for additional verification.
@@ -293,19 +322,33 @@ impl Client {
 				continue
 			}
 
-			// TODO: `epoch_end_signal`, `is_epoch_end`.
-			// proofs we get from the network would be _complete_, whereas we need
-			// _incomplete_ signals
+			let write_proof_result = match self.check_epoch_signal(&verified_header) {
+				Ok(Some(proof)) => self.write_pending_proof(&verified_header, proof),
+				Ok(None) => Ok(()),
+				Err(e) =>
+					panic!("Unable to fetch epoch transition proof: {:?}", e),
+			};
+
+			if let Err(e) = write_proof_result {
+				warn!(target: "client", "Error writing pending transition proof to DB: {:?} \
+					The node may not be able to synchronize further.", e);
+			}
+
+			let epoch_proof =  self.engine.is_epoch_end(
+				&verified_header,
+				&|h| self.chain.block_header(BlockId::Hash(h)).map(|hdr| hdr.decode()),
+				&|h| self.chain.pending_transition(h),
+			);
 
 			let mut tx = self.db.transaction();
-			let pending = match self.chain.insert(&mut tx, verified_header) {
+			let pending = match self.chain.insert(&mut tx, verified_header, epoch_proof) {
 				Ok(pending) => {
 					good.push(hash);
 					self.report.write().blocks_imported += 1;
 					pending
 				}
 				Err(e) => {
-					debug!(target: "client", "Error importing header {:?}: {}", (num, hash), e);
+					debug!(target: "client", "Error importing header {:?}: {:?}", (num, hash), e);
 					bad.push(hash);
 					continue;
 				}
@@ -421,9 +464,76 @@ impl Client {
 
 		true
 	}
+
+	fn check_epoch_signal(&self, verified_header: &Header) -> Result<Option<Proof>, T::Error> {
+		let (mut block, mut receipts) = (None, None);
+
+		// First, check without providing auxiliary data.
+		match self.engine.signals_epoch_end(verified_header, None, None) {
+			EpochChange::No => return Ok(None),
+			EpochChange::Yes(proof) => return Ok(Some(proof)),
+			EpochChange::Unsure(unsure) => {
+				let (b, r) = match unsure {
+					Unsure::NeedsBody =>
+						(Some(self.fetcher.block_body(verified_header)), None),
+					Unsure::NeedsReceipts =>
+						(None, Some(self.fetcher.block_receipts(verified_header))),
+					Unsure::NeedsBoth => (
+						Some(self.fetcher.block_body(verified_header)),
+						Some(self.fetcher.block_receipts(verified_header)),
+					),
+				};
+
+				if let Some(b) = b {
+					block = Some(b.into_future().wait()?.into_inner());
+				}
+
+				if let Some(r) = r {
+					receipts = Some(r.into_future().wait()?);
+				}
+			}
+		}
+
+		let block = block.as_ref().map(|x| &x[..]);
+		let receipts = receipts.as_ref().map(|x| &x[..]);
+
+		// Check again now that required data has been fetched.
+		match self.engine.signals_epoch_end(verified_header, block, receipts) {
+			EpochChange::No => return Ok(None),
+			EpochChange::Yes(proof) => return Ok(Some(proof)),
+			EpochChange::Unsure(_) =>
+				panic!("Detected faulty engine implementation: requests additional \
+					data to check epoch end signal when everything necessary provided"),
+		}
+	}
+
+	// attempts to fetch the epoch proof from the network until successful.
+	fn write_pending_proof(&self, header: &Header, proof: Proof) -> Result<(), T::Error> {
+		let proof = match proof {
+			Proof::Known(known) => known,
+			Proof::WithState(state_dependent) => {
+				self.fetcher.epoch_transition(
+					header.hash(),
+					self.engine.clone(),
+					state_dependent
+				).into_future().wait()?
+			}
+		};
+
+		let mut batch = self.db.transaction();
+		self.chain.insert_pending_transition(&mut batch, header.hash(), epoch::PendingTransition {
+			proof: proof,
+		});
+		self.db.write_buffered(batch);
+		Ok(())
+	}
 }
 
-impl LightChainClient for Client {
+impl<T: ChainDataFetcher> LightChainClient for Client<T> {
+	fn add_listener(&self, listener: Weak<LightChainNotify>) {
+		Client::add_listener(self, listener)
+	}
+
 	fn chain_info(&self) -> BlockChainInfo { Client::chain_info(self) }
 
 	fn queue_header(&self, header: Header) -> Result<H256, BlockImportError> {
@@ -482,7 +592,7 @@ impl LightChainClient for Client {
 		Client::cht_root(self, i)
 	}
 
-	fn eip86_transition(&self) -> u64 {
+	fn eip86_transition(&self) -> BlockNumber {
 		self.engine().params().eip86_transition
 	}
 
@@ -490,3 +600,29 @@ impl LightChainClient for Client {
 		Client::report(self)
 	}
 }
+
+impl<T: ChainDataFetcher> ::ethcore::client::EngineClient for Client<T> {
+	fn update_sealing(&self) { }
+	fn submit_seal(&self, _block_hash: H256, _seal: Vec<Vec<u8>>) { }
+	fn broadcast_consensus_message(&self, _message: Vec<u8>) { }
+
+	fn epoch_transition_for(&self, parent_hash: H256) -> Option<EpochTransition> {
+		self.chain.epoch_transition_for(parent_hash).map(|(hdr, proof)| EpochTransition {
+			block_hash: hdr.hash(),
+			block_number: hdr.number(),
+			proof: proof,
+		})
+	}
+
+	fn chain_info(&self) -> BlockChainInfo {
+		Client::chain_info(self)
+	}
+
+	fn as_full_client(&self) -> Option<&::ethcore::client::BlockChainClient> {
+		None
+	}
+
+	fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
+		self.block_header(id).map(|hdr| hdr.number())
+	}
+}

ethcore/light/src/client/service.rs

@@ -30,7 +30,7 @@ use util::kvdb::{Database, DatabaseConfig};
 use cache::Cache;
 use parking_lot::Mutex;
 
-use super::{Client, Config as ClientConfig};
+use super::{ChainDataFetcher, Client, Config as ClientConfig};
 
 /// Errors on service initialization.
 #[derive(Debug)]
@@ -51,14 +51,14 @@ impl fmt::Display for Error {
 }
 
 /// Light client service.
-pub struct Service {
-	client: Arc<Client>,
+pub struct Service<T> {
+	client: Arc<Client<T>>,
 	io_service: IoService<ClientIoMessage>,
 }
 
-impl Service {
+impl<T: ChainDataFetcher> Service<T> {
 	/// Start the service: initialize I/O workers and client itself.
-	pub fn start(config: ClientConfig, spec: &Spec, path: &Path, cache: Arc<Mutex<Cache>>) -> Result<Self, Error> {
+	pub fn start(config: ClientConfig, spec: &Spec, fetcher: T, path: &Path, cache: Arc<Mutex<Cache>>) -> Result<Self, Error> {
 
 		// initialize database.
 		let mut db_config = DatabaseConfig::with_columns(db::NUM_COLUMNS);
@@ -81,10 +81,14 @@ impl Service {
 			db,
 			db::COL_LIGHT_CHAIN,
 			spec,
+			fetcher,
 			io_service.channel(),
 			cache,
 		).map_err(Error::Database)?);
+
 		io_service.register_handler(Arc::new(ImportBlocks(client.clone()))).map_err(Error::Io)?;
+		spec.engine.register_client(Arc::downgrade(&client) as _);
+
 		Ok(Service {
 			client: client,
 			io_service: io_service,
@@ -97,14 +101,14 @@ impl Service {
 	}
 
 	/// Get a handle to the client.
-	pub fn client(&self) -> &Arc<Client> {
+	pub fn client(&self) -> &Arc<Client<T>> {
 		&self.client
 	}
 }
 
-struct ImportBlocks(Arc<Client>);
+struct ImportBlocks<T>(Arc<Client<T>>);
 
-impl IoHandler<ClientIoMessage> for ImportBlocks {
+impl<T: ChainDataFetcher> IoHandler<ClientIoMessage> for ImportBlocks<T> {
 	fn message(&self, _io: &IoContext<ClientIoMessage>, message: &ClientIoMessage) {
 		if let ClientIoMessage::BlockVerified = *message {
 			self.0.import_verified();
@@ -120,6 +124,7 @@ mod tests {
 
 	use std::sync::Arc;
 	use cache::Cache;
+	use client::fetch;
 	use time::Duration;
 	use parking_lot::Mutex;
 
@@ -129,6 +134,6 @@ mod tests {
 		let temp_path = RandomTempPath::new();
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 
-		Service::start(Default::default(), &spec, temp_path.as_path(), cache).unwrap();
+		Service::start(Default::default(), &spec, fetch::unavailable(), temp_path.as_path(), cache).unwrap();
 	}
 }

ethcore/light/src/net/load_timer.rs

@@ -62,6 +62,7 @@ fn hardcoded_serve_time(kind: Kind) -> u64 {
 		Kind::Storage => 2_000_000,
 		Kind::Code => 1_500_000,
 		Kind::Execution => 250, // per gas.
+		Kind::Signal => 500_000,
 	}
 }
 

ethcore/light/src/net/mod.rs

@@ -104,9 +104,8 @@ mod packet {
 	// relay transactions to peers.
 	pub const SEND_TRANSACTIONS: u8 = 0x06;
 
-	// request and respond with epoch transition proof
-	pub const REQUEST_EPOCH_PROOF: u8 = 0x07;
-	pub const EPOCH_PROOF: u8 = 0x08;
+	// two packets were previously meant to be reserved for epoch proofs.
+	// these have since been moved to requests.
 }
 
 // timeouts for different kinds of requests. all values are in milliseconds.
@@ -124,6 +123,7 @@ mod timeout {
 	pub const CONTRACT_CODE: i64 = 100;
 	pub const HEADER_PROOF: i64 = 100;
 	pub const TRANSACTION_PROOF: i64 = 1000; // per gas?
+	pub const EPOCH_SIGNAL: i64 = 200;
 }
 
 /// A request id.
@@ -584,12 +584,6 @@ impl LightProtocol {
 
 			packet::SEND_TRANSACTIONS => self.relay_transactions(peer, io, rlp),
 
-			packet::REQUEST_EPOCH_PROOF | packet::EPOCH_PROOF => {
-				// ignore these for now, but leave them specified.
-				debug!(target: "pip", "Ignoring request/response for epoch proof");
-				Ok(())
-			}
-
 			other => {
 				Err(Error::UnrecognizedPacket(other))
 			}
@@ -952,6 +946,7 @@ impl LightProtocol {
 				CompleteRequest::Storage(req) => self.provider.storage_proof(req).map(Response::Storage),
 				CompleteRequest::Code(req) => self.provider.contract_code(req).map(Response::Code),
 				CompleteRequest::Execution(req) => self.provider.transaction_proof(req).map(Response::Execution),
+				CompleteRequest::Signal(req) => self.provider.epoch_signal(req).map(Response::Signal),
 			}
 		});
 

ethcore/light/src/net/request_credits.rs

@@ -91,6 +91,7 @@ pub struct CostTable {
 	code: U256,
 	header_proof: U256,
 	transaction_proof: U256, // cost per gas.
+	epoch_signal: U256,
 }
 
 impl Default for CostTable {
@@ -107,6 +108,7 @@ impl Default for CostTable {
 			code: 20000.into(),
 			header_proof: 15000.into(),
 			transaction_proof: 2.into(),
+			epoch_signal: 10000.into(),
 		}
 	}
 }
@@ -121,7 +123,7 @@ impl Encodable for CostTable {
 			s.append(cost);
 		}
 
-		s.begin_list(10).append(&self.base);
+		s.begin_list(11).append(&self.base);
 		append_cost(s, &self.headers, request::Kind::Headers);
 		append_cost(s, &self.transaction_index, request::Kind::TransactionIndex);
 		append_cost(s, &self.body, request::Kind::Body);
@@ -131,6 +133,7 @@ impl Encodable for CostTable {
 		append_cost(s, &self.code, request::Kind::Code);
 		append_cost(s, &self.header_proof, request::Kind::HeaderProof);
 		append_cost(s, &self.transaction_proof, request::Kind::Execution);
+		append_cost(s, &self.epoch_signal, request::Kind::Signal);
 	}
 }
 
@@ -147,6 +150,7 @@ impl Decodable for CostTable {
 		let mut code = None;
 		let mut header_proof = None;
 		let mut transaction_proof = None;
+		let mut epoch_signal = None;
 
 		for cost_list in rlp.iter().skip(1) {
 			let cost = cost_list.val_at(1)?;
@@ -160,6 +164,7 @@ impl Decodable for CostTable {
 				request::Kind::Code => code = Some(cost),
 				request::Kind::HeaderProof => header_proof = Some(cost),
 				request::Kind::Execution => transaction_proof = Some(cost),
+				request::Kind::Signal => epoch_signal = Some(cost),
 			}
 		}
 
@@ -176,6 +181,7 @@ impl Decodable for CostTable {
 			code: unwrap_cost(code)?,
 			header_proof: unwrap_cost(header_proof)?,
 			transaction_proof: unwrap_cost(transaction_proof)?,
+			epoch_signal: unwrap_cost(epoch_signal)?,
 		})
 	}
 }
@@ -238,6 +244,7 @@ impl FlowParams {
 			code: cost_for_kind(Kind::Code),
 			header_proof: cost_for_kind(Kind::HeaderProof),
 			transaction_proof: cost_for_kind(Kind::Execution),
+			epoch_signal: cost_for_kind(Kind::Signal),
 		};
 
 		FlowParams {
@@ -263,7 +270,8 @@ impl FlowParams {
 				storage: free_cost.clone(),
 				code: free_cost.clone(),
 				header_proof: free_cost.clone(),
-				transaction_proof: free_cost,
+				transaction_proof: free_cost.clone(),
+				epoch_signal: free_cost,
 			}
 		}
 	}
@@ -293,6 +301,7 @@ impl FlowParams {
 			Request::Storage(_) => self.costs.storage,
 			Request::Code(_) => self.costs.code,
 			Request::Execution(ref req) => self.costs.transaction_proof * req.gas,
+			Request::Signal(_) => self.costs.epoch_signal,
 		}
 	}
 

ethcore/light/src/net/request_set.rs

@@ -139,6 +139,7 @@ fn compute_timeout(reqs: &Requests) -> Duration {
 			Request::Storage(_) => timeout::PROOF,
 			Request::Code(_) => timeout::CONTRACT_CODE,
 			Request::Execution(_) => timeout::TRANSACTION_PROOF,
+			Request::Signal(_) => timeout::EPOCH_SIGNAL,
 		}
 	}))
 }

ethcore/light/src/net/tests/mod.rs

@@ -158,6 +158,12 @@ impl Provider for TestProvider {
 		None
 	}
 
+	fn epoch_signal(&self, _req: request::CompleteSignalRequest) -> Option<request::SignalResponse> {
+		Some(request::SignalResponse {
+			signal: vec![1, 2, 3, 4],
+		})
+	}
+
 	fn ready_transactions(&self) -> Vec<PendingTransaction> {
 		self.0.client.ready_transactions()
 	}
@@ -523,6 +529,50 @@ fn get_contract_code() {
 	proto.handle_packet(&expected, &1, packet::REQUEST, &request_body);
 }
 
+#[test]
+fn epoch_signal() {
+	let capabilities = capabilities();
+
+	let (provider, proto) = setup(capabilities.clone());
+	let flow_params = proto.flow_params.read().clone();
+
+	let cur_status = status(provider.client.chain_info());
+
+	{
+		let packet_body = write_handshake(&cur_status, &capabilities, &proto);
+		proto.on_connect(&1, &Expect::Send(1, packet::STATUS, packet_body.clone()));
+		proto.handle_packet(&Expect::Nothing, &1, packet::STATUS, &packet_body);
+	}
+
+	let req_id = 112;
+	let request = Request::Signal(request::IncompleteSignalRequest {
+		block_hash: H256([1; 32]).into(),
+	});
+
+	let requests = encode_single(request.clone());
+	let request_body = make_packet(req_id, &requests);
+
+	let response = {
+		let response = vec![Response::Signal(SignalResponse {
+			signal: vec![1, 2, 3, 4],
+		})];
+
+		let limit = *flow_params.limit();
+		let cost = flow_params.compute_cost_multi(requests.requests());
+
+		println!("limit = {}, cost = {}", limit, cost);
+		let new_creds = limit - cost;
+
+		let mut response_stream = RlpStream::new_list(3);
+		response_stream.append(&req_id).append(&new_creds).append_list(&response);
+
+		response_stream.out()
+	};
+
+	let expected = Expect::Respond(packet::RESPONSE, response);
+	proto.handle_packet(&expected, &1, packet::REQUEST, &request_body);
+}
+
 #[test]
 fn proof_of_execution() {
 	let capabilities = capabilities();

ethcore/light/src/on_demand/mod.rs

@@ -195,6 +195,8 @@ fn guess_capabilities(requests: &[CheckedRequest]) -> Capabilities {
 				caps.serve_headers = true,
 			CheckedRequest::HeaderByHash(_, _) =>
 				caps.serve_headers = true,
+			CheckedRequest::Signal(_, _) =>
+				caps.serve_headers = true,
 			CheckedRequest::Body(ref req, _) => if let Ok(ref hdr) = req.0.as_ref() {
 				update_since(&mut caps.serve_chain_since, hdr.number());
 			},

ethcore/light/src/on_demand/request.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 
 use ethcore::basic_account::BasicAccount;
 use ethcore::encoded;
-use ethcore::engines::Engine;
+use ethcore::engines::{Engine, StateDependentProof};
 use ethcore::receipt::Receipt;
 use ethcore::state::{self, ProvedExecution};
 use ethcore::transaction::SignedTransaction;
@@ -56,6 +56,8 @@ pub enum Request {
 	Code(Code),
 	/// A request for proof of execution.
 	Execution(TransactionProof),
+	/// A request for epoch change signal.
+	Signal(Signal),
 }
 
 /// A request argument.
@@ -136,6 +138,7 @@ impl_single!(Body, Body, encoded::Block);
 impl_single!(Account, Account, Option<BasicAccount>);
 impl_single!(Code, Code, Bytes);
 impl_single!(Execution, TransactionProof, super::ExecutionResult);
+impl_single!(Signal, Signal, Vec<u8>);
 
 macro_rules! impl_args {
 	() => {
@@ -244,6 +247,7 @@ pub enum CheckedRequest {
 	Account(Account, net_request::IncompleteAccountRequest),
 	Code(Code, net_request::IncompleteCodeRequest),
 	Execution(TransactionProof, net_request::IncompleteExecutionRequest),
+	Signal(Signal, net_request::IncompleteSignalRequest)
 }
 
 impl From<Request> for CheckedRequest {
@@ -302,6 +306,12 @@ impl From<Request> for CheckedRequest {
 				};
 				CheckedRequest::Execution(req, net_req)
 			}
+			Request::Signal(req) => {
+				let net_req = net_request::IncompleteSignalRequest {
+					block_hash: req.hash.into(),
+				};
+				CheckedRequest::Signal(req, net_req)
+			}
 		}
 	}
 }
@@ -319,6 +329,7 @@ impl CheckedRequest {
 			CheckedRequest::Account(_, req) => NetRequest::Account(req),
 			CheckedRequest::Code(_, req) => NetRequest::Code(req),
 			CheckedRequest::Execution(_, req) => NetRequest::Execution(req),
+			CheckedRequest::Signal(_, req) => NetRequest::Signal(req),
 		}
 	}
 
@@ -446,6 +457,7 @@ macro_rules! match_me {
 			CheckedRequest::Account($check, $req) => $e,
 			CheckedRequest::Code($check, $req) => $e,
 			CheckedRequest::Execution($check, $req) => $e,
+			CheckedRequest::Signal($check, $req) => $e,
 		}
 	}
 }
@@ -473,6 +485,7 @@ impl IncompleteRequest for CheckedRequest {
 			CheckedRequest::Account(_, ref req) => req.check_outputs(f),
 			CheckedRequest::Code(_, ref req) => req.check_outputs(f),
 			CheckedRequest::Execution(_, ref req) => req.check_outputs(f),
+			CheckedRequest::Signal(_, ref req) => req.check_outputs(f),
 		}
 	}
 
@@ -493,6 +506,7 @@ impl IncompleteRequest for CheckedRequest {
 			CheckedRequest::Account(_, req) => req.complete().map(CompleteRequest::Account),
 			CheckedRequest::Code(_, req) => req.complete().map(CompleteRequest::Code),
 			CheckedRequest::Execution(_, req) => req.complete().map(CompleteRequest::Execution),
+			CheckedRequest::Signal(_, req) => req.complete().map(CompleteRequest::Signal),
 		}
 	}
 
@@ -544,6 +558,9 @@ impl net_request::CheckedRequest for CheckedRequest {
 			CheckedRequest::Execution(ref prover, _) =>
 				expect!((&NetResponse::Execution(ref res), _) =>
 					prover.check_response(cache, &res.items).map(Response::Execution)),
+			CheckedRequest::Signal(ref prover, _) =>
+				expect!((&NetResponse::Signal(ref res), _) =>
+					prover.check_response(cache, &res.signal).map(Response::Signal)),
 		}
 	 }
 }
@@ -567,6 +584,8 @@ pub enum Response {
 	Code(Vec<u8>),
 	/// Response to a request for proved execution.
 	Execution(super::ExecutionResult),
+	/// Response to a request for epoch change signal.
+	Signal(Vec<u8>),
 }
 
 impl net_request::ResponseLike for Response {
@@ -850,6 +869,27 @@ impl TransactionProof {
 	}
 }
 
+/// Request for epoch signal.
+/// Provide engine and state-dependent proof checker.
+#[derive(Clone)]
+pub struct Signal {
+	/// Block hash and number to fetch proof for.
+	pub hash: H256,
+	/// Consensus engine, used to check the proof.
+	pub engine: Arc<Engine>,
+	/// Special checker for the proof.
+	pub proof_check: Arc<StateDependentProof>,
+}
+
+impl Signal {
+	/// Check the signal, returning the signal or indicate that it's bad.
+	pub fn check_response(&self, _: &Mutex<::cache::Cache>, signal: &[u8]) -> Result<Vec<u8>, Error> {
+		self.proof_check.check_proof(&*self.engine, signal)
+			.map(|_| signal.to_owned())
+			.map_err(|_| Error::BadProof)
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;

ethcore/light/src/provider.rs

@@ -127,6 +127,9 @@ pub trait Provider: Send + Sync {
 	/// Provide a proof-of-execution for the given transaction proof request.
 	/// Returns a vector of all state items necessary to execute the transaction.
 	fn transaction_proof(&self, req: request::CompleteExecutionRequest) -> Option<request::ExecutionResponse>;
+
+	/// Provide epoch signal data at given block hash. This should be just the
+	fn epoch_signal(&self, req: request::CompleteSignalRequest) -> Option<request::SignalResponse>;
 }
 
 // Implementation of a light client data provider for a client.
@@ -265,6 +268,12 @@ impl<T: ProvingBlockChainClient + ?Sized> Provider for T {
 	fn ready_transactions(&self) -> Vec<PendingTransaction> {
 		BlockChainClient::ready_transactions(self)
 	}
+
+	fn epoch_signal(&self, req: request::CompleteSignalRequest) -> Option<request::SignalResponse> {
+		self.epoch_signal(req.block_hash).map(|signal| request::SignalResponse {
+			signal: signal,
+		})
+	}
 }
 
 /// The light client "provider" implementation. This wraps a `LightClient` and
@@ -330,6 +339,10 @@ impl<L: AsLightClient + Send + Sync> Provider for LightProvider<L> {
 		None
 	}
 
+	fn epoch_signal(&self, _req: request::CompleteSignalRequest) -> Option<request::SignalResponse> {
+		None
+	}
+
 	fn ready_transactions(&self) -> Vec<PendingTransaction> {
 		let chain_info = self.chain_info();
 		self.txqueue.read().ready_transactions(chain_info.best_block_number, chain_info.best_block_timestamp)

ethcore/light/src/types/request/mod.rs

@@ -67,6 +67,11 @@ pub use self::execution::{
 	Incomplete as IncompleteExecutionRequest,
 	Response as ExecutionResponse,
 };
+pub use self::epoch_signal::{
+	Complete as CompleteSignalRequest,
+	Incomplete as IncompleteSignalRequest,
+	Response as SignalResponse,
+};
 
 pub use self::builder::{RequestBuilder, Requests};
 
@@ -261,6 +266,8 @@ pub enum Request {
 	Code(IncompleteCodeRequest),
 	/// A request for proof of execution,
 	Execution(IncompleteExecutionRequest),
+	/// A request for an epoch signal.
+	Signal(IncompleteSignalRequest),
 }
 
 /// All request types, in an answerable state.
@@ -284,6 +291,8 @@ pub enum CompleteRequest {
 	Code(CompleteCodeRequest),
 	/// A request for proof of execution,
 	Execution(CompleteExecutionRequest),
+	/// A request for an epoch signal.
+	Signal(CompleteSignalRequest),
 }
 
 impl CompleteRequest {
@@ -299,6 +308,7 @@ impl CompleteRequest {
 			CompleteRequest::Storage(_) => Kind::Storage,
 			CompleteRequest::Code(_) => Kind::Code,
 			CompleteRequest::Execution(_) => Kind::Execution,
+			CompleteRequest::Signal(_) => Kind::Signal,
 		}
 	}
 }
@@ -316,6 +326,7 @@ impl Request {
 			Request::Storage(_) => Kind::Storage,
 			Request::Code(_) => Kind::Code,
 			Request::Execution(_) => Kind::Execution,
+			Request::Signal(_) => Kind::Signal,
 		}
 	}
 }
@@ -332,6 +343,7 @@ impl Decodable for Request {
 			Kind::Storage => Ok(Request::Storage(rlp.val_at(1)?)),
 			Kind::Code => Ok(Request::Code(rlp.val_at(1)?)),
 			Kind::Execution => Ok(Request::Execution(rlp.val_at(1)?)),
+			Kind::Signal => Ok(Request::Signal(rlp.val_at(1)?)),
 		}
 	}
 }
@@ -353,6 +365,7 @@ impl Encodable for Request {
 			Request::Storage(ref req) => s.append(req),
 			Request::Code(ref req) => s.append(req),
 			Request::Execution(ref req) => s.append(req),
+			Request::Signal(ref req) => s.append(req),
 		};
 	}
 }
@@ -374,6 +387,7 @@ impl IncompleteRequest for Request {
 			Request::Storage(ref req) => req.check_outputs(f),
 			Request::Code(ref req) => req.check_outputs(f),
 			Request::Execution(ref req) => req.check_outputs(f),
+			Request::Signal(ref req) => req.check_outputs(f),
 		}
 	}
 
@@ -388,6 +402,7 @@ impl IncompleteRequest for Request {
 			Request::Storage(ref req) => req.note_outputs(f),
 			Request::Code(ref req) => req.note_outputs(f),
 			Request::Execution(ref req) => req.note_outputs(f),
+			Request::Signal(ref req) => req.note_outputs(f),
 		}
 	}
 
@@ -402,6 +417,7 @@ impl IncompleteRequest for Request {
 			Request::Storage(ref mut req) => req.fill(oracle),
 			Request::Code(ref mut req) => req.fill(oracle),
 			Request::Execution(ref mut req) => req.fill(oracle),
+			Request::Signal(ref mut req) => req.fill(oracle),
 		}
 	}
 
@@ -416,6 +432,7 @@ impl IncompleteRequest for Request {
 			Request::Storage(req) => req.complete().map(CompleteRequest::Storage),
 			Request::Code(req) => req.complete().map(CompleteRequest::Code),
 			Request::Execution(req) => req.complete().map(CompleteRequest::Execution),
+			Request::Signal(req) => req.complete().map(CompleteRequest::Signal),
 		}
 	}
 
@@ -430,6 +447,7 @@ impl IncompleteRequest for Request {
 			Request::Storage(ref mut req) => req.adjust_refs(mapping),
 			Request::Code(ref mut req) => req.adjust_refs(mapping),
 			Request::Execution(ref mut req) => req.adjust_refs(mapping),
+			Request::Signal(ref mut req) => req.adjust_refs(mapping),
 		}
 	}
 }
@@ -471,6 +489,8 @@ pub enum Kind {
 	Code = 7,
 	/// A request for transaction execution + state proof.
 	Execution = 8,
+	/// A request for epoch transition signal.
+	Signal = 9,
 }
 
 impl Decodable for Kind {
@@ -485,6 +505,7 @@ impl Decodable for Kind {
 			6 => Ok(Kind::Storage),
 			7 => Ok(Kind::Code),
 			8 => Ok(Kind::Execution),
+			9 => Ok(Kind::Signal),
 			_ => Err(DecoderError::Custom("Unknown PIP request ID.")),
 		}
 	}
@@ -517,6 +538,8 @@ pub enum Response {
 	Code(CodeResponse),
 	/// A response for proof of execution,
 	Execution(ExecutionResponse),
+	/// A response for epoch change signal.
+	Signal(SignalResponse),
 }
 
 impl ResponseLike for Response {
@@ -532,6 +555,7 @@ impl ResponseLike for Response {
 			Response::Storage(ref res) => res.fill_outputs(f),
 			Response::Code(ref res) => res.fill_outputs(f),
 			Response::Execution(ref res) => res.fill_outputs(f),
+			Response::Signal(ref res) => res.fill_outputs(f),
 		}
 	}
 }
@@ -549,6 +573,7 @@ impl Response {
 			Response::Storage(_) => Kind::Storage,
 			Response::Code(_) => Kind::Code,
 			Response::Execution(_) => Kind::Execution,
+			Response::Signal(_) => Kind::Signal,
 		}
 	}
 }
@@ -565,6 +590,7 @@ impl Decodable for Response {
 			Kind::Storage => Ok(Response::Storage(rlp.val_at(1)?)),
 			Kind::Code => Ok(Response::Code(rlp.val_at(1)?)),
 			Kind::Execution => Ok(Response::Execution(rlp.val_at(1)?)),
+			Kind::Signal => Ok(Response::Signal(rlp.val_at(1)?)),
 		}
 	}
 }
@@ -586,6 +612,7 @@ impl Encodable for Response {
 			Response::Storage(ref res) => s.append(res),
 			Response::Code(ref res) => s.append(res),
 			Response::Execution(ref res) => s.append(res),
+			Response::Signal(ref res) => s.append(res),
 		};
 	}
 }
@@ -760,8 +787,8 @@ pub mod header {
 pub mod header_proof {
 	use super::{Field, NoSuchOutput, OutputKind, Output};
 	use rlp::{Encodable, Decodable, DecoderError, RlpStream, UntrustedRlp};
-	use bigint::hash::H256;
 	use bigint::prelude::U256;
+	use bigint::hash::H256;
 	use util::Bytes;
 
 	/// Potentially incomplete header proof request.
@@ -1091,8 +1118,8 @@ pub mod block_body {
 /// A request for an account proof.
 pub mod account {
 	use super::{Field, NoSuchOutput, OutputKind, Output};
-	use bigint::hash::H256;
 	use bigint::prelude::U256;
+	use bigint::hash::H256;
 	use util::Bytes;
 
 	/// Potentially incomplete request for an account proof.
@@ -1388,8 +1415,8 @@ pub mod execution {
 	use super::{Field, NoSuchOutput, OutputKind, Output};
 	use ethcore::transaction::Action;
 	use rlp::{Encodable, Decodable, DecoderError, RlpStream, UntrustedRlp};
-	use bigint::hash::H256;
 	use bigint::prelude::U256;
+	use bigint::hash::H256;
 	use util::{Bytes, Address, DBValue};
 
 	/// Potentially incomplete execution proof request.
@@ -1509,6 +1536,105 @@ pub mod execution {
 	}
 }
 
+/// A request for epoch signal data.
+pub mod epoch_signal {
+	use super::{Field, NoSuchOutput, OutputKind, Output};
+	use rlp::{Encodable, Decodable, DecoderError, RlpStream, UntrustedRlp};
+	use bigint::hash::H256;
+	use util::Bytes;
+
+	/// Potentially incomplete epoch signal request.
+	#[derive(Debug, Clone, PartialEq, Eq)]
+	pub struct Incomplete {
+		/// The block hash to request the signal for.
+		pub block_hash: Field<H256>,
+	}
+
+	impl Decodable for Incomplete {
+		fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
+			Ok(Incomplete {
+				block_hash: rlp.val_at(0)?,
+			})
+		}
+	}
+
+	impl Encodable for Incomplete {
+		fn rlp_append(&self, s: &mut RlpStream) {
+			s.begin_list(1).append(&self.block_hash);
+		}
+	}
+
+	impl super::IncompleteRequest for Incomplete {
+		type Complete = Complete;
+		type Response = Response;
+
+		fn check_outputs<F>(&self, mut f: F) -> Result<(), NoSuchOutput>
+			where F: FnMut(usize, usize, OutputKind) -> Result<(), NoSuchOutput>
+		{
+			if let Field::BackReference(req, idx) = self.block_hash {
+				f(req, idx, OutputKind::Hash)?;
+			}
+
+			Ok(())
+		}
+
+		fn note_outputs<F>(&self, _: F) where F: FnMut(usize, OutputKind) {}
+
+		fn fill<F>(&mut self, oracle: F) where F: Fn(usize, usize) -> Result<Output, NoSuchOutput> {
+			if let Field::BackReference(req, idx) = self.block_hash {
+				self.block_hash = match oracle(req, idx) {
+					Ok(Output::Hash(block_hash)) => Field::Scalar(block_hash.into()),
+					_ => Field::BackReference(req, idx),
+				}
+			}
+		}
+
+		fn complete(self) -> Result<Self::Complete, NoSuchOutput> {
+			Ok(Complete {
+				block_hash: self.block_hash.into_scalar()?,
+			})
+		}
+
+		fn adjust_refs<F>(&mut self, mut mapping: F) where F: FnMut(usize) -> usize {
+			self.block_hash.adjust_req(&mut mapping);
+		}
+	}
+
+	/// A complete request.
+	#[derive(Debug, Clone, PartialEq, Eq)]
+	pub struct Complete {
+		/// The block hash to request the epoch signal for.
+		pub block_hash: H256,
+	}
+
+	/// The output of a request for an epoch signal.
+	#[derive(Debug, Clone, PartialEq, Eq)]
+	pub struct Response {
+		/// The requested epoch signal.
+		pub signal: Bytes,
+	}
+
+	impl super::ResponseLike for Response {
+		/// Fill reusable outputs by providing them to the function.
+		fn fill_outputs<F>(&self, _: F) where F: FnMut(usize, Output) {}
+	}
+
+	impl Decodable for Response {
+		fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
+
+			Ok(Response {
+				signal: rlp.as_val()?,
+			})
+		}
+	}
+
+	impl Encodable for Response {
+		fn rlp_append(&self, s: &mut RlpStream) {
+			s.append(&self.signal);
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -1797,4 +1923,22 @@ mod tests {
 		let raw = ::rlp::encode_list(&reqs);
 		assert_eq!(::rlp::decode_list::<Response>(&raw), reqs);
 	}
+
+	#[test]
+	fn epoch_signal_roundtrip() {
+		let req = IncompleteSignalRequest {
+			block_hash: Field::Scalar(Default::default()),
+		};
+
+		let full_req = Request::Signal(req.clone());
+		let res = SignalResponse {
+			signal: vec![1, 2, 3, 4, 5, 6, 7, 6, 5, 4],
+		};
+		let full_res = Response::Signal(res.clone());
+
+		check_roundtrip(req);
+		check_roundtrip(full_req);
+		check_roundtrip(res);
+		check_roundtrip(full_res);
+	}
 }

ethcore/src/blockchain/blockchain.rs

@@ -44,6 +44,7 @@ use db::{self, Writable, Readable, CacheUpdatePolicy};
 use cache_manager::CacheManager;
 use encoded;
 use engines::epoch::{Transition as EpochTransition, PendingTransition as PendingEpochTransition};
+use rayon::prelude::*;
 use ansi_term::Colour;
 
 const LOG_BLOOMS_LEVELS: usize = 3;
@@ -152,7 +153,7 @@ pub trait BlockProvider {
 
 	/// Returns logs matching given filter.
 	fn logs<F>(&self, blocks: Vec<BlockNumber>, matches: F, limit: Option<usize>) -> Vec<LocalizedLogEntry>
-		where F: Fn(&LogEntry) -> bool, Self: Sized;
+		where F: Fn(&LogEntry) -> bool + Send + Sync, Self: Sized;
 }
 
 macro_rules! otry {
@@ -363,50 +364,56 @@ impl BlockProvider for BlockChain {
 	}
 
 	fn logs<F>(&self, mut blocks: Vec<BlockNumber>, matches: F, limit: Option<usize>) -> Vec<LocalizedLogEntry>
-		where F: Fn(&LogEntry) -> bool, Self: Sized {
+		where F: Fn(&LogEntry) -> bool + Send + Sync, Self: Sized {
 		// sort in reverse order
 		blocks.sort_by(|a, b| b.cmp(a));
 
-		let mut log_index = 0;
-		let mut logs = blocks.into_iter()
-			.filter_map(|number| self.block_hash(number).map(|hash| (number, hash)))
-			.filter_map(|(number, hash)| self.block_receipts(&hash).map(|r| (number, hash, r.receipts)))
-			.filter_map(|(number, hash, receipts)| self.block_body(&hash).map(|ref b| (number, hash, receipts, b.transaction_hashes())))
-			.flat_map(|(number, hash, mut receipts, mut hashes)| {
-				if receipts.len() != hashes.len() {
-					warn!("Block {} ({}) has different number of receipts ({}) to transactions ({}). Database corrupt?", number, hash, receipts.len(), hashes.len());
-					assert!(false);
-				}
-				log_index = receipts.iter().fold(0, |sum, receipt| sum + receipt.logs.len());
+		let mut logs = blocks
+			.chunks(128)
+			.flat_map(move |blocks_chunk| {
+				blocks_chunk.into_par_iter()
+					.filter_map(|number| self.block_hash(*number).map(|hash| (*number, hash)))
+					.filter_map(|(number, hash)| self.block_receipts(&hash).map(|r| (number, hash, r.receipts)))
+					.filter_map(|(number, hash, receipts)| self.block_body(&hash).map(|ref b| (number, hash, receipts, b.transaction_hashes())))
+					.flat_map(|(number, hash, mut receipts, mut hashes)| {
+						if receipts.len() != hashes.len() {
+							warn!("Block {} ({}) has different number of receipts ({}) to transactions ({}). Database corrupt?", number, hash, receipts.len(), hashes.len());
+							assert!(false);
+						}
+						let mut log_index = receipts.iter().fold(0, |sum, receipt| sum + receipt.logs.len());
 
-				let receipts_len = receipts.len();
-				hashes.reverse();
-				receipts.reverse();
-				receipts.into_iter()
-					.map(|receipt| receipt.logs)
-					.zip(hashes)
-					.enumerate()
-					.flat_map(move |(index, (mut logs, tx_hash))| {
-						let current_log_index = log_index;
-						let no_of_logs = logs.len();
-						log_index -= no_of_logs;
-
-						logs.reverse();
-						logs.into_iter()
+						let receipts_len = receipts.len();
+						hashes.reverse();
+						receipts.reverse();
+						receipts.into_iter()
+							.map(|receipt| receipt.logs)
+							.zip(hashes)
 							.enumerate()
-							.map(move |(i, log)| LocalizedLogEntry {
-								entry: log,
-								block_hash: hash,
-								block_number: number,
-								transaction_hash: tx_hash,
-								// iterating in reverse order
-								transaction_index: receipts_len - index - 1,
-								transaction_log_index: no_of_logs - i - 1,
-								log_index: current_log_index - i - 1,
+							.flat_map(move |(index, (mut logs, tx_hash))| {
+								let current_log_index = log_index;
+								let no_of_logs = logs.len();
+								log_index -= no_of_logs;
+
+								logs.reverse();
+								logs.into_iter()
+									.enumerate()
+									.map(move |(i, log)| LocalizedLogEntry {
+										entry: log,
+										block_hash: hash,
+										block_number: number,
+										transaction_hash: tx_hash,
+										// iterating in reverse order
+										transaction_index: receipts_len - index - 1,
+										transaction_log_index: no_of_logs - i - 1,
+										log_index: current_log_index - i - 1,
+									})
 							})
+							.filter(|log_entry| matches(&log_entry.entry))
+							.take(limit.unwrap_or(::std::usize::MAX))
+							.collect::<Vec<_>>()
 					})
+					.collect::<Vec<_>>()
 			})
-			.filter(|log_entry| matches(&log_entry.entry))
 			.take(limit.unwrap_or(::std::usize::MAX))
 			.collect::<Vec<LocalizedLogEntry>>();
 		logs.reverse();

ethcore/src/client/client.rs

@@ -34,7 +34,7 @@ use util::kvdb::*;
 
 // other
 use bigint::prelude::U256;
-use bigint::hash::{H256, H2048};
+use bigint::hash::H256;
 use basic_types::Seal;
 use block::*;
 use blockchain::{BlockChain, BlockProvider,  TreeRoute, ImportRoute};
@@ -43,7 +43,7 @@ use client::ancient_import::AncientVerifier;
 use client::Error as ClientError;
 use client::{
 	BlockId, TransactionId, UncleId, TraceId, ClientConfig, BlockChainClient,
-	MiningBlockChainClient, EngineClient, TraceFilter, CallAnalytics, BlockImportError, Mode,
+	MiningBlockChainClient, TraceFilter, CallAnalytics, BlockImportError, Mode,
 	ChainNotify, PruningInfo, ProvingBlockChainClient,
 };
 use encoded;
@@ -771,7 +771,7 @@ impl Client {
 							res.map(|(output, proof)| (output, proof.into_iter().map(|x| x.into_vec()).collect()))
 						};
 
-						match (with_state)(&call) {
+						match with_state.generate_proof(&call) {
 							Ok(proof) => proof,
 							Err(e) => {
 								warn!(target: "client", "Failed to generate transition proof for block {}: {}", hash, e);
@@ -918,7 +918,7 @@ impl Client {
 			_ => {},
 		}
 
-		let block_number = match self.block_number(id.clone()) {
+		let block_number = match self.block_number(id) {
 			Some(num) => num,
 			None => return None,
 		};
@@ -1155,6 +1155,16 @@ impl Client {
 			(false, false) => call(state, env_info, engine, state_diff, t, TransactOptions::with_no_tracing()),
 		}
 	}
+
+	fn block_number_ref(&self, id: &BlockId) -> Option<BlockNumber> {
+		match *id {
+			BlockId::Number(number) => Some(number),
+			BlockId::Hash(ref hash) => self.chain.read().block_number(hash),
+			BlockId::Earliest => Some(0),
+			BlockId::Latest => Some(self.chain.read().best_block_number()),
+			BlockId::Pending => Some(self.chain.read().best_block_number() + 1),
+		}
+	}
 }
 
 impl snapshot::DatabaseRestore for Client {
@@ -1364,13 +1374,7 @@ impl BlockChainClient for Client {
 	}
 
 	fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
-		match id {
-			BlockId::Number(number) => Some(number),
-			BlockId::Hash(ref hash) => self.chain.read().block_number(hash),
-			BlockId::Earliest => Some(0),
-			BlockId::Latest => Some(self.chain.read().best_block_number()),
-			BlockId::Pending => Some(self.chain.read().best_block_number() + 1),
-		}
+		self.block_number_ref(&id)
 	}
 
 	fn block_body(&self, id: BlockId) -> Option<encoded::Body> {
@@ -1651,16 +1655,17 @@ impl BlockChainClient for Client {
 		self.engine.additional_params().into_iter().collect()
 	}
 
-	fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockId, to_block: BlockId) -> Option<Vec<BlockNumber>> {
-		match (self.block_number(from_block), self.block_number(to_block)) {
-			(Some(from), Some(to)) => Some(self.chain.read().blocks_with_bloom(bloom, from, to)),
-			_ => None
-		}
-	}
-
 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry> {
+		let (from, to) = match (self.block_number_ref(&filter.from_block), self.block_number_ref(&filter.to_block)) {
+			(Some(from), Some(to)) => (from, to),
+			_ => return Vec::new(),
+		};
+
+		let chain = self.chain.read();
 		let blocks = filter.bloom_possibilities().iter()
-			.filter_map(|bloom| self.blocks_with_bloom(bloom, filter.from_block.clone(), filter.to_block.clone()))
+			.map(move |bloom| {
+				chain.blocks_with_bloom(bloom, from, to)
+			})
 			.flat_map(|m| m)
 			// remove duplicate elements
 			.collect::<HashSet<u64>>()
@@ -1937,7 +1942,7 @@ impl MiningBlockChainClient for Client {
 	}
 }
 
-impl EngineClient for Client {
+impl super::traits::EngineClient for Client {
 	fn update_sealing(&self) {
 		self.miner.update_sealing(self)
 	}
@@ -1955,6 +1960,16 @@ impl EngineClient for Client {
 	fn epoch_transition_for(&self, parent_hash: H256) -> Option<::engines::EpochTransition> {
 		self.chain.read().epoch_transition_for(parent_hash)
 	}
+
+	fn chain_info(&self) -> BlockChainInfo {
+		BlockChainClient::chain_info(self)
+	}
+
+	fn as_full_client(&self) -> Option<&BlockChainClient> { Some(self) }
+
+	fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
+		BlockChainClient::block_number(self, id)
+	}
 }
 
 impl ProvingBlockChainClient for Client {
@@ -1969,27 +1984,30 @@ impl ProvingBlockChainClient for Client {
 	}
 
 	fn prove_transaction(&self, transaction: SignedTransaction, id: BlockId) -> Option<(Bytes, Vec<DBValue>)> {
-		let (state, mut env_info) = match (self.state_at(id), self.env_info(id)) {
+		let (header, mut env_info) = match (self.block_header(id), self.env_info(id)) {
 			(Some(s), Some(e)) => (s, e),
 			_ => return None,
 		};
 
 		env_info.gas_limit = transaction.gas.clone();
 		let mut jdb = self.state_db.lock().journal_db().boxed_clone();
-		let backend = state::backend::Proving::new(jdb.as_hashdb_mut());
 
-		let mut state = state.replace_backend(backend);
-		let options = TransactOptions::with_no_tracing().dont_check_nonce();
-		let res = Executive::new(&mut state, &env_info, &*self.engine).transact(&transaction, options);
+		state::prove_transaction(
+			jdb.as_hashdb_mut(),
+			header.state_root().clone(),
+			&transaction,
+			&*self.engine,
+			&env_info,
+			self.factories.clone(),
+			false,
+		)
+	}
 
-		match res {
-			Err(ExecutionError::Internal(_)) => None,
-			Err(e) => {
-				trace!(target: "client", "Proved call failed: {}", e);
-				Some((Vec::new(), state.drop().1.extract_proof()))
-			}
-			Ok(res) => Some((res.output, state.drop().1.extract_proof())),
-		}
+
+	fn epoch_signal(&self, hash: H256) -> Option<Vec<u8>> {
+		// pending transitions are never deleted, and do not contain
+		// finality proofs by definition.
+		self.chain.read().get_pending_transition(hash).map(|pending| pending.proof)
 	}
 }
 

ethcore/src/client/test_client.rs

@@ -24,7 +24,7 @@ use itertools::Itertools;
 use rustc_hex::FromHex;
 use hash::keccak;
 use bigint::prelude::U256;
-use bigint::hash::{H256, H2048};
+use bigint::hash::H256;
 use parking_lot::RwLock;
 use util::*;
 use rlp::*;
@@ -33,7 +33,7 @@ use devtools::*;
 use transaction::{Transaction, LocalizedTransaction, PendingTransaction, SignedTransaction, Action};
 use blockchain::TreeRoute;
 use client::{
-	BlockChainClient, MiningBlockChainClient, EngineClient, BlockChainInfo, BlockStatus, BlockId,
+	BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockId,
 	TransactionId, UncleId, TraceId, TraceFilter, LastHashes, CallAnalytics, BlockImportError,
 	ProvingBlockChainClient,
 };
@@ -508,10 +508,6 @@ impl BlockChainClient for TestBlockChainClient {
 		self.receipts.read().get(&id).cloned()
 	}
 
-	fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockId, _to_block: BlockId) -> Option<Vec<BlockNumber>> {
-		unimplemented!();
-	}
-
 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry> {
 		let mut logs = self.logs.read().clone();
 		let len = logs.len();
@@ -801,9 +797,13 @@ impl ProvingBlockChainClient for TestBlockChainClient {
 	fn prove_transaction(&self, _: SignedTransaction, _: BlockId) -> Option<(Bytes, Vec<DBValue>)> {
 		None
 	}
+
+	fn epoch_signal(&self, _: H256) -> Option<Vec<u8>> {
+		None
+	}
 }
 
-impl EngineClient for TestBlockChainClient {
+impl super::traits::EngineClient for TestBlockChainClient {
 	fn update_sealing(&self) {
 		self.miner.update_sealing(self)
 	}
@@ -819,4 +819,14 @@ impl EngineClient for TestBlockChainClient {
 	fn epoch_transition_for(&self, _block_hash: H256) -> Option<::engines::EpochTransition> {
 		None
 	}
+
+	fn chain_info(&self) -> BlockChainInfo {
+		BlockChainClient::chain_info(self)
+	}
+
+	fn as_full_client(&self) -> Option<&BlockChainClient> { Some(self) }
+
+	fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
+		BlockChainClient::block_number(self, id)
+	}
 }

ethcore/src/client/traits.rs

@@ -35,7 +35,7 @@ use transaction::{LocalizedTransaction, PendingTransaction, SignedTransaction};
 use verification::queue::QueueInfo as BlockQueueInfo;
 
 use bigint::prelude::U256;
-use bigint::hash::{H256, H2048};
+use bigint::hash::H256;
 use util::{Address, Bytes};
 use util::hashdb::DBValue;
 
@@ -181,9 +181,6 @@ pub trait BlockChainClient : Sync + Send {
 	/// Get the best block header.
 	fn best_block_header(&self) -> encoded::Header;
 
-	/// Returns numbers of blocks containing given bloom.
-	fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockId, to_block: BlockId) -> Option<Vec<BlockNumber>>;
-
 	/// Returns logs matching given filter.
 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry>;
 
@@ -317,7 +314,7 @@ pub trait MiningBlockChainClient: BlockChainClient {
 }
 
 /// Client facilities used by internally sealing Engines.
-pub trait EngineClient: MiningBlockChainClient {
+pub trait EngineClient: Sync + Send {
 	/// Make a new block and seal it.
 	fn update_sealing(&self);
 
@@ -333,6 +330,15 @@ pub trait EngineClient: MiningBlockChainClient {
 	///
 	/// The block corresponding the the parent hash must be stored already.
 	fn epoch_transition_for(&self, parent_hash: H256) -> Option<::engines::EpochTransition>;
+
+	/// Get block chain info.
+	fn chain_info(&self) -> BlockChainInfo;
+
+	/// Attempt to cast the engine client to a full client.
+	fn as_full_client(&self) -> Option<&BlockChainClient>;
+
+	/// Get a block number by ID.
+	fn block_number(&self, id: BlockId) -> Option<BlockNumber>;
 }
 
 /// Extended client interface for providing proofs of the state.
@@ -352,4 +358,7 @@ pub trait ProvingBlockChainClient: BlockChainClient {
 	/// Returns the output of the call and a vector of database items necessary
 	/// to reproduce it.
 	fn prove_transaction(&self, transaction: SignedTransaction, id: BlockId) -> Option<(Bytes, Vec<DBValue>)>;
+
+	/// Get an epoch change signal by block hash.
+	fn epoch_signal(&self, hash: H256) -> Option<Vec<u8>>;
 }

ethcore/src/engines/authority_round/mod.rs

@@ -25,7 +25,7 @@ use std::cmp;
 use account_provider::AccountProvider;
 use block::*;
 use builtin::Builtin;
-use client::{Client, EngineClient};
+use client::EngineClient;
 use engines::{Call, Engine, Seal, EngineError, ConstructedVerifier};
 use error::{Error, TransactionError, BlockError};
 use ethjson;
@@ -647,6 +647,8 @@ impl Engine for AuthorityRound {
 			(&active_set as &_, epoch_manager.epoch_transition_number)
 		};
 
+		// always report with "self.validators" so that the report actually gets
+		// to the contract.
 		let report = |report| match report {
 			Report::Benign(address, block_number) =>
 				self.validators.report_benign(&address, set_number, block_number),
@@ -739,13 +741,18 @@ impl Engine for AuthorityRound {
 		{
 			if let Ok(finalized) = epoch_manager.finality_checker.push_hash(chain_head.hash(), *chain_head.author()) {
 				let mut finalized = finalized.into_iter();
-				while let Some(hash) = finalized.next() {
-					if let Some(pending) = transition_store(hash) {
-						let finality_proof = ::std::iter::once(hash)
+				while let Some(finalized_hash) = finalized.next() {
+					if let Some(pending) = transition_store(finalized_hash) {
+						let finality_proof = ::std::iter::once(finalized_hash)
 							.chain(finalized)
 							.chain(epoch_manager.finality_checker.unfinalized_hashes())
-							.map(|hash| chain(hash)
-								.expect("these headers fetched before when constructing finality checker; qed"))
+							.map(|h| if h == chain_head.hash() {
+								// chain closure only stores ancestry, but the chain head is also
+								// unfinalized.
+								chain_head.clone()
+							} else {
+								chain(h).expect("these headers fetched before when constructing finality checker; qed")
+							})
 							.collect::<Vec<Header>>();
 
 						// this gives us the block number for `hash`, assuming it's ancestry.
@@ -809,9 +816,9 @@ impl Engine for AuthorityRound {
 		Ok(())
 	}
 
-	fn register_client(&self, client: Weak<Client>) {
+	fn register_client(&self, client: Weak<EngineClient>) {
 		*self.client.write() = Some(client.clone());
-		self.validators.register_contract(client);
+		self.validators.register_client(client);
 	}
 
 	fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: String) {

ethcore/src/engines/basic_authority.rs

@@ -34,7 +34,7 @@ use error::{BlockError, Error};
 use evm::Schedule;
 use ethjson;
 use header::{Header, BlockNumber};
-use client::Client;
+use client::EngineClient;
 use semantic_version::SemanticVersion;
 use super::signer::EngineSigner;
 use super::validator_set::{ValidatorSet, SimpleList, new_validator_set};
@@ -237,8 +237,8 @@ impl Engine for BasicAuthority {
 		}
 	}
 
-	fn register_client(&self, client: Weak<Client>) {
-		self.validators.register_contract(client);
+	fn register_client(&self, client: Weak<EngineClient>) {
+		self.validators.register_client(client);
 	}
 
 	fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: String) {

ethcore/src/engines/mod.rs

@@ -44,7 +44,7 @@ use self::epoch::PendingTransition;
 use account_provider::AccountProvider;
 use block::ExecutedBlock;
 use builtin::Builtin;
-use client::Client;
+use client::EngineClient;
 use vm::{EnvInfo, LastHashes, Schedule, CreateContractAddress};
 use error::Error;
 use header::{Header, BlockNumber};
@@ -124,12 +124,22 @@ pub type Headers<'a> = Fn(H256) -> Option<Header> + 'a;
 /// Type alias for a function we can query pending transitions by block hash through.
 pub type PendingTransitionStore<'a> = Fn(H256) -> Option<PendingTransition> + 'a;
 
+/// Proof dependent on state.
+pub trait StateDependentProof: Send + Sync {
+	/// Generate a proof, given the state.
+	fn generate_proof(&self, caller: &Call) -> Result<Vec<u8>, String>;
+	/// Check a proof generated elsewhere (potentially by a peer).
+	// `engine` needed to check state proofs, while really this should
+	// just be state machine params.
+	fn check_proof(&self, engine: &Engine, proof: &[u8]) -> Result<(), String>;
+}
+
 /// Proof generated on epoch change.
 pub enum Proof {
-	/// Known proof (exctracted from signal)
+	/// Known proof (extracted from signal)
 	Known(Vec<u8>),
-	/// Extract proof from caller.
-	WithState(Box<Fn(&Call) -> Result<Vec<u8>, String>>),
+	/// State dependent proof.
+	WithState(Arc<StateDependentProof>),
 }
 
 /// Generated epoch verifier.
@@ -361,7 +371,7 @@ pub trait Engine : Sync + Send {
 	fn sign(&self, _hash: H256) -> Result<Signature, Error> { unimplemented!() }
 
 	/// Add Client which can be used for sealing, querying the state and sending messages.
-	fn register_client(&self, _client: Weak<Client>) {}
+	fn register_client(&self, _client: Weak<EngineClient>) {}
 
 	/// Trigger next step of the consensus engine.
 	fn step(&self) {}

ethcore/src/engines/tendermint/mod.rs

@@ -35,7 +35,7 @@ use bigint::hash::{H256, H520};
 use parking_lot::RwLock;
 use util::*;
 use unexpected::{OutOfBounds, Mismatch};
-use client::{Client, EngineClient};
+use client::EngineClient;
 use error::{Error, BlockError};
 use header::{Header, BlockNumber};
 use builtin::Builtin;
@@ -571,18 +571,35 @@ impl Engine for Tendermint {
 		Ok(())
 	}
 
-	/// Verify validators and gas limit.
+	/// Verify gas limit.
 	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		if header.number() == 0 {
 			return Err(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() }).into());
 		}
 
+		let gas_limit_divisor = self.params().gas_limit_bound_divisor;
+		let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor;
+		let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor;
+		if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas {
+			self.validators.report_malicious(header.author(), header.number(), header.number(), Default::default());
+			return Err(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit().clone() }).into());
+		}
+
+		Ok(())
+	}
+
+	fn verify_block_external(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		if let Ok(proposal) = ConsensusMessage::new_proposal(header) {
 			let proposer = proposal.verify()?;
 			if !self.is_authority(&proposer) {
 				return Err(EngineError::NotAuthorized(proposer).into());
 			}
-			self.check_view_proposer(header.parent_hash(), proposal.vote_step.height, proposal.vote_step.view, &proposer)?;
+			self.check_view_proposer(
+				header.parent_hash(),
+				proposal.vote_step.height,
+				proposal.vote_step.view,
+				&proposer
+			).map_err(Into::into)
 		} else {
 			let vote_step = VoteStep::new(header.number() as usize, consensus_view(header)?, Step::Precommit);
 			let precommit_hash = message_hash(vote_step.clone(), header.bare_hash());
@@ -608,18 +625,8 @@ impl Engine for Tendermint {
 				}
 			}
 
-			self.check_above_threshold(origins.len())?
+			self.check_above_threshold(origins.len()).map_err(Into::into)
 		}
-
-		let gas_limit_divisor = self.params().gas_limit_bound_divisor;
-		let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor;
-		let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor;
-		if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas {
-			self.validators.report_malicious(header.author(), header.number(), header.number(), Default::default());
-			return Err(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit().clone() }).into());
-		}
-
-		Ok(())
 	}
 
 	fn signals_epoch_end(&self, header: &Header, block: Option<&[u8]>, receipts: Option<&[::receipt::Receipt]>)
@@ -754,13 +761,12 @@ impl Engine for Tendermint {
 		self.to_step(next_step);
 	}
 
-	fn register_client(&self, client: Weak<Client>) {
-		use client::BlockChainClient;
+	fn register_client(&self, client: Weak<EngineClient>) {
 		if let Some(c) = client.upgrade() {
 			self.height.store(c.chain_info().best_block_number as usize + 1, AtomicOrdering::SeqCst);
 		}
 		*self.client.write() = Some(client.clone());
-		self.validators.register_contract(client);
+		self.validators.register_client(client);
 	}
 }
 
@@ -888,14 +894,14 @@ mod tests {
 		let seal = proposal_seal(&tap, &header, 0);
 		header.set_seal(seal);
 		// Good proposer.
-		assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());
+		assert!(engine.verify_block_external(&header, None).is_ok());
 
 		let validator = insert_and_unlock(&tap, "0");
 		header.set_author(validator);
 		let seal = proposal_seal(&tap, &header, 0);
 		header.set_seal(seal);
 		// Bad proposer.
-		match engine.verify_block_family(&header, &parent_header, None) {
+		match engine.verify_block_external(&header, None) {
 			Err(Error::Engine(EngineError::NotProposer(_))) => {},
 			_ => panic!(),
 		}
@@ -905,7 +911,7 @@ mod tests {
 		let seal = proposal_seal(&tap, &header, 0);
 		header.set_seal(seal);
 		// Not authority.
-		match engine.verify_block_family(&header, &parent_header, None) {
+		match engine.verify_block_external(&header, None) {
 			Err(Error::Engine(EngineError::NotAuthorized(_))) => {},
 			_ => panic!(),
 		};
@@ -935,7 +941,7 @@ mod tests {
 		header.set_seal(seal.clone());
 
 		// One good signature is not enough.
-		match engine.verify_block_family(&header, &parent_header, None) {
+		match engine.verify_block_external(&header, None) {
 			Err(Error::Engine(EngineError::BadSealFieldSize(_))) => {},
 			_ => panic!(),
 		}
@@ -946,7 +952,7 @@ mod tests {
 		seal[2] = ::rlp::encode_list(&vec![H520::from(signature1.clone()), H520::from(signature0.clone())]).into_vec();
 		header.set_seal(seal.clone());
 
-		assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());
+		assert!(engine.verify_block_external(&header, None).is_ok());
 
 		let bad_voter = insert_and_unlock(&tap, "101");
 		let bad_signature = tap.sign(bad_voter, None, keccak(vote_info)).unwrap();
@@ -955,7 +961,7 @@ mod tests {
 		header.set_seal(seal);
 
 		// One good and one bad signature.
-		match engine.verify_block_family(&header, &parent_header, None) {
+		match engine.verify_block_external(&header, None) {
 			Err(Error::Engine(EngineError::NotAuthorized(_))) => {},
 			_ => panic!(),
 		};
@@ -1001,7 +1007,7 @@ mod tests {
 		let client = generate_dummy_client(0);
 		let notify = Arc::new(TestNotify::default());
 		client.add_notify(notify.clone());
-		engine.register_client(Arc::downgrade(&client));
+		engine.register_client(Arc::downgrade(&client) as _);
 
 		let prevote_current = vote(engine.as_ref(), |mh| tap.sign(v0, None, mh).map(H520::from), h, r, Step::Prevote, proposal);
 
@@ -1019,7 +1025,6 @@ mod tests {
 	fn seal_submission() {
 		use ethkey::{Generator, Random};
 		use transaction::{Transaction, Action};
-		use client::BlockChainClient;
 
 		let tap = Arc::new(AccountProvider::transient_provider());
 		// Accounts for signing votes.
@@ -1032,7 +1037,7 @@ mod tests {
 
 		let notify = Arc::new(TestNotify::default());
 		client.add_notify(notify.clone());
-		engine.register_client(Arc::downgrade(&client));
+		engine.register_client(Arc::downgrade(&client) as _);
 
 		let keypair = Random.generate().unwrap();
 		let transaction = Transaction {

ethcore/src/engines/validator_set/contract.rs

@@ -25,7 +25,7 @@ use util::*;
 use futures::Future;
 use native_contracts::ValidatorReport as Provider;
 
-use client::{Client, BlockChainClient};
+use client::EngineClient;
 use engines::{Call, Engine};
 use header::{Header, BlockNumber};
 
@@ -36,7 +36,7 @@ use super::safe_contract::ValidatorSafeContract;
 pub struct ValidatorContract {
 	validators: ValidatorSafeContract,
 	provider: Provider,
-	client: RwLock<Option<Weak<Client>>>, // TODO [keorn]: remove
+	client: RwLock<Option<Weak<EngineClient>>>, // TODO [keorn]: remove
 }
 
 impl ValidatorContract {
@@ -58,7 +58,13 @@ impl ValidatorContract {
 		Box::new(move |a, d| client.as_ref()
 			.and_then(Weak::upgrade)
 			.ok_or("No client!".into())
-			.and_then(|c| c.transact_contract(a, d).map_err(|e| format!("Transaction import error: {}", e)))
+			.and_then(|c| {
+				match c.as_full_client() {
+					Some(c) => c.transact_contract(a, d)
+						.map_err(|e| format!("Transaction import error: {}", e)),
+					None => Err("No full client!".into()),
+				}
+			})
 			.map(|_| Default::default()))
 	}
 }
@@ -120,8 +126,8 @@ impl ValidatorSet for ValidatorContract {
 		}
 	}
 
-	fn register_contract(&self, client: Weak<Client>) {
-		self.validators.register_contract(client.clone());
+	fn register_client(&self, client: Weak<EngineClient>) {
+		self.validators.register_client(client.clone());
 		*self.client.write() = Some(client);
 	}
 }
@@ -148,7 +154,7 @@ mod tests {
 	fn fetches_validators() {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, None);
 		let vc = Arc::new(ValidatorContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
-		vc.register_contract(Arc::downgrade(&client));
+		vc.register_client(Arc::downgrade(&client) as _);
 		let last_hash = client.best_block_header().hash();
 		assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
 		assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
@@ -159,7 +165,7 @@ mod tests {
 		let tap = Arc::new(AccountProvider::transient_provider());
 		let v1 = tap.insert_account(keccak("1").into(), "").unwrap();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, Some(tap.clone()));
-		client.engine().register_client(Arc::downgrade(&client));
+		client.engine().register_client(Arc::downgrade(&client) as _);
 		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 
 		// Make sure reporting can be done.

ethcore/src/engines/validator_set/mod.rs

@@ -28,7 +28,7 @@ use ids::BlockId;
 use bigint::hash::H256;
 use util::{Bytes, Address};
 use ethjson::spec::ValidatorSet as ValidatorSpec;
-use client::Client;
+use client::EngineClient;
 use header::{Header, BlockNumber};
 
 #[cfg(test)]
@@ -142,5 +142,5 @@ pub trait ValidatorSet: Send + Sync {
 	/// Notifies about benign misbehaviour.
 	fn report_benign(&self, _validator: &Address, _set_block: BlockNumber, _block: BlockNumber) {}
 	/// Allows blockchain state access.
-	fn register_contract(&self, _client: Weak<Client>) {}
+	fn register_client(&self, _client: Weak<EngineClient>) {}
 }

ethcore/src/engines/validator_set/multi.rs

@@ -24,7 +24,7 @@ use parking_lot::RwLock;
 use util::{Bytes, Address};
 use ids::BlockId;
 use header::{BlockNumber, Header};
-use client::{Client, BlockChainClient};
+use client::EngineClient;
 use super::{SystemCall, ValidatorSet};
 
 type BlockNumberLookup = Box<Fn(BlockId) -> Result<BlockNumber, String> + Send + Sync + 'static>;
@@ -131,9 +131,9 @@ impl ValidatorSet for Multi {
 		self.correct_set_by_number(set_block).1.report_benign(validator, set_block, block);
 	}
 
-	fn register_contract(&self, client: Weak<Client>) {
+	fn register_client(&self, client: Weak<EngineClient>) {
 		for set in self.sets.values() {
-			set.register_contract(client.clone());
+			set.register_client(client.clone());
 		}
 		*self.block_number.write() = Box::new(move |id| client
 			.upgrade()
@@ -148,7 +148,7 @@ mod tests {
 	use std::collections::BTreeMap;
 	use hash::keccak;
 	use account_provider::AccountProvider;
-	use client::{BlockChainClient, EngineClient};
+	use client::BlockChainClient;
 	use engines::EpochChange;
 	use engines::validator_set::ValidatorSet;
 	use ethkey::Secret;
@@ -170,7 +170,7 @@ mod tests {
 		let v0 = tap.insert_account(s0.clone(), "").unwrap();
 		let v1 = tap.insert_account(keccak("1").into(), "").unwrap();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_multi, Some(tap));
-		client.engine().register_client(Arc::downgrade(&client));
+		client.engine().register_client(Arc::downgrade(&client) as _);
 
 		// Make sure txs go through.
 		client.miner().set_gas_floor_target(1_000_000.into());
@@ -178,27 +178,27 @@ mod tests {
 		// Wrong signer for the first block.
 		client.miner().set_engine_signer(v1, "".into()).unwrap();
 		client.transact_contract(Default::default(), Default::default()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 0);
 		// Right signer for the first block.
 		client.miner().set_engine_signer(v0, "".into()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 1);
 		// This time v0 is wrong.
 		client.transact_contract(Default::default(), Default::default()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 1);
 		client.miner().set_engine_signer(v1, "".into()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 2);
 		// v1 is still good.
 		client.transact_contract(Default::default(), Default::default()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 3);
 
 		// Check syncing.
 		let sync_client = generate_dummy_client_with_spec_and_data(Spec::new_validator_multi, 0, 0, &[]);
-		sync_client.engine().register_client(Arc::downgrade(&sync_client));
+		sync_client.engine().register_client(Arc::downgrade(&sync_client) as _);
 		for i in 1..4 {
 			sync_client.import_block(client.block(BlockId::Number(i)).unwrap().into_inner()).unwrap();
 		}

ethcore/src/engines/validator_set/safe_contract.rs

@@ -23,14 +23,15 @@ use hash::keccak;
 
 use bigint::prelude::U256;
 use bigint::hash::{H160, H256};
-use parking_lot::RwLock;
+use parking_lot::{Mutex, RwLock};
+
 use util::*;
 use util::cache::MemoryLruCache;
 use unexpected::Mismatch;
 use rlp::{UntrustedRlp, RlpStream};
 
 use basic_types::LogBloom;
-use client::{Client, BlockChainClient};
+use client::EngineClient;
 use engines::{Call, Engine};
 use header::Header;
 use ids::BlockId;
@@ -49,12 +50,35 @@ lazy_static! {
 	static ref EVENT_NAME_HASH: H256 = keccak(EVENT_NAME);
 }
 
+// state-dependent proofs for the safe contract:
+// only "first" proofs are such.
+struct StateProof {
+	header: Mutex<Header>,
+	provider: Provider,
+}
+
+impl ::engines::StateDependentProof for StateProof {
+	fn generate_proof(&self, caller: &Call) -> Result<Vec<u8>, String> {
+		prove_initial(&self.provider, &*self.header.lock(), caller)
+	}
+
+	fn check_proof(&self, engine: &Engine, proof: &[u8]) -> Result<(), String> {
+		let (header, state_items) = decode_first_proof(&UntrustedRlp::new(proof))
+			.map_err(|e| format!("proof incorrectly encoded: {}", e))?;
+		if &header != &*self.header.lock(){
+			return Err("wrong header in proof".into());
+		}
+
+		check_first_proof(engine, &self.provider, header, &state_items).map(|_| ())
+	}
+}
+
 /// The validator contract should have the following interface:
 pub struct ValidatorSafeContract {
 	pub address: Address,
 	validators: RwLock<MemoryLruCache<H256, SimpleList>>,
 	provider: Provider,
-	client: RwLock<Option<Weak<Client>>>, // TODO [keorn]: remove
+	client: RwLock<Option<Weak<EngineClient>>>, // TODO [keorn]: remove
 }
 
 // first proof is just a state proof call of `getValidators` at header's state.
@@ -68,6 +92,59 @@ fn encode_first_proof(header: &Header, state_items: &[Vec<u8>]) -> Bytes {
 	stream.out()
 }
 
+// check a first proof: fetch the validator set at the given block.
+fn check_first_proof(engine: &Engine, provider: &Provider, old_header: Header, state_items: &[DBValue])
+	-> Result<Vec<Address>, String>
+{
+	use transaction::{Action, Transaction};
+
+	// TODO: match client contract_call_tx more cleanly without duplication.
+	const PROVIDED_GAS: u64 = 50_000_000;
+
+	let env_info = ::vm::EnvInfo {
+		number: old_header.number(),
+		author: *old_header.author(),
+		difficulty: *old_header.difficulty(),
+		gas_limit: PROVIDED_GAS.into(),
+		timestamp: old_header.timestamp(),
+		last_hashes: {
+			// this will break if we don't inclue all 256 last hashes.
+			let mut last_hashes: Vec<_> = (0..256).map(|_| H256::default()).collect();
+			last_hashes[255] = *old_header.parent_hash();
+			Arc::new(last_hashes)
+		},
+		gas_used: 0.into(),
+	};
+
+	// check state proof using given engine.
+	let number = old_header.number();
+	provider.get_validators(move |a, d| {
+		let from = Address::default();
+		let tx = Transaction {
+			nonce: engine.account_start_nonce(number),
+			action: Action::Call(a),
+			gas: PROVIDED_GAS.into(),
+			gas_price: U256::default(),
+			value: U256::default(),
+			data: d,
+		}.fake_sign(from);
+
+		let res = ::state::check_proof(
+			state_items,
+			*old_header.state_root(),
+			&tx,
+			engine,
+			&env_info,
+		);
+
+		match res {
+			::state::ProvedExecution::BadProof => Err("Bad proof".into()),
+			::state::ProvedExecution::Failed(e) => Err(format!("Failed call: {}", e)),
+			::state::ProvedExecution::Complete(e) => Ok(e.output),
+		}
+	}).wait()
+}
+
 fn decode_first_proof(rlp: &UntrustedRlp) -> Result<(Header, Vec<DBValue>), ::error::Error> {
 	let header = rlp.val_at(0)?;
 	let state_items = rlp.at(1)?.iter().map(|x| {
@@ -105,8 +182,7 @@ fn prove_initial(provider: &Provider, header: &Header, caller: &Call) -> Result<
 			Ok(result)
 		};
 
-		provider.get_validators(caller)
-			.wait()
+		provider.get_validators(caller).wait()
 	};
 
 	res.map(|validators| {
@@ -235,7 +311,12 @@ impl ValidatorSet for ValidatorSafeContract {
 		Box::new(move |addr, data| client.as_ref()
 			.and_then(Weak::upgrade)
 			.ok_or("No client!".into())
-			.and_then(|c| c.call_contract(id, addr, data))
+			.and_then(|c| {
+				match c.as_full_client() {
+					Some(c) => c.call_contract(id, addr, data),
+					None => Err("No full client!".into()),
+				}
+			})
 			.map(|out| (out, Vec::new()))) // generate no proofs in general
 	}
 
@@ -260,9 +341,11 @@ impl ValidatorSet for ValidatorSafeContract {
 		// transition to the first block of a contract requires finality but has no log event.
 		if first {
 			debug!(target: "engine", "signalling transition to fresh contract.");
-			let (provider, header) = (self.provider.clone(), header.clone());
-			let with_caller: Box<Fn(&Call) -> _> = Box::new(move |caller| prove_initial(&provider, &header, caller));
-			return ::engines::EpochChange::Yes(::engines::Proof::WithState(with_caller))
+			let state_proof = Arc::new(StateProof {
+				header: Mutex::new(header.clone()),
+				provider: self.provider.clone(),
+			});
+			return ::engines::EpochChange::Yes(::engines::Proof::WithState(state_proof as Arc<_>));
 		}
 
 		// otherwise, we're checking for logs.
@@ -291,61 +374,16 @@ impl ValidatorSet for ValidatorSafeContract {
 	fn epoch_set(&self, first: bool, engine: &Engine, _number: ::header::BlockNumber, proof: &[u8])
 		-> Result<(SimpleList, Option<H256>), ::error::Error>
 	{
-		use transaction::{Action, Transaction};
-
 		let rlp = UntrustedRlp::new(proof);
 
 		if first {
 			trace!(target: "engine", "Recovering initial epoch set");
 
-			// TODO: match client contract_call_tx more cleanly without duplication.
-			const PROVIDED_GAS: u64 = 50_000_000;
-
 			let (old_header, state_items) = decode_first_proof(&rlp)?;
-			let old_hash = old_header.hash();
-
-			let env_info = ::vm::EnvInfo {
-				number: old_header.number(),
-				author: *old_header.author(),
-				difficulty: *old_header.difficulty(),
-				gas_limit: PROVIDED_GAS.into(),
-				timestamp: old_header.timestamp(),
-				last_hashes: {
-					// this will break if we don't inclue all 256 last hashes.
-					let mut last_hashes: Vec<_> = (0..256).map(|_| H256::default()).collect();
-					last_hashes[255] = *old_header.parent_hash();
-					Arc::new(last_hashes)
-				},
-				gas_used: 0.into(),
-			};
-
-			// check state proof using given engine.
 			let number = old_header.number();
-			let addresses = self.provider.get_validators(move |a, d| {
-				let from = Address::default();
-				let tx = Transaction {
-					nonce: engine.account_start_nonce(number),
-					action: Action::Call(a),
-					gas: PROVIDED_GAS.into(),
-					gas_price: U256::default(),
-					value: U256::default(),
-					data: d,
-				}.fake_sign(from);
-
-				let res = ::state::check_proof(
-					&state_items,
-					*old_header.state_root(),
-					&tx,
-					engine,
-					&env_info,
-				);
-
-				match res {
-					::state::ProvedExecution::BadProof => Err("Bad proof".into()),
-					::state::ProvedExecution::Failed(e) => Err(format!("Failed call: {}", e)),
-					::state::ProvedExecution::Complete(e) => Ok(e.output),
-				}
-			}).wait().map_err(::engines::EngineError::InsufficientProof)?;
+			let old_hash = old_header.hash();
+			let addresses = check_first_proof(engine, &self.provider, old_header, &state_items)
+				.map_err(::engines::EngineError::InsufficientProof)?;
 
 			trace!(target: "engine", "extracted epoch set at #{}: {} addresses",
 				number, addresses.len());
@@ -419,7 +457,7 @@ impl ValidatorSet for ValidatorSafeContract {
 				 }))
 	}
 
-	fn register_contract(&self, client: Weak<Client>) {
+	fn register_client(&self, client: Weak<EngineClient>) {
 		trace!(target: "engine", "Setting up contract caller.");
 		*self.client.write() = Some(client);
 	}
@@ -435,7 +473,7 @@ mod tests {
 	use spec::Spec;
 	use account_provider::AccountProvider;
 	use transaction::{Transaction, Action};
-	use client::{BlockChainClient, EngineClient};
+	use client::BlockChainClient;
 	use ethkey::Secret;
 	use miner::MinerService;
 	use tests::helpers::{generate_dummy_client_with_spec_and_accounts, generate_dummy_client_with_spec_and_data};
@@ -446,7 +484,7 @@ mod tests {
 	fn fetches_validators() {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
 		let vc = Arc::new(ValidatorSafeContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
-		vc.register_contract(Arc::downgrade(&client));
+		vc.register_client(Arc::downgrade(&client) as _);
 		let last_hash = client.best_block_header().hash();
 		assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
 		assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
@@ -460,7 +498,7 @@ mod tests {
 		let v1 = tap.insert_account(keccak("0").into(), "").unwrap();
 		let chain_id = Spec::new_validator_safe_contract().chain_id();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, Some(tap));
-		client.engine().register_client(Arc::downgrade(&client));
+		client.engine().register_client(Arc::downgrade(&client) as _);
 		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 
 		client.miner().set_engine_signer(v1, "".into()).unwrap();
@@ -474,7 +512,7 @@ mod tests {
 			data: "bfc708a000000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1".from_hex().unwrap(),
 		}.sign(&s0, Some(chain_id));
 		client.miner().import_own_transaction(client.as_ref(), tx.into()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 1);
 		// Add "1" validator back in.
 		let tx = Transaction {
@@ -486,13 +524,13 @@ mod tests {
 			data: "4d238c8e00000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1".from_hex().unwrap(),
 		}.sign(&s0, Some(chain_id));
 		client.miner().import_own_transaction(client.as_ref(), tx.into()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		// The transaction is not yet included so still unable to seal.
 		assert_eq!(client.chain_info().best_block_number, 1);
 
 		// Switch to the validator that is still there.
 		client.miner().set_engine_signer(v0, "".into()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		assert_eq!(client.chain_info().best_block_number, 2);
 		// Switch back to the added validator, since the state is updated.
 		client.miner().set_engine_signer(v1, "".into()).unwrap();
@@ -505,13 +543,13 @@ mod tests {
 			data: Vec::new(),
 		}.sign(&s0, Some(chain_id));
 		client.miner().import_own_transaction(client.as_ref(), tx.into()).unwrap();
-		client.update_sealing();
+		::client::EngineClient::update_sealing(&*client);
 		// Able to seal again.
 		assert_eq!(client.chain_info().best_block_number, 3);
 
 		// Check syncing.
 		let sync_client = generate_dummy_client_with_spec_and_data(Spec::new_validator_safe_contract, 0, 0, &[]);
-		sync_client.engine().register_client(Arc::downgrade(&sync_client));
+		sync_client.engine().register_client(Arc::downgrade(&sync_client) as _);
 		for i in 1..4 {
 			sync_client.import_block(client.block(BlockId::Number(i)).unwrap().into_inner()).unwrap();
 		}

ethcore/src/ethereum/ethash.rs

@@ -40,7 +40,7 @@ use rlp::{self, UntrustedRlp};
 use vm::LastHashes;
 use semantic_version::SemanticVersion;
 use tx_filter::{TransactionFilter};
-use client::{Client, BlockChainClient};
+use client::EngineClient;
 
 /// Parity tries to round block.gas_limit to multiple of this constant
 pub const PARITY_GAS_LIMIT_DETERMINANT: U256 = U256([37, 0, 0, 0]);
@@ -460,9 +460,9 @@ impl Engine for Arc<Ethash> {
 		Some(Box::new(::snapshot::PowSnapshot::new(SNAPSHOT_BLOCKS, MAX_SNAPSHOT_BLOCKS)))
 	}
 
-	fn register_client(&self, client: Weak<Client>) {
+	fn register_client(&self, client: Weak<EngineClient>) {
 		if let Some(ref filter) = self.tx_filter {
-			filter.register_client(client as Weak<BlockChainClient>);
+			filter.register_client(client);
 		}
 	}
 

ethcore/src/header.rs

@@ -261,8 +261,13 @@ impl Header {
 		s.out()
 	}
 
-	/// Get the KECCAK (Keccak) of this header, optionally `with_seal`.
+	/// Get the SHA3 (Keccak) of this header, optionally `with_seal`.
 	pub fn rlp_keccak(&self, with_seal: Seal) -> H256 { keccak(self.rlp(with_seal)) }
+
+	/// Encode the header, getting a type-safe wrapper around the RLP.
+	pub fn encoded(&self) -> ::encoded::Header {
+		::encoded::Header::new(self.rlp(Seal::With))
+	}
 }
 
 impl Decodable for Header {

ethcore/src/lib.rs

@@ -102,6 +102,7 @@ extern crate num;
 extern crate parking_lot;
 extern crate price_info;
 extern crate rand;
+extern crate rayon;
 extern crate rlp;
 extern crate hash;
 extern crate heapsize;

ethcore/src/service.rs

@@ -116,7 +116,7 @@ impl ClientService {
 		});
 		io_service.register_handler(client_io)?;
 
-		spec.engine.register_client(Arc::downgrade(&client));
+		spec.engine.register_client(Arc::downgrade(&client) as _);
 
 		let stop_guard = ::devtools::StopGuard::new();
 		run_ipc(ipc_path, client.clone(), snapshot.clone(), stop_guard.share());

ethcore/src/snapshot/tests/proof_of_authority.rs

@@ -93,7 +93,7 @@ fn make_chain(accounts: Arc<AccountProvider>, blocks_beyond: usize, transitions:
 	let mut cur_signers = vec![*RICH_ADDR];
 	{
 		let engine = client.engine();
-		engine.register_client(Arc::downgrade(&client));
+		engine.register_client(Arc::downgrade(&client) as _);
 	}
 
 	{

ethcore/src/spec/spec.rs

@@ -36,7 +36,6 @@ use factory::Factories;
 use header::{BlockNumber, Header};
 use pod_state::*;
 use rlp::{Rlp, RlpStream};
-use state_db::StateDB;
 use state::{Backend, State, Substate};
 use state::backend::Basic as BasicBackend;
 use trace::{NoopTracer, NoopVMTracer};
@@ -465,7 +464,7 @@ impl Spec {
 	}
 
 	/// Ensure that the given state DB has the trie nodes in for the genesis state.
-	pub fn ensure_db_good(&self, db: StateDB, factories: &Factories) -> Result<StateDB, Error> {
+	pub fn ensure_db_good<T: Backend>(&self, db: T, factories: &Factories) -> Result<T, Error> {
 		if db.as_hashdb().contains(&self.state_root()) {
 			return Ok(db)
 		}
@@ -487,6 +486,63 @@ impl Spec {
 			.and_then(|x| load_from(cache_dir, x).map_err(fmt))
 	}
 
+	/// initialize genesis epoch data, using in-memory database for
+	/// constructor.
+	pub fn genesis_epoch_data(&self) -> Result<Vec<u8>, String> {
+		use transaction::{Action, Transaction};
+		use util::{journaldb, kvdb};
+
+		let genesis = self.genesis_header();
+
+		let factories = Default::default();
+		let mut db = journaldb::new(
+			Arc::new(kvdb::in_memory(0)),
+			journaldb::Algorithm::Archive,
+			None,
+		);
+
+		self.ensure_db_good(BasicBackend(db.as_hashdb_mut()), &factories)
+			.map_err(|e| format!("Unable to initialize genesis state: {}", e))?;
+
+		let call = |a, d| {
+			let mut db = db.boxed_clone();
+			let env_info = ::evm::EnvInfo {
+				number: 0,
+				author: *genesis.author(),
+				timestamp: genesis.timestamp(),
+				difficulty: *genesis.difficulty(),
+				gas_limit: *genesis.gas_limit(),
+				last_hashes: Arc::new(Vec::new()),
+				gas_used: 0.into()
+			};
+
+			let from = Address::default();
+			let tx = Transaction {
+				nonce: self.engine.account_start_nonce(0),
+				action: Action::Call(a),
+				gas: U256::from(50_000_000), // TODO: share with client.
+				gas_price: U256::default(),
+				value: U256::default(),
+				data: d,
+			}.fake_sign(from);
+
+			let res = ::state::prove_transaction(
+				db.as_hashdb_mut(),
+				*genesis.state_root(),
+				&tx,
+				&*self.engine,
+				&env_info,
+				factories.clone(),
+				true,
+			);
+
+			res.map(|(out, proof)| (out, proof.into_iter().map(|x| x.into_vec()).collect()))
+				.ok_or_else(|| "Failed to prove call: insufficient state".into())
+		};
+
+		self.engine.genesis_epoch_data(&genesis, &call)
+	}
+
 	/// Create a new Spec which conforms to the Frontier-era Morden chain except that it's a NullEngine consensus.
 	pub fn new_test() -> Spec { load_bundled!("null_morden") }
 

ethcore/src/tx_filter.rs

@@ -19,10 +19,10 @@
 use std::sync::Weak;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
-use native_contracts::TransactAcl as Contract;
-use client::{BlockChainClient, BlockId, ChainNotify};
-use util::{Address, Bytes};
 use bigint::hash::H256;
+use native_contracts::TransactAcl as Contract;
+use client::{EngineClient, BlockId, ChainNotify};
+use util::{Address, Bytes};
 use parking_lot::{Mutex, RwLock};
 use futures::{self, Future};
 use spec::CommonParams;
@@ -43,7 +43,7 @@ mod tx_permissions {
 /// Connection filter that uses a contract to manage permissions.
 pub struct TransactionFilter {
 	contract: Mutex<Option<Contract>>,
-	client: RwLock<Option<Weak<BlockChainClient>>>,
+	client: RwLock<Option<Weak<EngineClient>>>,
 	contract_address: Address,
 	permission_cache: Mutex<HashMap<(H256, Address), u32>>,
 }
@@ -67,7 +67,7 @@ impl TransactionFilter {
 	}
 
 	/// Set client reference to be used for contract call.
-	pub fn register_client(&self, client: Weak<BlockChainClient>) {
+	pub fn register_client(&self, client: Weak<EngineClient>) {
 		*self.client.write() = Some(client);
 	}
 
@@ -79,6 +79,12 @@ impl TransactionFilter {
 				Some(client) => client,
 				_ => return false,
 			};
+
+			let client = match client.as_full_client() {
+				Some(client) => client,
+				_ => return false, // TODO: how to handle verification for light clients?
+			};
+
 			let tx_type = match transaction.action {
 				Action::Create => tx_permissions::CREATE,
 				Action::Call(address) => if client.code_hash(&address, BlockId::Hash(*parent_hash)).map_or(false, |c| c != KECCAK_EMPTY) {
@@ -205,7 +211,7 @@ mod test {
 		let key4 = KeyPair::from_secret(Secret::from("0000000000000000000000000000000000000000000000000000000000000004")).unwrap();
 
 		let filter = TransactionFilter::from_params(spec.params()).unwrap();
-		filter.register_client(Arc::downgrade(&client) as Weak<BlockChainClient>);
+		filter.register_client(Arc::downgrade(&client) as Weak<_>);
 		let mut basic_tx = Transaction::default();
 		basic_tx.action = Action::Call(Address::from("000000000000000000000000000000000000032"));
 		let create_tx = Transaction::default();

ethcore/src/verification/verification.rs

@@ -392,14 +392,13 @@ mod tests {
 			self.numbers.get(&index).cloned()
 		}
 
-		fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockNumber, _to_block: BlockNumber) -> Vec<BlockNumber> {
-			unimplemented!()
-		}
-
 		fn block_receipts(&self, _hash: &H256) -> Option<BlockReceipts> {
 			unimplemented!()
 		}
 
+		fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockNumber, _to_block: BlockNumber) -> Vec<BlockNumber> {
+			unimplemented!()
+		}
 
 		fn logs<F>(&self, _blocks: Vec<BlockNumber>, _matches: F, _limit: Option<usize>) -> Vec<LocalizedLogEntry>
 			where F: Fn(&LogEntry) -> bool, Self: Sized {

ethcore/wasm/Cargo.toml

@@ -8,7 +8,7 @@ byteorder = "1.0"
 ethcore-util = { path = "../../util" }
 ethcore-bigint = { path = "../../util/bigint" }
 log = "0.3"
-parity-wasm = "0.12"
+parity-wasm = "0.14"
 wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
 vm = { path = "../vm" }
 ethcore-logger = { path = "../../logger" }

ethcore/wasm/src/env.rs

@@ -19,7 +19,7 @@
 use parity_wasm::elements::ValueType::*;
 use parity_wasm::interpreter::{self, UserFunctionDescriptor};
 use parity_wasm::interpreter::UserFunctionDescriptor::*;
-use super::runtime::Runtime;
+use super::runtime::{Runtime, UserTrap};
 
 pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
 	Static(
@@ -87,6 +87,41 @@ pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
 		&[I32; 3],
 		Some(I32),
 	),
+	Static(
+		"_panic",
+		&[I32; 2],
+		None,
+	),
+	Static(
+		"_blockhash",
+		&[I32; 3],
+		Some(I32),
+	),
+	Static(
+		"_coinbase",
+		&[I32],
+		None,
+	),
+	Static(
+		"_timestamp",
+		&[],
+		Some(I32),
+	),
+	Static(
+		"_blocknumber",
+		&[],
+		Some(I32),
+	),
+	Static(
+		"_difficulty",
+		&[I32],
+		None,
+	),
+	Static(
+		"_gaslimit",
+		&[I32],
+		None,
+	),
 
 	// TODO: Get rid of it also somehow?
 	Static(
@@ -102,9 +137,10 @@ pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
 	),
 ];
 
-pub fn native_bindings<'a>(runtime: &'a mut Runtime) -> interpreter::UserFunctions<'a> {
-	interpreter::UserFunctions {
-		executor: runtime,
+pub fn native_bindings<'a>(runtime: &'a mut Runtime) -> interpreter::UserDefinedElements<'a, UserTrap> {
+	interpreter::UserDefinedElements {
+		executor: Some(runtime),
+		globals: ::std::collections::HashMap::new(),
 		functions: ::std::borrow::Cow::from(SIGNATURES),
 	}
 }

ethcore/wasm/src/lib.rs

@@ -39,21 +39,41 @@ use parity_wasm::{interpreter, elements};
 use parity_wasm::interpreter::ModuleInstanceInterface;
 
 use vm::{GasLeft, ReturnData, ActionParams};
-use self::runtime::{Runtime, RuntimeContext};
+use self::runtime::{Runtime, RuntimeContext, UserTrap};
 
-pub use self::runtime::Error as RuntimeError;
+pub use self::runtime::InterpreterError;
 
 const DEFAULT_RESULT_BUFFER: usize = 1024;
 
+/// Wrapped interpreter error
+#[derive(Debug)]
+pub struct Error(InterpreterError);
+
+impl From<InterpreterError> for Error {
+	fn from(e: InterpreterError) -> Self {
+		Error(e)
+	}
+}
+
+impl From<Error> for vm::Error {
+	fn from(e: Error) -> Self {
+		vm::Error::Wasm(format!("Wasm runtime error: {:?}", e.0))
+	}
+}
+
+impl From<UserTrap> for vm::Error {
+	fn from(e: UserTrap) -> Self { e.into() }
+}
+
 /// Wasm interpreter instance
 pub struct WasmInterpreter {
-	program: interpreter::ProgramInstance,
+	program: runtime::InterpreterProgramInstance,
 	result: Vec<u8>,
 }
 
 impl WasmInterpreter {
 	/// New wasm interpreter instance
-	pub fn new() -> Result<WasmInterpreter, RuntimeError> {
+	pub fn new() -> Result<WasmInterpreter, Error> {
 		Ok(WasmInterpreter {
 			program: interpreter::ProgramInstance::new()?,
 			result: Vec::with_capacity(DEFAULT_RESULT_BUFFER),
@@ -109,7 +129,7 @@ impl vm::Vm for WasmInterpreter {
 				params.value.value(),
 				params.data.unwrap_or(Vec::with_capacity(0)),
 			)
-		)?;
+		).map_err(|e| Error(e))?;
 
 		{
 			let execution_params = runtime.execution_params()
@@ -118,27 +138,30 @@ impl vm::Vm for WasmInterpreter {
 			let module_instance = self.program.add_module("contract", contract_module, Some(&execution_params.externals))
 				.map_err(|err| {
 					trace!(target: "wasm", "Error adding contract module: {:?}", err);
-					vm::Error::from(RuntimeError::Interpreter(err))
+					vm::Error::from(Error(err))
 				})?;
 
-			module_instance.execute_export("_call", execution_params)
-				.map_err(|err| {
+			match module_instance.execute_export("_call", execution_params) {
+				Ok(_) => { },
+				Err(interpreter::Error::User(UserTrap::Suicide)) => { },
+				Err(err) => {
 					trace!(target: "wasm", "Error executing contract: {:?}", err);
-					vm::Error::from(RuntimeError::Interpreter(err))
-				})?;
+					return Err(vm::Error::from(Error(err)))
+				}
+			}
 		}
 
 		let result = result::WasmResult::new(d_ptr);
-		if result.peek_empty(&*runtime.memory())? {
+		if result.peek_empty(&*runtime.memory()).map_err(|e| Error(e))? {
 			trace!(target: "wasm", "Contract execution result is empty.");
 			Ok(GasLeft::Known(runtime.gas_left()?.into()))
 		} else {
 			self.result.clear();
 			// todo: use memory views to avoid copy
-			self.result.extend(result.pop(&*runtime.memory())?);
+			self.result.extend(result.pop(&*runtime.memory()).map_err(|e| Error(e.into()))?);
 			let len = self.result.len();
 			Ok(GasLeft::NeedsReturn {
-				gas_left: runtime.gas_left()?.into(),
+				gas_left: runtime.gas_left().map_err(|e| Error(e.into()))?.into(),
 				data: ReturnData::new(
 					::std::mem::replace(&mut self.result, Vec::with_capacity(DEFAULT_RESULT_BUFFER)),
 					0,
@@ -149,9 +172,3 @@ impl vm::Vm for WasmInterpreter {
 		}
 	}
 }
-
-impl From<runtime::Error> for vm::Error {
-	fn from(err: runtime::Error) -> vm::Error {
-		vm::Error::Wasm(format!("WASM runtime-error: {:?}", err))
-	}
-}

ethcore/wasm/src/ptr.rs

@@ -16,9 +16,9 @@
 
 //! Wasm bound-checked ptr
 
-use parity_wasm::interpreter;
+use super::runtime::{InterpreterMemoryInstance, InterpreterError, UserTrap};
 
-/// Bound-checked wrapper for webassembly memory 
+/// Bound-checked wrapper for webassembly memory
 pub struct WasmPtr(u32);
 
 /// Error in bound check
@@ -28,15 +28,21 @@ pub enum Error {
 }
 
 impl From<u32> for WasmPtr {
-	fn from(raw: u32) -> Self { 
+	fn from(raw: u32) -> Self {
 		WasmPtr(raw)
 	}
 }
 
+impl From<Error> for InterpreterError {
+	fn from(_e: Error) -> Self {
+		UserTrap::MemoryAccessViolation.into()
+	}
+}
+
 impl WasmPtr {
 	// todo: use memory view when they are on
 	/// Check memory range and return data with given length starting from the current pointer value
-	pub fn slice(&self, len: u32, mem: &interpreter::MemoryInstance) -> Result<Vec<u8>, Error> {
+	pub fn slice(&self, len: u32, mem: &InterpreterMemoryInstance) -> Result<Vec<u8>, Error> {
 		mem.get(self.0, len as usize).map_err(|_| Error::AccessViolation)
 	}
 

ethcore/wasm/src/result.rs

@@ -18,10 +18,8 @@
 
 use byteorder::{LittleEndian, ByteOrder};
 
-use parity_wasm::interpreter;
-
 use super::ptr::WasmPtr;
-use super::runtime::Error as RuntimeError;
+use super::runtime::{InterpreterError, InterpreterMemoryInstance};
 
 /// Wrapper for wasm contract call result
 pub struct WasmResult {
@@ -35,13 +33,13 @@ impl WasmResult {
 	}
 
 	/// Check if the result contains any data
-	pub fn peek_empty(&self, mem: &interpreter::MemoryInstance) -> Result<bool, RuntimeError> {
+	pub fn peek_empty(&self, mem: &InterpreterMemoryInstance) -> Result<bool, InterpreterError> {
 		let result_len = LittleEndian::read_u32(&self.ptr.slice(16, mem)?[12..16]);
 		Ok(result_len == 0)
 	}
 
 	/// Consume the result ptr and return the actual data from wasm linear memory
-	pub fn pop(self, mem: &interpreter::MemoryInstance) -> Result<Vec<u8>, RuntimeError> {
+	pub fn pop(self, mem: &InterpreterMemoryInstance) -> Result<Vec<u8>, InterpreterError> {
 		let result_ptr = LittleEndian::read_u32(&self.ptr.slice(16, mem)?[8..12]);
 		let result_len = LittleEndian::read_u32(&self.ptr.slice(16, mem)?[12..16]);
 		trace!(target: "wasm", "contract result: {} bytes at @{}", result_len, result_ptr);

ethcore/wasm/src/runtime.rs

@@ -30,31 +30,68 @@ use vm::CallType;
 use super::ptr::{WasmPtr, Error as PtrError};
 use super::call_args::CallArgs;
 
-/// Wasm runtime error
-#[derive(Debug)]
-pub enum Error {
-	/// Storage error
-	Storage,
-	/// Allocator error
-	Allocator,
-	/// Invalid gas state during the call
-	InvalidGasState,
+/// User trap in native code
+#[derive(Debug, Clone, PartialEq)]
+pub enum UserTrap {
+	/// Storage read error
+	StorageReadError,
+	/// Storage update error
+	StorageUpdateError,
 	/// Memory access violation
-	AccessViolation,
-	/// Interpreter runtime error
-	Interpreter(interpreter::Error),
+	MemoryAccessViolation,
+	/// Native code resulted in suicide
+	Suicide,
+	/// Suicide was requested but coudn't complete
+	SuicideAbort,
+	/// Invalid gas state inside interpreter
+	InvalidGasState,
+	/// Query of the balance resulted in an error
+	BalanceQueryError,
+	/// Failed allocation
+	AllocationFailed,
+	/// Gas limit reached
+	GasLimit,
+	/// Unknown runtime function
+	Unknown,
+	/// Passed string had invalid utf-8 encoding
+	BadUtf8,
+	/// Other error in native code
+	Other,
+	/// Panic with message
+	Panic(String),
 }
 
-impl From<interpreter::Error> for Error {
-	fn from(err: interpreter::Error) -> Self {
-		Error::Interpreter(err)
+impl ::std::fmt::Display for UserTrap {
+	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+		match *self {
+			UserTrap::StorageReadError => write!(f, "Storage read error"),
+			UserTrap::StorageUpdateError => write!(f, "Storage update error"),
+			UserTrap::MemoryAccessViolation => write!(f, "Memory access violation"),
+			UserTrap::SuicideAbort => write!(f, "Attempt to suicide resulted in an error"),
+			UserTrap::InvalidGasState => write!(f, "Invalid gas state"),
+			UserTrap::BalanceQueryError => write!(f, "Balance query resulted in an error"),
+			UserTrap::Suicide => write!(f, "Suicide result"),
+			UserTrap::Unknown => write!(f, "Unknown runtime function invoked"),
+			UserTrap::AllocationFailed => write!(f, "Memory allocation failed (OOM)"),
+			UserTrap::BadUtf8 => write!(f, "String encoding is bad utf-8 sequence"),
+			UserTrap::GasLimit => write!(f, "Invocation resulted in gas limit violated"),
+			UserTrap::Other => write!(f, "Other unspecified error"),
+			UserTrap::Panic(ref msg) => write!(f, "Panic: {}", msg),
+		}
 	}
 }
 
-impl From<PtrError> for Error {
+impl interpreter::UserError for UserTrap { }
+
+pub type InterpreterError = interpreter::Error<UserTrap>;
+pub type InterpreterMemoryInstance = interpreter::MemoryInstance<UserTrap>;
+pub type InterpreterProgramInstance = interpreter::ProgramInstance<UserTrap>;
+pub type InterpreterCallerContext<'a> = interpreter::CallerContext<'a, UserTrap>;
+
+impl From<PtrError> for UserTrap {
 	fn from(err: PtrError) -> Self {
 		match err {
-			PtrError::AccessViolation => Error::AccessViolation,
+			PtrError::AccessViolation => UserTrap::MemoryAccessViolation,
 		}
 	}
 }
@@ -79,20 +116,20 @@ pub struct Runtime<'a, 'b> {
 	gas_limit: u64,
 	dynamic_top: u32,
 	ext: &'a mut vm::Ext,
-	memory: Arc<interpreter::MemoryInstance>,
+	memory: Arc<InterpreterMemoryInstance>,
 	context: RuntimeContext,
-	instance: &'b interpreter::ProgramInstance,
+	instance: &'b InterpreterProgramInstance,
 }
 
 impl<'a, 'b> Runtime<'a, 'b> {
 	/// New runtime for wasm contract with specified params
 	pub fn with_params<'c, 'd>(
 		ext: &'c mut vm::Ext,
-		memory: Arc<interpreter::MemoryInstance>,
+		memory: Arc<InterpreterMemoryInstance>,
 		stack_space: u32,
 		gas_limit: u64,
 		context: RuntimeContext,
-		program_instance: &'d interpreter::ProgramInstance,
+		program_instance: &'d InterpreterProgramInstance,
 	) -> Runtime<'c, 'd> {
 		Runtime {
 			gas_counter: 0,
@@ -106,30 +143,28 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 
 	/// Write to the storage from wasm memory
-	pub fn storage_write(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn storage_write(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let mut context = context;
 		let val = self.pop_h256(&mut context)?;
 		let key = self.pop_h256(&mut context)?;
 		trace!(target: "wasm", "storage_write: value {} at @{}", &val, &key);
 
-		self.ext.set_storage(key, val)
-			.map_err(|_| interpreter::Error::Trap("Storage update error".to_owned()))?;
+		self.ext.set_storage(key, val).map_err(|_| UserTrap::StorageUpdateError)?;
 
 		Ok(Some(0i32.into()))
 	}
 
 	/// Read from the storage to wasm memory
-	pub fn storage_read(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn storage_read(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let mut context = context;
 		let val_ptr = context.value_stack.pop_as::<i32>()?;
 		let key = self.pop_h256(&mut context)?;
 
-		let val = self.ext.storage_at(&key)
-			.map_err(|_| interpreter::Error::Trap("Storage read error".to_owned()))?;
+		let val = self.ext.storage_at(&key).map_err(|_| UserTrap::StorageReadError)?;
 
 		self.memory.set(val_ptr as u32, &*val)?;
 
@@ -137,21 +172,21 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 
 	/// Pass suicide to state runtime
-	pub fn suicide(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn suicide(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let mut context = context;
 		let refund_address = self.pop_address(&mut context)?;
 
-		self.ext.suicide(&refund_address)
-			.map_err(|_| interpreter::Error::Trap("Suicide error".to_owned()))?;
+		self.ext.suicide(&refund_address).map_err(|_| UserTrap::SuicideAbort)?;
 
-		Ok(None)
+		// We send trap to interpreter so it should abort further execution
+		Err(UserTrap::Suicide.into())
 	}
 
 	/// Invoke create in the state runtime
-	pub fn create(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn create(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		//
 		// method signature:
@@ -172,7 +207,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		let code = self.memory.get(code_ptr, code_len as usize)?;
 
 		let gas_left = self.gas_left()
-			.map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))?
+			.map_err(|_| UserTrap::InvalidGasState)?
 			.into();
 
 		match self.ext.create(&gas_left, &endowment, &code, vm::CreateContractAddress::FromSenderAndCodeHash) {
@@ -189,8 +224,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		}
 	}
 
-	pub fn call(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn call(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		//
 		// method signature:
@@ -207,8 +242,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 
 
-	fn call_code(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	fn call_code(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		//
 		// signature (same as static call):
@@ -227,9 +262,9 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		&mut self,
 		use_val: bool,
 		call_type: CallType,
-		context: interpreter::CallerContext,
+		context: InterpreterCallerContext,
 	)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 
 		trace!(target: "wasm", "runtime: call code");
@@ -255,7 +290,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
 
 		if let Some(ref val) = val {
 			let address_balance = self.ext.balance(&self.context.address)
-				.map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))?;
+				.map_err(|_| UserTrap::BalanceQueryError)?;
 
 			if &address_balance < val {
 				trace!(target: "wasm", "runtime: call failed due to balance check");
@@ -266,7 +301,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		let mut result = Vec::with_capacity(result_alloc_len as usize);
 		result.resize(result_alloc_len as usize, 0);
 		let gas = self.gas_left()
-			.map_err(|_| interpreter::Error::Trap("Gas state error".to_owned()))?
+			.map_err(|_| UserTrap::InvalidGasState)?
 			.into();
 		// todo: optimize to use memory views once it's in
 		let payload = self.memory.get(input_ptr, input_len as usize)?;
@@ -294,8 +329,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		}
 	}
 
-	pub fn static_call(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn static_call(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		// signature (same as code call):
 		// fn (
@@ -311,8 +346,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
 
 
 	/// Allocate memory using the wasm stack params
-	pub fn malloc(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	pub fn malloc(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let amount = context.value_stack.pop_as::<i32>()? as u32;
 		let previous_top = self.dynamic_top;
@@ -321,21 +356,21 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 
 	/// Allocate memory in wasm memory instance
-	pub fn alloc(&mut self, amount: u32) -> Result<u32, Error> {
+	pub fn alloc(&mut self, amount: u32) -> Result<u32, UserTrap> {
 		let previous_top = self.dynamic_top;
 		self.dynamic_top = previous_top + amount;
 		Ok(previous_top.into())
 	}
 
 	/// Report gas cost with the params passed in wasm stack
-	fn gas(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	fn gas(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let amount = context.value_stack.pop_as::<i32>()? as u64;
 		if self.charge_gas(amount) {
 			Ok(None)
 		} else {
-			Err(interpreter::Error::Trap(format!("Gas exceeds limits of {}", self.gas_limit)))
+			Err(UserTrap::GasLimit.into())
 		}
 	}
 
@@ -350,50 +385,50 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		}
 	}
 
-	fn h256_at(&self, ptr: WasmPtr) -> Result<H256, interpreter::Error> {
+	fn h256_at(&self, ptr: WasmPtr) -> Result<H256, InterpreterError> {
 		Ok(H256::from_slice(&ptr.slice(32, &*self.memory)
-			.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?
+			.map_err(|_| UserTrap::MemoryAccessViolation)?
 		))
 	}
 
-	fn pop_h256(&self, context: &mut interpreter::CallerContext) -> Result<H256, interpreter::Error> {
+	fn pop_h256(&self, context: &mut InterpreterCallerContext) -> Result<H256, InterpreterError> {
 		let ptr = WasmPtr::from_i32(context.value_stack.pop_as::<i32>()?)
-			.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?;
+			.map_err(|_| UserTrap::MemoryAccessViolation)?;
 		self.h256_at(ptr)
 	}
 
-	fn pop_u256(&self, context: &mut interpreter::CallerContext) -> Result<U256, interpreter::Error> {
+	fn pop_u256(&self, context: &mut InterpreterCallerContext) -> Result<U256, InterpreterError> {
 		let ptr = WasmPtr::from_i32(context.value_stack.pop_as::<i32>()?)
-			.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?;
+			.map_err(|_| UserTrap::MemoryAccessViolation)?;
 		self.h256_at(ptr).map(Into::into)
 	}
 
-	fn address_at(&self, ptr: WasmPtr) -> Result<Address, interpreter::Error> {
+	fn address_at(&self, ptr: WasmPtr) -> Result<Address, InterpreterError> {
 		Ok(Address::from_slice(&ptr.slice(20, &*self.memory)
-			.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?
+			.map_err(|_| UserTrap::MemoryAccessViolation)?
 		))
 	}
 
-	fn pop_address(&self, context: &mut interpreter::CallerContext) -> Result<Address, interpreter::Error> {
+	fn pop_address(&self, context: &mut InterpreterCallerContext) -> Result<Address, InterpreterError> {
 		let ptr = WasmPtr::from_i32(context.value_stack.pop_as::<i32>()?)
-			.map_err(|_| interpreter::Error::Trap("Memory access violation".to_owned()))?;
+			.map_err(|_| UserTrap::MemoryAccessViolation)?;
 		self.address_at(ptr)
 	}
 
-	fn user_trap(&mut self, _context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	fn unknown_trap(&mut self, _context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, UserTrap>
 	{
-		Err(interpreter::Error::Trap("unknown trap".to_owned()))
+		Err(UserTrap::Unknown)
 	}
 
 	fn user_noop(&mut self,
-		_context: interpreter::CallerContext
-	) -> Result<Option<interpreter::RuntimeValue>, interpreter::Error> {
+		_context: InterpreterCallerContext
+	) -> Result<Option<interpreter::RuntimeValue>, InterpreterError> {
 		Ok(None)
 	}
 
 	/// Write call descriptor to wasm memory
-	pub fn write_descriptor(&mut self, call_args: CallArgs) -> Result<WasmPtr, Error> {
+	pub fn write_descriptor(&mut self, call_args: CallArgs) -> Result<WasmPtr, InterpreterError> {
 		let d_ptr = self.alloc(16)?;
 
 		let args_len = call_args.len();
@@ -417,14 +452,14 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		Ok(d_ptr.into())
 	}
 
-	fn debug_log(&mut self, context: interpreter::CallerContext)
-			-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	fn debug_log(&mut self, context: InterpreterCallerContext)
+			-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let msg_len = context.value_stack.pop_as::<i32>()? as u32;
 		let msg_ptr = context.value_stack.pop_as::<i32>()? as u32;
 
 		let msg = String::from_utf8(self.memory.get(msg_ptr, msg_len as usize)?)
-			.map_err(|_| interpreter::Error::Trap("Debug log utf-8 decoding error".to_owned()))?;
+			.map_err(|_| UserTrap::BadUtf8)?;
 
 		trace!(target: "wasm", "Contract debug message: {}", msg);
 
@@ -432,18 +467,18 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 
 	/// Query current gas left for execution
-	pub fn gas_left(&self) -> Result<u64, Error> {
-		if self.gas_counter > self.gas_limit { return Err(Error::InvalidGasState); }
+	pub fn gas_left(&self) -> Result<u64, UserTrap> {
+		if self.gas_counter > self.gas_limit { return Err(UserTrap::InvalidGasState); }
 		Ok(self.gas_limit - self.gas_counter)
 	}
 
 	/// Shared memory reference
-	pub fn memory(&self) -> &interpreter::MemoryInstance {
+	pub fn memory(&self) -> &InterpreterMemoryInstance {
 		&*self.memory
 	}
 
-	fn mem_copy(&self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	fn mem_copy(&self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let len = context.value_stack.pop_as::<i32>()? as u32;
 		let dst = context.value_stack.pop_as::<i32>()? as u32;
@@ -459,8 +494,8 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		x >> 24 | x >> 8 & 0xff00 | x << 8 & 0xff0000 | x << 24
 	}
 
-	fn bitswap_i64(&mut self, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+	fn bitswap_i64(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		let x1 = context.value_stack.pop_as::<i32>()?;
 		let x2 = context.value_stack.pop_as::<i32>()?;
@@ -471,13 +506,83 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		self.return_i64(result)
 	}
 
-	fn return_i64(&mut self, val: i64) -> Result<Option<interpreter::RuntimeValue>, interpreter::Error> {
+	fn user_panic(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let msg_len = context.value_stack.pop_as::<i32>()? as u32;
+		let msg_ptr = context.value_stack.pop_as::<i32>()? as u32;
+
+		let msg = String::from_utf8(self.memory.get(msg_ptr, msg_len as usize)?)
+			.map_err(|_| UserTrap::BadUtf8)?;
+
+		trace!(target: "wasm", "Contract custom panic message: {}", msg);
+
+		Err(UserTrap::Panic(msg).into())
+	}
+
+	fn block_hash(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		let block_hi = context.value_stack.pop_as::<i32>()? as u32;
+		let block_lo = context.value_stack.pop_as::<i32>()? as u32;
+
+		let block_num = (block_hi as u64) << 32 | block_lo as u64;
+
+		trace!("Requesting block hash for block #{}", block_num);
+		let hash = self.ext.blockhash(&U256::from(block_num));
+
+		self.memory.set(return_ptr, &*hash)?;
+
+		Ok(Some(0i32.into()))
+	}
+
+	fn coinbase(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		self.memory.set(return_ptr, &*self.ext.env_info().author)?;
+		Ok(None)
+	}
+
+	fn timestamp(&mut self, _context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let timestamp = self.ext.env_info().timestamp as i64;
+		self.return_i64(timestamp)
+	}
+
+	fn block_number(&mut self, _context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let block_number: u64 = self.ext.env_info().number.into();
+		self.return_i64(block_number as i64)
+	}
+
+	fn difficulty(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		let difficulty: H256 = self.ext.env_info().difficulty.into();
+		self.memory.set(return_ptr, &*difficulty)?;
+		Ok(None)
+	}
+
+	fn ext_gas_limit(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		let gas_limit: H256 = self.ext.env_info().gas_limit.into();
+		self.memory.set(return_ptr, &*gas_limit)?;
+		Ok(None)
+	}
+
+	fn return_i64(&mut self, val: i64) -> Result<Option<interpreter::RuntimeValue>, InterpreterError> {
 		let uval = val as u64;
 		let hi = (uval >> 32) as i32;
 		let lo = (uval << 32 >> 32) as i32;
 
-		let target = self.instance.module("contract")
-			.ok_or(interpreter::Error::Trap("Error locating main execution entry".to_owned()))?;
+		let target = self.instance.module("contract").ok_or(UserTrap::Other)?;
 		target.execute_export(
 			"setTempRet0",
 			self.execution_params().add_argument(
@@ -489,7 +594,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		))
 	}
 
-	pub fn execution_params(&mut self) -> interpreter::ExecutionParams {
+	pub fn execution_params(&mut self) -> interpreter::ExecutionParams<UserTrap> {
 		use super::env;
 
 		let env_instance = self.instance.module("env")
@@ -505,9 +610,9 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 }
 
-impl<'a, 'b> interpreter::UserFunctionExecutor for Runtime<'a, 'b> {
-	fn execute(&mut self, name: &str, context: interpreter::CallerContext)
-		-> Result<Option<interpreter::RuntimeValue>, interpreter::Error>
+impl<'a, 'b> interpreter::UserFunctionExecutor<UserTrap> for Runtime<'a, 'b> {
+	fn execute(&mut self, name: &str, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
 		match name {
 			"_malloc" => {
@@ -551,10 +656,31 @@ impl<'a, 'b> interpreter::UserFunctionExecutor for Runtime<'a, 'b> {
 			"_llvm_bswap_i64" => {
 				self.bitswap_i64(context)
 			},
+			"_panic" => {
+				self.user_panic(context)
+			},
+			"_blockhash" => {
+				self.block_hash(context)
+			},
+			"_coinbase" => {
+				self.coinbase(context)
+			},
+			"_timestamp" => {
+				self.timestamp(context)
+			},
+			"_blocknumber" => {
+				self.block_number(context)
+			},
+			"_difficulty" => {
+				self.difficulty(context)
+			},
+			"_gaslimit" => {
+				self.ext_gas_limit(context)
+			},
 			_ => {
 				trace!(target: "wasm", "Trapped due to unhandled function: '{}'", name);
-				self.user_trap(context)
-			}
+				Ok(self.unknown_trap(context)?)
+			},
 		}
 	}
 }

ethcore/wasm/src/tests.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::sync::Arc;
+use std::collections::HashMap;
 use byteorder::{LittleEndian, ByteOrder};
 use bigint::prelude::U256;
 use bigint::hash::H256;
@@ -87,7 +88,7 @@ fn logger() {
 	};
 
 	println!("ext.store: {:?}", ext.store);
-	assert_eq!(gas_left, U256::from(99327));
+	assert_eq!(gas_left, U256::from(99529));
 	let address_val: H256 = address.into();
 	assert_eq!(
 		ext.store.get(&"0100000000000000000000000000000000000000000000000000000000000000".parse().unwrap()).expect("storage key to exist"),
@@ -138,7 +139,7 @@ fn identity() {
 		}
 	};
 
-	assert_eq!(gas_left, U256::from(99_672));
+	assert_eq!(gas_left, U256::from(99_762));
 
 	assert_eq!(
 		Address::from_slice(&result),
@@ -172,7 +173,7 @@ fn dispersion() {
 		}
 	};
 
-	assert_eq!(gas_left, U256::from(99_270));
+	assert_eq!(gas_left, U256::from(99_360));
 
 	assert_eq!(
 		result,
@@ -201,7 +202,7 @@ fn suicide_not() {
 		}
 	};
 
-	assert_eq!(gas_left, U256::from(99_578));
+	assert_eq!(gas_left, U256::from(99_668));
 
 	assert_eq!(
 		result,
@@ -235,7 +236,7 @@ fn suicide() {
 		}
 	};
 
-	assert_eq!(gas_left, U256::from(99_621));
+	assert_eq!(gas_left, U256::from(99_699));
 	assert!(ext.suicides.contains(&refund));
 }
 
@@ -266,7 +267,7 @@ fn create() {
 	assert!(ext.calls.contains(
 		&FakeCall {
 			call_type: FakeCallType::Create,
-			gas: U256::from(99_674),
+			gas: U256::from(99_734),
 			sender_address: None,
 			receive_address: None,
 			value: Some(1_000_000_000.into()),
@@ -274,7 +275,7 @@ fn create() {
 			code_address: None,
 		}
 	));
-	assert_eq!(gas_left, U256::from(99_596));
+	assert_eq!(gas_left, U256::from(99_686));
 }
 
 
@@ -308,7 +309,7 @@ fn call_code() {
 	assert!(ext.calls.contains(
 		&FakeCall {
 			call_type: FakeCallType::Call,
-			gas: U256::from(99_069),
+			gas: U256::from(99_129),
 			sender_address: Some(sender),
 			receive_address: Some(receiver),
 			value: None,
@@ -316,7 +317,7 @@ fn call_code() {
 			code_address: Some("0d13710000000000000000000000000000000000".parse().unwrap()),
 		}
 	));
-	assert_eq!(gas_left, U256::from(94144));
+	assert_eq!(gas_left, U256::from(94262));
 
 	// siphash result
 	let res = LittleEndian::read_u32(&result[..]);
@@ -353,7 +354,7 @@ fn call_static() {
 	assert!(ext.calls.contains(
 		&FakeCall {
 			call_type: FakeCallType::Call,
-			gas: U256::from(99_069),
+			gas: U256::from(99_129),
 			sender_address: Some(sender),
 			receive_address: Some(receiver),
 			value: None,
@@ -361,7 +362,7 @@ fn call_static() {
 			code_address: Some("13077bfb00000000000000000000000000000000".parse().unwrap()),
 		}
 	));
-	assert_eq!(gas_left, U256::from(94144));
+	assert_eq!(gas_left, U256::from(94262));
 
 	// siphash result
 	let res = LittleEndian::read_u32(&result[..]);
@@ -387,7 +388,7 @@ fn realloc() {
 				GasLeft::NeedsReturn { gas_left: gas, data: result, apply_state: _apply } => (gas, result.to_vec()),
 		}
 	};
-	assert_eq!(gas_left, U256::from(99432));
+	assert_eq!(gas_left, U256::from(99522));
 	assert_eq!(result, vec![0u8; 2]);
 }
 
@@ -413,12 +414,15 @@ fn storage_read() {
 		}
 	};
 
-	assert_eq!(gas_left, U256::from(99682));
+	assert_eq!(gas_left, U256::from(99800));
 	assert_eq!(Address::from(&result[12..32]), address);
 }
 
 macro_rules! reqrep_test {
 	($name: expr, $input: expr) => {
+		reqrep_test!($name, $input, vm::EnvInfo::default(), HashMap::new())
+	};
+	($name: expr, $input: expr, $info: expr, $block_hashes: expr) => {
 		{
 			::ethcore_logger::init_log();
 			let code = load_sample!($name);
@@ -428,18 +432,18 @@ macro_rules! reqrep_test {
 			params.code = Some(Arc::new(code));
 			params.data = Some($input);
 
-			let (gas_left, result) = {
-				let mut interpreter = wasm_interpreter();
-				let result = interpreter.exec(params, &mut FakeExt::new()).expect("Interpreter to execute without any errors");
-				match result {
-						GasLeft::Known(_) => { panic!("Test is expected to return payload to check"); },
-						GasLeft::NeedsReturn { gas_left: gas, data: result, apply_state: _apply } => (gas, result.to_vec()),
-				}
-			};
+			let mut fake_ext = FakeExt::new();
+			fake_ext.info = $info;
+			fake_ext.blockhashes = $block_hashes;
 
-			(gas_left, result)
+			let mut interpreter = wasm_interpreter();
+			interpreter.exec(params, &mut fake_ext)
+				.map(|result| match result {
+					GasLeft::Known(_) => { panic!("Test is expected to return payload to check"); },
+					GasLeft::NeedsReturn { gas_left: gas, data: result, apply_state: _apply } => (gas, result.to_vec()),
+				})
 		}
-	}
+	};
 }
 
 // math_* tests check the ability of wasm contract to perform big integer operations
@@ -462,9 +466,9 @@ fn math_add() {
 			arg_b.to_big_endian(&mut args[33..65]);
 			args.to_vec()
 		}
-	);
+	).expect("Interpreter to execute without any errors");
 
-	assert_eq!(gas_left, U256::from(98087));
+	assert_eq!(gas_left, U256::from(98177));
 	assert_eq!(
 		U256::from_dec_str("1888888888888888888888888888887").unwrap(),
 		(&result[..]).into()
@@ -484,16 +488,16 @@ fn math_mul() {
 			arg_b.to_big_endian(&mut args[33..65]);
 			args.to_vec()
 		}
-	);
+	).expect("Interpreter to execute without any errors");
 
-	assert_eq!(gas_left, U256::from(97236));
+	assert_eq!(gas_left, U256::from(97326));
 	assert_eq!(
 		U256::from_dec_str("888888888888888888888888888887111111111111111111111111111112").unwrap(),
 		(&result[..]).into()
 	);
 }
 
-// substraction
+// subtraction
 #[test]
 fn math_sub() {
 	let (gas_left, result) = reqrep_test!(
@@ -506,15 +510,33 @@ fn math_sub() {
 			arg_b.to_big_endian(&mut args[33..65]);
 			args.to_vec()
 		}
-	);
+	).expect("Interpreter to execute without any errors");
 
-	assert_eq!(gas_left, U256::from(98131));
+	assert_eq!(gas_left, U256::from(98221));
 	assert_eq!(
 		U256::from_dec_str("111111111111111111111111111111").unwrap(),
 		(&result[..]).into()
 	);
 }
 
+// subtraction with overflow
+#[test]
+fn math_sub_with_overflow() {
+	let result = reqrep_test!(
+		"math.wasm",
+		{
+			let mut args = [2u8; 65];
+			let arg_a = U256::from_dec_str("888888888888888888888888888888").unwrap();
+			let arg_b = U256::from_dec_str("999999999999999999999999999999").unwrap();
+			arg_a.to_big_endian(&mut args[1..33]);
+			arg_b.to_big_endian(&mut args[33..65]);
+			args.to_vec()
+		}
+	);
+
+	assert_eq!(result, Err(vm::Error::Wasm("Wasm runtime error: User(Panic(\"arithmetic operation overflow\"))".into())));
+}
+
 #[test]
 fn math_div() {
 	let (gas_left, result) = reqrep_test!(
@@ -527,11 +549,99 @@ fn math_div() {
 			arg_b.to_big_endian(&mut args[33..65]);
 			args.to_vec()
 		}
-	);
+	).expect("Interpreter to execute without any errors");
 
-	assert_eq!(gas_left, U256::from(91420));
+	assert_eq!(gas_left, U256::from(91510));
 	assert_eq!(
 		U256::from_dec_str("1125000").unwrap(),
 		(&result[..]).into()
 	);
 }
+
+// This test checks the ability of wasm contract to invoke
+// varios blockchain runtime methods
+#[test]
+fn externs() {
+	let (gas_left, result) = reqrep_test!(
+		"externs.wasm",
+		Vec::new(),
+		vm::EnvInfo {
+			number: 0x9999999999u64.into(),
+			author: "efefefefefefefefefefefefefefefefefefefef".parse().unwrap(),
+			timestamp: 0x8888888888u64.into(),
+			difficulty: H256::from("0f1f2f3f4f5f6f7f8f9fafbfcfdfefff0d1d2d3d4d5d6d7d8d9dadbdcdddedfd").into(),
+			gas_limit: 0x777777777777u64.into(),
+			last_hashes: Default::default(),
+			gas_used: 0.into(),
+		},
+		{
+			let mut hashes = HashMap::new();
+			hashes.insert(
+				U256::from(0),
+				H256::from("9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d")
+			);
+			hashes.insert(
+				U256::from(1),
+				H256::from("7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b")
+			);
+			hashes
+		}
+	).expect("Interpreter to execute without any errors");
+
+	assert_eq!(
+		&result[0..64].to_vec(),
+		&vec![
+			0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+			0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,
+		],
+		"Block hashes requested and returned do not match"
+	);
+
+	assert_eq!(
+		&result[64..84].to_vec(),
+		&vec![
+			0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+		],
+		"Coinbase requested and returned does not match"
+	);
+
+	assert_eq!(
+		&result[84..92].to_vec(),
+		&vec![
+			0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x00, 0x00
+		],
+		"Timestamp requested and returned does not match"
+	);
+
+	assert_eq!(
+		&result[92..100].to_vec(),
+		&vec![
+			0x99, 0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00
+		],
+		"Block number requested and returned does not match"
+	);
+
+	assert_eq!(
+		&result[100..132].to_vec(),
+		&vec![
+			0x0f, 0x1f, 0x2f, 0x3f, 0x4f, 0x5f, 0x6f, 0x7f,
+			0x8f, 0x9f, 0xaf, 0xbf, 0xcf, 0xdf, 0xef, 0xff,
+			0x0d, 0x1d, 0x2d, 0x3d, 0x4d, 0x5d, 0x6d, 0x7d,
+			0x8d, 0x9d, 0xad, 0xbd, 0xcd, 0xdd, 0xed, 0xfd,
+		],
+		"Difficulty requested and returned does not match"
+	);
+
+	assert_eq!(
+		&result[132..164].to_vec(),
+		&vec![
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+		],
+		"Gas limit requested and returned does not match"
+	);
+
+	assert_eq!(gas_left, U256::from(97588));
+}