Merge with master

ethcore/src/account.rs

@@ -166,16 +166,16 @@ impl Account {
 		!self.code_cache.is_empty() || (self.code_cache.is_empty() && self.code_hash == Some(SHA3_EMPTY))
 	}
 
-	/// Provide a database to lookup `code_hash`. Should not be called if it is a contract without code.
+	/// Provide a database to get `code_hash`. Should not be called if it is a contract without code.
 	pub fn cache_code(&mut self, db: &AccountDB) -> bool {
 		// TODO: fill out self.code_cache;
 		trace!("Account::cache_code: ic={}; self.code_hash={:?}, self.code_cache={}", self.is_cached(), self.code_hash, self.code_cache.pretty());
 		self.is_cached() ||
 			match self.code_hash {
-				Some(ref h) => match db.lookup(h) {
+				Some(ref h) => match db.get(h) {
 					Some(x) => { self.code_cache = x.to_vec(); true },
 					_ => {
-						warn!("Failed reverse lookup of {}", h);
+						warn!("Failed reverse get of {}", h);
 						false
 					},
 				},

ethcore/src/account_db.rs

@@ -37,18 +37,18 @@ impl<'db> HashDB for AccountDB<'db>{
 		unimplemented!()
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		if key == &SHA3_NULL_RLP {
 			return Some(&NULL_RLP_STATIC);
 		}
-		self.db.lookup(&combine_key(&self.address_hash, key))
+		self.db.get(&combine_key(&self.address_hash, key))
 	}
 
-	fn exists(&self, key: &H256) -> bool {
+	fn contains(&self, key: &H256) -> bool {
 		if key == &SHA3_NULL_RLP {
 			return true;
 		}
-		self.db.exists(&combine_key(&self.address_hash, key))
+		self.db.contains(&combine_key(&self.address_hash, key))
 	}
 
 	fn insert(&mut self, _value: &[u8]) -> H256 {
@@ -59,7 +59,7 @@ impl<'db> HashDB for AccountDB<'db>{
 		unimplemented!()
 	}
 
-	fn kill(&mut self, _key: &H256) {
+	fn remove(&mut self, _key: &H256) {
 		unimplemented!()
 	}
 }
@@ -95,18 +95,18 @@ impl<'db> HashDB for AccountDBMut<'db>{
 		unimplemented!()
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		if key == &SHA3_NULL_RLP {
 			return Some(&NULL_RLP_STATIC);
 		}
-		self.db.lookup(&combine_key(&self.address_hash, key))
+		self.db.get(&combine_key(&self.address_hash, key))
 	}
 
-	fn exists(&self, key: &H256) -> bool {
+	fn contains(&self, key: &H256) -> bool {
 		if key == &SHA3_NULL_RLP {
 			return true;
 		}
-		self.db.exists(&combine_key(&self.address_hash, key))
+		self.db.contains(&combine_key(&self.address_hash, key))
 	}
 
 	fn insert(&mut self, value: &[u8]) -> H256 {
@@ -127,12 +127,12 @@ impl<'db> HashDB for AccountDBMut<'db>{
 		self.db.emplace(key, value.to_vec())
 	}
 
-	fn kill(&mut self, key: &H256) {
+	fn remove(&mut self, key: &H256) {
 		if key == &SHA3_NULL_RLP {
 			return;
 		}
 		let key = combine_key(&self.address_hash, key);
-		self.db.kill(&key)
+		self.db.remove(&key)
 	}
 }
 

ethcore/src/account_provider.rs

@@ -0,0 +1,272 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Account management.
+
+use std::fmt;
+use std::sync::RwLock;
+use std::collections::HashMap;
+use util::{Address as H160, H256, H520};
+use ethstore::{SecretStore, Error as SSError, SafeAccount, EthStore};
+use ethstore::dir::{KeyDirectory};
+use ethstore::ethkey::{Address as SSAddress, Message as SSMessage, Secret as SSSecret, Random, Generator};
+
+/// Type of unlock.
+#[derive(Clone)]
+enum Unlock {
+	/// If account is unlocked temporarily, it should be locked after first usage.
+	Temp,
+	/// Account unlocked permantently can always sign message.
+	/// Use with caution.
+	Perm,
+}
+
+/// Data associated with account.
+#[derive(Clone)]
+struct AccountData {
+	unlock: Unlock,
+	password: String,
+}
+
+/// `AccountProvider` errors.
+#[derive(Debug)]
+pub enum Error {
+	/// Returned when account is not unlocked.
+	NotUnlocked,
+	/// Returned when signing fails.
+	SStore(SSError),
+}
+
+impl fmt::Display for Error {
+	fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+		match *self {
+			Error::NotUnlocked => write!(f, "Account is locked"),
+			Error::SStore(ref e) => write!(f, "{}", e),
+		}
+	}
+}
+
+impl From<SSError> for Error {
+	fn from(e: SSError) -> Self {
+		Error::SStore(e)
+	}
+}
+
+macro_rules! impl_bridge_type {
+	($name: ident, $size: expr, $core: ident, $store: ident) => {
+		/// Primitive
+		pub struct $name([u8; $size]);
+
+		impl From<[u8; $size]> for $name {
+			fn from(s: [u8; $size]) -> Self {
+				$name(s)
+			}
+		}
+
+		impl From<$core> for $name {
+			fn from(s: $core) -> Self {
+				$name(s.0)
+			}
+		}
+
+		impl From<$store> for $name {
+			fn from(s: $store) -> Self {
+				$name(s.into())
+			}
+		}
+
+		impl Into<$core> for $name {
+			fn into(self) -> $core {
+				$core(self.0)
+			}
+		}
+
+		impl Into<$store> for $name {
+			fn into(self) -> $store {
+				$store::from(self.0)
+			}
+		}
+	}
+}
+
+impl_bridge_type!(Secret, 32, H256, SSSecret);
+impl_bridge_type!(Message, 32, H256, SSMessage);
+impl_bridge_type!(Address, 20, H160, SSAddress);
+
+
+struct NullDir;
+
+impl KeyDirectory for NullDir {
+	fn load(&self) -> Result<Vec<SafeAccount>, SSError> {
+		Ok(vec![])
+	}
+
+	fn insert(&self, _account: SafeAccount) -> Result<(), SSError> {
+		Ok(())
+	}
+
+	fn remove(&self, _address: &SSAddress) -> Result<(), SSError> {
+		Ok(())
+	}
+}
+
+/// Account management.
+/// Responsible for unlocking accounts.
+pub struct AccountProvider {
+	unlocked: RwLock<HashMap<SSAddress, AccountData>>,
+	sstore: Box<SecretStore>,
+}
+
+impl AccountProvider {
+	/// Creates new account provider.
+	pub fn new(sstore: Box<SecretStore>) -> Self {
+		AccountProvider {
+			unlocked: RwLock::new(HashMap::new()),
+			sstore: sstore,
+		}
+	}
+
+	/// Creates not disk backed provider.
+	pub fn transient_provider() -> Self {
+		AccountProvider {
+			unlocked: RwLock::new(HashMap::new()),
+			sstore: Box::new(EthStore::open(Box::new(NullDir)).unwrap())
+		}
+	}
+
+	/// Creates new random account.
+	pub fn new_account(&self, password: &str) -> Result<H160, Error> {
+		let secret = Random.generate().unwrap().secret().clone();
+		let address = try!(self.sstore.insert_account(secret, password));
+		Ok(Address::from(address).into())
+	}
+
+	/// Inserts new account into underlying store.
+	/// Does not unlock account!
+	pub fn insert_account<S>(&self, secret: S, password: &str) -> Result<H160, Error> where Secret: From<S> {
+		let s = Secret::from(secret);
+		let address = try!(self.sstore.insert_account(s.into(), password));
+		Ok(Address::from(address).into())
+	}
+
+	/// Returns addresses of all accounts.
+	pub fn accounts(&self) -> Vec<H160> {
+		self.sstore.accounts().into_iter().map(|a| H160(a.into())).collect()
+	}
+
+	/// Helper method used for unlocking accounts.
+	fn unlock_account<A>(&self, account: A, password: String, unlock: Unlock) -> Result<(), Error> where Address: From<A> {
+		let a = Address::from(account);
+		let account = a.into();
+		// verify password by signing dump message
+		// result may be discarded
+		let _ = try!(self.sstore.sign(&account, &password, &Default::default()));
+
+		// check if account is already unlocked pernamently, if it is, do nothing
+		{
+			let unlocked = self.unlocked.read().unwrap();
+			if let Some(data) = unlocked.get(&account) {
+				if let Unlock::Perm = data.unlock {
+					return Ok(())
+				}
+			}
+		}
+
+		let data = AccountData {
+			unlock: unlock,
+			password: password,
+		};
+
+		let mut unlocked = self.unlocked.write().unwrap();
+		unlocked.insert(account, data);
+		Ok(())
+	}
+
+	/// Unlocks account permanently.
+	pub fn unlock_account_permanently<A>(&self, account: A, password: String) -> Result<(), Error> where Address: From<A> {
+		self.unlock_account(account, password, Unlock::Perm)
+	}
+
+	/// Unlocks account temporarily (for one signing).
+	pub fn unlock_account_temporarily<A>(&self, account: A, password: String) -> Result<(), Error> where Address: From<A> {
+		self.unlock_account(account, password, Unlock::Temp)
+	}
+
+	/// Checks if given account is unlocked
+	pub fn is_unlocked<A>(&self, account: A) -> bool where Address: From<A> {
+		let account = Address::from(account).into();
+		let unlocked = self.unlocked.read().unwrap();
+		unlocked.get(&account).is_some()
+	}
+
+	/// Signs the message. Account must be unlocked.
+	pub fn sign<A, M>(&self, account: A, message: M) -> Result<H520, Error> where Address: From<A>, Message: From<M> {
+		let account = Address::from(account).into();
+		let message = Message::from(message).into();
+
+		let data = {
+			let unlocked = self.unlocked.read().unwrap();
+			try!(unlocked.get(&account).ok_or(Error::NotUnlocked)).clone()
+		};
+
+		if let Unlock::Temp = data.unlock {
+			let mut unlocked = self.unlocked.write().unwrap();
+			unlocked.remove(&account).expect("data exists: so key must exist: qed");
+		}
+
+		let signature = try!(self.sstore.sign(&account, &data.password, &message));
+		Ok(H520(signature.into()))
+	}
+
+	/// Unlocks an account, signs the message, and locks it again.
+	pub fn sign_with_password<A, M>(&self, account: A, password: String, message: M) -> Result<H520, Error> where Address: From<A>, Message: From<M> {
+		let account = Address::from(account).into();
+		let message = Message::from(message).into();
+		let signature = try!(self.sstore.sign(&account, &password, &message));
+		Ok(H520(signature.into()))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::AccountProvider;
+	use ethstore::ethkey::{Generator, Random};
+
+	#[test]
+	fn unlock_account_temp() {
+		let kp = Random.generate().unwrap();
+		let ap = AccountProvider::transient_provider();
+		assert!(ap.insert_account(kp.secret().clone(), "test").is_ok());
+		assert!(ap.unlock_account_temporarily(kp.address(), "test1".into()).is_err());
+		assert!(ap.unlock_account_temporarily(kp.address(), "test".into()).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_err());
+	}
+
+	#[test]
+	fn unlock_account_perm() {
+		let kp = Random.generate().unwrap();
+		let ap = AccountProvider::transient_provider();
+		assert!(ap.insert_account(kp.secret().clone(), "test").is_ok());
+		assert!(ap.unlock_account_permanently(kp.address(), "test1".into()).is_err());
+		assert!(ap.unlock_account_permanently(kp.address(), "test".into()).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
+		assert!(ap.unlock_account_temporarily(kp.address(), "test".into()).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
+	}
+}

ethcore/src/basic_authority.rs

@@ -17,7 +17,7 @@
 //! A blockchain engine that supports a basic, non-BFT proof-of-authority.
 
 use common::*;
-use util::keys::store::AccountProvider;
+use account_provider::AccountProvider;
 use block::*;
 use spec::{CommonParams, Spec};
 use engine::*;
@@ -80,7 +80,7 @@ impl Engine for BasicAuthority {
 		Schedule::new_homestead()
 	}
 
-	fn populate_from_parent(&self, header: &mut Header, parent: &Header, gas_floor_target: U256) {
+	fn populate_from_parent(&self, header: &mut Header, parent: &Header, gas_floor_target: U256, _gas_ceil_target: U256) {
 		header.difficulty = parent.difficulty;
 		header.gas_limit = {
 			let gas_limit = parent.gas_limit;
@@ -105,15 +105,13 @@ impl Engine for BasicAuthority {
 	/// be returned.
 	fn generate_seal(&self, block: &ExecutedBlock, accounts: Option<&AccountProvider>) -> Option<Vec<Bytes>> {
 		if let Some(ap) = accounts {
-			// check to see if author is contained in self.our_params.authorities
-			if self.our_params.authorities.contains(block.header().author()) {
-				if let Ok(secret) = ap.account_secret(block.header().author()) {
-					return Some(block.header().author_seal(&secret));
-				} else {
-					trace!(target: "basicauthority", "generate_seal: FAIL: accounts secret key unavailable");
-				}
+			let header = block.header();
+			let message = header.bare_hash();
+			// account should be pernamently unlocked, otherwise sealing will fail
+			if let Ok(signature) = ap.sign(*block.header().author(), message) {
+				return Some(vec![encode(&signature).to_vec()]);
 			} else {
-				trace!(target: "basicauthority", "generate_seal: FAIL: block author {} isn't one of the authorized accounts {:?}", block.header().author(), self.our_params.authorities);
+				trace!(target: "basicauthority", "generate_seal: FAIL: accounts secret key unavailable");
 			}
 		} else {
 			trace!(target: "basicauthority", "generate_seal: FAIL: accounts not provided");
@@ -176,16 +174,6 @@ impl Header {
 	pub fn signature(&self) -> H520 {
 		decode(&self.seal()[0])
 	}
-
-	/// Generate a seal for the block with the given `secret`.
-	pub fn author_seal(&self, secret: &Secret) -> Vec<Bytes> {
-		vec![encode(&ec::sign(secret, &self.bare_hash()).unwrap_or(Signature::new())).to_vec()]
-	}
-
-	/// Set the nonce and mix hash fields of the header.
-	pub fn sign(&mut self, secret: &Secret) {
-		self.seal = self.author_seal(secret);
-	}
 }
 
 /// Create a new test chain spec with `BasicAuthority` consensus engine.
@@ -197,7 +185,7 @@ mod tests {
 	use common::*;
 	use block::*;
 	use tests::helpers::*;
-	use util::keys::{TestAccountProvider, TestAccount};
+	use account_provider::AccountProvider;
 
 	#[test]
 	fn has_valid_metadata() {
@@ -215,8 +203,9 @@ mod tests {
 			timestamp: 0,
 			difficulty: 0.into(),
 			last_hashes: vec![],
+			dao_rescue_block_gas_limit: None,
 			gas_used: 0.into(),
-			gas_limit: 0.into()
+			gas_limit: 0.into(),
 		});
 
 		assert!(schedule.stack_limit > 0);
@@ -251,24 +240,11 @@ mod tests {
 		}
 	}
 
-	#[test]
-	fn can_do_signature_verification() {
-		let secret = "".sha3();
-		let addr = KeyPair::from_secret("".sha3()).unwrap().address();
-
-		let engine = new_test_authority().engine;
-		let mut header: Header = Header::default();
-		header.set_author(addr);
-		header.sign(&secret);
-
-		assert!(engine.verify_block_unordered(&header, None).is_ok());
-	}
-
 	#[test]
 	fn can_generate_seal() {
-		let addr = KeyPair::from_secret("".sha3()).unwrap().address();
-		let accounts = hash_map![addr => TestAccount{unlocked: true, password: Default::default(), secret: "".sha3()}];
-		let tap = TestAccountProvider::new(accounts);
+		let tap = AccountProvider::transient_provider();
+		let addr = tap.insert_account("".sha3(), "").unwrap();
+		tap.unlock_account_permanently(addr, "".into()).unwrap();
 
 		let spec = new_test_authority();
 		let engine = &spec.engine;
@@ -278,10 +254,9 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, addr.clone(), 3141562.into(), vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, addr, (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let b = b.close_and_lock();
 		let seal = engine.generate_seal(b.block(), Some(&tap)).unwrap();
-
 		assert!(b.try_seal(engine.deref(), seal).is_ok());
 	}
 }

ethcore/src/block.rs

@@ -177,6 +177,7 @@ pub struct OpenBlock<'x> {
 	engine: &'x Engine,
 	vm_factory: &'x EvmFactory,
 	last_hashes: LastHashes,
+	dao_rescue_block_gas_limit: Option<U256>,
 }
 
 /// Just like `OpenBlock`, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
@@ -188,6 +189,7 @@ pub struct ClosedBlock {
 	block: ExecutedBlock,
 	uncle_bytes: Bytes,
 	last_hashes: LastHashes,
+	dao_rescue_block_gas_limit: Option<U256>,
 	unclosed_state: State,
 }
 
@@ -198,7 +200,6 @@ pub struct ClosedBlock {
 pub struct LockedBlock {
 	block: ExecutedBlock,
 	uncle_bytes: Bytes,
-	last_hashes: LastHashes,
 }
 
 /// A block that has a valid seal.
@@ -219,9 +220,10 @@ impl<'x> OpenBlock<'x> {
 		db: Box<JournalDB>,
 		parent: &Header,
 		last_hashes: LastHashes,
+		dao_rescue_block_gas_limit: Option<U256>,
 		author: Address,
-		gas_floor_target: U256,
-		extra_data: Bytes
+		gas_range_target: (U256, U256),
+		extra_data: Bytes,
 	) -> Result<Self, Error> {
 		let state = try!(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce()));
 		let mut r = OpenBlock {
@@ -229,6 +231,7 @@ impl<'x> OpenBlock<'x> {
 			engine: engine,
 			vm_factory: vm_factory,
 			last_hashes: last_hashes,
+			dao_rescue_block_gas_limit: dao_rescue_block_gas_limit,
 		};
 
 		r.block.base.header.parent_hash = parent.hash();
@@ -238,7 +241,7 @@ impl<'x> OpenBlock<'x> {
 		r.block.base.header.extra_data = extra_data;
 		r.block.base.header.note_dirty();
 
-		engine.populate_from_parent(&mut r.block.base.header, parent, gas_floor_target);
+		engine.populate_from_parent(&mut r.block.base.header, parent, gas_range_target.0, gas_range_target.1);
 		engine.on_new_block(&mut r.block);
 		Ok(r)
 	}
@@ -285,6 +288,7 @@ impl<'x> OpenBlock<'x> {
 	/// Get the environment info concerning this block.
 	pub fn env_info(&self) -> EnvInfo {
 		// TODO: memoise.
+		const SOFT_FORK_BLOCK: u64 = 1_800_000;
 		EnvInfo {
 			number: self.block.base.header.number,
 			author: self.block.base.header.author.clone(),
@@ -293,6 +297,7 @@ impl<'x> OpenBlock<'x> {
 			last_hashes: self.last_hashes.clone(),		// TODO: should be a reference.
 			gas_used: self.block.receipts.last().map_or(U256::zero(), |r| r.gas_used),
 			gas_limit: self.block.base.header.gas_limit.clone(),
+			dao_rescue_block_gas_limit: if self.block.base.header.number == SOFT_FORK_BLOCK { Some(self.block.base.header.gas_limit) } else { self.dao_rescue_block_gas_limit },
 		}
 	}
 
@@ -339,6 +344,7 @@ impl<'x> OpenBlock<'x> {
 			block: s.block,
 			uncle_bytes: uncle_bytes,
 			last_hashes: s.last_hashes,
+			dao_rescue_block_gas_limit: s.dao_rescue_block_gas_limit,
 			unclosed_state: unclosed_state,
 		}
 	}
@@ -360,7 +366,6 @@ impl<'x> OpenBlock<'x> {
 		LockedBlock {
 			block: s.block,
 			uncle_bytes: uncle_bytes,
-			last_hashes: s.last_hashes,
 		}
 	}
 }
@@ -386,7 +391,6 @@ impl ClosedBlock {
 		LockedBlock {
 			block: self.block,
 			uncle_bytes: self.uncle_bytes,
-			last_hashes: self.last_hashes,
 		}
 	}
 
@@ -400,6 +404,7 @@ impl ClosedBlock {
 			engine: engine,
 			vm_factory: vm_factory,
 			last_hashes: self.last_hashes,
+			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit,
 		}
 	}
 }
@@ -456,7 +461,18 @@ impl IsBlock for SealedBlock {
 
 /// Enact the block given by block header, transactions and uncles
 #[cfg_attr(feature="dev", allow(too_many_arguments))]
-pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes, vm_factory: &EvmFactory) -> Result<LockedBlock, Error> {
+pub fn enact(
+	header: &Header,
+	transactions: &[SignedTransaction],
+	uncles: &[Header],
+	engine: &Engine,
+	tracing: bool,
+	db: Box<JournalDB>,
+	parent: &Header,
+	last_hashes: LastHashes,
+	dao_rescue_block_gas_limit: Option<U256>,
+	vm_factory: &EvmFactory
+) -> Result<LockedBlock, Error> {
 	{
 		if ::log::max_log_level() >= ::log::LogLevel::Trace {
 			let s = try!(State::from_existing(db.boxed_clone(), parent.state_root().clone(), engine.account_start_nonce()));
@@ -464,7 +480,7 @@ pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Head
 		}
 	}
 
-	let mut b = try!(OpenBlock::new(engine, vm_factory, tracing, db, parent, last_hashes, header.author().clone(), 3141562.into(), header.extra_data().clone()));
+	let mut b = try!(OpenBlock::new(engine, vm_factory, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, header.author().clone(), (3141562.into(), 31415620.into()), header.extra_data().clone()));
 	b.set_difficulty(*header.difficulty());
 	b.set_gas_limit(*header.gas_limit());
 	b.set_timestamp(header.timestamp());
@@ -474,22 +490,52 @@ pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Head
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_bytes(block_bytes: &[u8], engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes, vm_factory: &EvmFactory) -> Result<LockedBlock, Error> {
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
+pub fn enact_bytes(
+	block_bytes: &[u8],
+	engine: &Engine,
+	tracing: bool,
+	db: Box<JournalDB>,
+	parent: &Header,
+	last_hashes: LastHashes,
+	dao_rescue_block_gas_limit: Option<U256>,
+	vm_factory: &EvmFactory
+) -> Result<LockedBlock, Error> {
 	let block = BlockView::new(block_bytes);
 	let header = block.header();
-	enact(&header, &block.transactions(), &block.uncles(), engine, tracing, db, parent, last_hashes, vm_factory)
+	enact(&header, &block.transactions(), &block.uncles(), engine, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, vm_factory)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_verified(block: &PreverifiedBlock, engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes, vm_factory: &EvmFactory) -> Result<LockedBlock, Error> {
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
+pub fn enact_verified(
+	block: &PreverifiedBlock,
+	engine: &Engine,
+	tracing: bool,
+	db: Box<JournalDB>,
+	parent: &Header,
+	last_hashes: LastHashes,
+	dao_rescue_block_gas_limit: Option<U256>,
+	vm_factory: &EvmFactory
+) -> Result<LockedBlock, Error> {
 	let view = BlockView::new(&block.bytes);
-	enact(&block.header, &block.transactions, &view.uncles(), engine, tracing, db, parent, last_hashes, vm_factory)
+	enact(&block.header, &block.transactions, &view.uncles(), engine, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, vm_factory)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
-pub fn enact_and_seal(block_bytes: &[u8], engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes, vm_factory: &EvmFactory) -> Result<SealedBlock, Error> {
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
+pub fn enact_and_seal(
+	block_bytes: &[u8],
+	engine: &Engine,
+	tracing: bool,
+	db: Box<JournalDB>,
+	parent: &Header,
+	last_hashes: LastHashes,
+	dao_rescue_block_gas_limit: Option<U256>,
+	vm_factory: &EvmFactory
+) -> Result<SealedBlock, Error> {
 	let header = BlockView::new(block_bytes).header_view();
-	Ok(try!(try!(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes, vm_factory)).seal(engine, header.seal())))
+	Ok(try!(try!(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, vm_factory)).seal(engine, header.seal())))
 }
 
 #[cfg(test)]
@@ -509,7 +555,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, Address::zero(), 3141562.into(), vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let b = b.close_and_lock();
 		let _ = b.seal(engine.deref(), vec![]);
 	}
@@ -525,7 +571,7 @@ mod tests {
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], Address::zero(), 3141562.into(), vec![]).unwrap()
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap()
 			.close_and_lock().seal(engine.deref(), vec![]).unwrap();
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();
@@ -533,7 +579,7 @@ mod tests {
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
-		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], &Default::default()).unwrap();
+		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], None, &Default::default()).unwrap();
 
 		assert_eq!(e.rlp_bytes(), orig_bytes);
 
@@ -553,7 +599,7 @@ mod tests {
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let vm_factory = Default::default();
-		let mut open_block = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], Address::zero(), 3141562.into(), vec![]).unwrap();
+		let mut open_block = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let mut uncle1_header = Header::new();
 		uncle1_header.extra_data = b"uncle1".to_vec();
 		let mut uncle2_header = Header::new();
@@ -568,7 +614,7 @@ mod tests {
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
-		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], &Default::default()).unwrap();
+		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], None, &Default::default()).unwrap();
 
 		let bytes = e.rlp_bytes();
 		assert_eq!(bytes, orig_bytes);

ethcore/src/block_queue.rs

@@ -130,7 +130,9 @@ impl QueueSignal {
 		}
 
 		if self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) == false {
-			self.message_channel.send(UserMessage(SyncMessage::BlockVerified)).expect("Error sending BlockVerified message");
+			if let Err(e) = self.message_channel.send(UserMessage(SyncMessage::BlockVerified)) {
+				debug!("Error sending BlockVerified message: {:?}", e);
+			}
 		}
 	}
 

ethcore/src/blockchain/blockchain.rs

@@ -253,12 +253,22 @@ impl BlockChain {
 		// open extras db
 		let mut extras_path = path.to_path_buf();
 		extras_path.push("extras");
-		let extras_db = Database::open_default(extras_path.to_str().unwrap()).unwrap();
+		let extras_db = match config.db_cache_size {
+			None => Database::open_default(extras_path.to_str().unwrap()).unwrap(),
+			Some(cache_size) => Database::open(
+				&DatabaseConfig::with_cache(cache_size/2),
+				extras_path.to_str().unwrap()).unwrap(),
+		};
 
 		// open blocks db
 		let mut blocks_path = path.to_path_buf();
 		blocks_path.push("blocks");
-		let blocks_db = Database::open_default(blocks_path.to_str().unwrap()).unwrap();
+		let blocks_db = match config.db_cache_size {
+			None => Database::open_default(blocks_path.to_str().unwrap()).unwrap(),
+			Some(cache_size) => Database::open(
+				&DatabaseConfig::with_cache(cache_size/2),
+				blocks_path.to_str().unwrap()).unwrap(),
+		};
 
 		let mut cache_man = CacheManager{cache_usage: VecDeque::new(), in_use: HashSet::new()};
 		(0..COLLECTION_QUEUE_SIZE).foreach(|_| cache_man.cache_usage.push_back(HashSet::new()));

ethcore/src/blockchain/config.rs

@@ -23,6 +23,8 @@ pub struct Config {
 	pub pref_cache_size: usize,
 	/// Maximum cache size in bytes.
 	pub max_cache_size: usize,
+	/// Backing db cache_size
+	pub db_cache_size: Option<usize>,
 }
 
 impl Default for Config {
@@ -30,6 +32,7 @@ impl Default for Config {
 		Config {
 			pref_cache_size: 1 << 14,
 			max_cache_size: 1 << 20,
+			db_cache_size: None,
 		}
 	}
 }

ethcore/src/client/client.rs

@@ -16,9 +16,9 @@
 
 //! Blockchain database client.
 
-use std::marker::PhantomData;
 use std::fs::{create_dir, File};
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 use util::*;
 use util::panics::*;
 use views::BlockView;
@@ -30,7 +30,8 @@ use engine::Engine;
 use views::HeaderView;
 use service::{NetSyncMessage, SyncMessage};
 use env_info::LastHashes;
-use verification::*;
+use verification;
+use verification::{PreverifiedBlock, Verifier};
 use block::*;
 use transaction::{LocalizedTransaction, SignedTransaction, Action};
 use blockchain::extras::TransactionAddress;
@@ -38,7 +39,7 @@ use filter::Filter;
 use log_entry::LocalizedLogEntry;
 use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
-use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics};
+use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, DatabaseCompactionProfile, BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics};
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -51,6 +52,8 @@ pub use types::block_status::BlockStatus;
 use evm::Factory as EvmFactory;
 use miner::{Miner, MinerService, TransactionImportResult, AccountDetails};
 
+const MAX_TX_QUEUE_SIZE: usize = 4096;
+
 impl fmt::Display for BlockChainInfo {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		write!(f, "#{}.{}", self.best_block_number, self.best_block_hash)
@@ -81,7 +84,7 @@ impl ClientReport {
 
 /// Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue.
 /// Call `import_block()` to import a block asynchronously; `flush_queue()` flushes the queue.
-pub struct Client<V = CanonVerifier> where V: Verifier {
+pub struct Client {
 	chain: Arc<BlockChain>,
 	tracedb: Arc<TraceDB<BlockChain>>,
 	engine: Arc<Box<Engine>>,
@@ -90,9 +93,11 @@ pub struct Client<V = CanonVerifier> where V: Verifier {
 	report: RwLock<ClientReport>,
 	import_lock: Mutex<()>,
 	panic_handler: Arc<PanicHandler>,
-	verifier: PhantomData<V>,
+	verifier: Box<Verifier>,
 	vm_factory: Arc<EvmFactory>,
 	miner: Arc<Miner>,
+	io_channel: IoChannel<NetSyncMessage>,
+	queue_transactions: AtomicUsize,
 }
 
 const HISTORY: u64 = 1200;
@@ -103,13 +108,6 @@ const HISTORY: u64 = 1200;
 // of which you actually want force an upgrade.
 const CLIENT_DB_VER_STR: &'static str = "5.3";
 
-impl Client<CanonVerifier> {
-	/// Create a new client with given spec and root path.
-	pub fn new(config: ClientConfig, spec: Spec, path: &Path, miner: Arc<Miner>, message_channel: IoChannel<NetSyncMessage> ) -> Result<Arc<Client>, ClientError> {
-		Client::<CanonVerifier>::new_with_verifier(config, spec, path, miner, message_channel)
-	}
-}
-
 /// Get the path for the databases given the root path and information on the databases.
 pub fn get_db_path(path: &Path, pruning: journaldb::Algorithm, genesis_hash: H256) -> PathBuf {
 	let mut dir = path.to_path_buf();
@@ -127,22 +125,35 @@ pub fn append_path(path: &Path, item: &str) -> String {
 	p.to_str().unwrap().to_owned()
 }
 
-impl<V> Client<V> where V: Verifier {
-	///  Create a new client with given spec and root path and custom verifier.
-	pub fn new_with_verifier(
+impl Client {
+	///  Create a new client with given spec and DB path and custom verifier.
+	pub fn new(
 		config: ClientConfig,
 		spec: Spec,
 		path: &Path,
 		miner: Arc<Miner>,
 		message_channel: IoChannel<NetSyncMessage>)
-		-> Result<Arc<Client<V>>, ClientError>
+		-> Result<Arc<Client>, ClientError>
 	{
 		let path = get_db_path(path, config.pruning, spec.genesis_header().hash());
 		let gb = spec.genesis_block();
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, &path));
 		let tracedb = Arc::new(try!(TraceDB::new(config.tracing, &path, chain.clone())));
 
-		let mut state_db = journaldb::new(&append_path(&path, "state"), config.pruning);
+		let mut state_db_config = match config.db_cache_size {
+			None => DatabaseConfig::default(),
+			Some(cache_size) => DatabaseConfig::with_cache(cache_size),
+		};
+
+		if config.db_compaction == DatabaseCompactionProfile::HDD {
+			state_db_config = state_db_config.compaction(CompactionProfile::hdd());
+		}
+
+		let mut state_db = journaldb::new(
+			&append_path(&path, "state"),
+			config.pruning,
+			state_db_config
+		);
 
 		if state_db.is_empty() && spec.ensure_db_good(state_db.as_hashdb_mut()) {
 			state_db.commit(0, &spec.genesis_header().hash(), None).expect("Error commiting genesis state to state DB");
@@ -150,7 +161,7 @@ impl<V> Client<V> where V: Verifier {
 
 		let engine = Arc::new(spec.engine);
 
-		let block_queue = BlockQueue::new(config.queue, engine.clone(), message_channel);
+		let block_queue = BlockQueue::new(config.queue, engine.clone(), message_channel.clone());
 		let panic_handler = PanicHandler::new_in_arc();
 		panic_handler.forward_from(&block_queue);
 
@@ -163,9 +174,11 @@ impl<V> Client<V> where V: Verifier {
 			report: RwLock::new(Default::default()),
 			import_lock: Mutex::new(()),
 			panic_handler: panic_handler,
-			verifier: PhantomData,
+			verifier: verification::new(config.verifier_type),
 			vm_factory: Arc::new(EvmFactory::new(config.vm_type)),
 			miner: miner,
+			io_channel: message_channel,
+			queue_transactions: AtomicUsize::new(0),
 		};
 
 		Ok(Arc::new(client))
@@ -203,7 +216,7 @@ impl<V> Client<V> where V: Verifier {
 		}
 
 		// Verify Block Family
-		let verify_family_result = V::verify_block_family(&header, &block.bytes, engine, self.chain.deref());
+		let verify_family_result = self.verifier.verify_block_family(&header, &block.bytes, engine, self.chain.deref());
 		if let Err(e) = verify_family_result {
 			warn!(target: "client", "Stage 3 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
@@ -221,7 +234,7 @@ impl<V> Client<V> where V: Verifier {
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().boxed_clone();
 
-		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory);
+		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, self.dao_rescue_block_gas_limit(header.parent_hash.clone()), &self.vm_factory);
 		if let Err(e) = enact_result {
 			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
@@ -229,7 +242,7 @@ impl<V> Client<V> where V: Verifier {
 
 		// Final Verification
 		let locked_block = enact_result.unwrap();
-		if let Err(e) = V::verify_block_final(&header, locked_block.block().header()) {
+		if let Err(e) = self.verifier.verify_block_final(&header, locked_block.block().header()) {
 			warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
 		}
@@ -272,6 +285,7 @@ impl<V> Client<V> where V: Verifier {
 		let mut import_results = Vec::with_capacity(max_blocks_to_import);
 
 		let _import_lock = self.import_lock.lock();
+		let _timer = PerfTimer::new("import_verified_blocks");
 		let blocks = self.block_queue.drain(max_blocks_to_import);
 
 		let original_best = self.chain_info().best_block_hash;
@@ -286,7 +300,7 @@ impl<V> Client<V> where V: Verifier {
 			let closed_block = self.check_and_close_block(&block);
 			if let Err(_) = closed_block {
 				invalid_blocks.insert(header.hash());
-				break;
+				continue;
 			}
 			imported_blocks.push(header.hash());
 
@@ -349,7 +363,7 @@ impl<V> Client<V> where V: Verifier {
 					invalid: invalid_blocks,
 					enacted: enacted,
 					retracted: retracted,
-				})).unwrap();
+				})).unwrap_or_else(|e| warn!("Error sending IO notification: {:?}", e));
 			}
 		}
 
@@ -362,6 +376,19 @@ impl<V> Client<V> where V: Verifier {
 		imported
 	}
 
+	/// Import transactions from the IO queue
+	pub fn import_queued_transactions(&self, transactions: &[Bytes]) -> usize {
+		let _timer = PerfTimer::new("import_queued_transactions");
+		self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
+		let fetch_account = |a: &Address| AccountDetails {
+			nonce: self.latest_nonce(a),
+			balance: self.latest_balance(a),
+		};
+		let tx = transactions.iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
+		let results = self.miner.import_transactions(self, tx, fetch_account);
+		results.len()
+	}
+
 	/// Attempt to get a copy of a specific block's state.
 	///
 	/// This will not fail if given BlockID::Latest.
@@ -450,7 +477,7 @@ impl<V> Client<V> where V: Verifier {
 	}
 }
 
-impl<V> BlockChainClient for Client<V> where V: Verifier {
+impl BlockChainClient for Client {
 	fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, ExecutionError> {
 		let header = self.block_header(BlockID::Latest).unwrap();
 		let view = HeaderView::new(&header);
@@ -463,6 +490,7 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			last_hashes: last_hashes,
 			gas_used: U256::zero(),
 			gas_limit: U256::max_value(),
+			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit(view.parent_hash()),
 		};
 		// that's just a copy of the state.
 		let mut state = self.state();
@@ -748,11 +776,27 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			nonce: self.latest_nonce(a),
 			balance: self.latest_balance(a),
 		};
-		self.miner.import_transactions(transactions, fetch_account)
+		self.miner.import_transactions(self, transactions, fetch_account)
 	}
 
-	fn all_transactions(&self) -> Vec<SignedTransaction> {
-		self.miner.all_transactions()
+	fn queue_transactions(&self, transactions: Vec<Bytes>) {
+		if self.queue_transactions.load(AtomicOrdering::Relaxed) > MAX_TX_QUEUE_SIZE {
+			debug!("Ignoring {} transactions: queue is full", transactions.len());
+		} else {
+			let len = transactions.len();
+			match self.io_channel.send(NetworkIoMessage::User(SyncMessage::NewTransactions(transactions))) {
+				Ok(_) => {
+					self.queue_transactions.fetch_add(len, AtomicOrdering::SeqCst);
+				}
+				Err(e) => {
+					debug!("Ignoring {} transactions: error queueing: {}", len, e);
+				}
+			}
+		}
+	}
+
+	fn pending_transactions(&self) -> Vec<SignedTransaction> {
+		self.miner.pending_transactions()
 	}
 
 	fn take_snapshot(&self, root_dir: &Path) {
@@ -794,8 +838,8 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 	}
 }
 
-impl<V> MiningBlockChainClient for Client<V> where V: Verifier {
-	fn prepare_open_block(&self, author: Address, gas_floor_target: U256, extra_data: Bytes) -> OpenBlock {
+impl MiningBlockChainClient for Client {
+	fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes) -> OpenBlock {
 		let engine = self.engine.deref().deref();
 		let h = self.chain.best_block_hash();
 
@@ -806,11 +850,11 @@ impl<V> MiningBlockChainClient for Client<V> where V: Verifier {
 			self.state_db.lock().unwrap().boxed_clone(),
 			&self.chain.block_header(&h).expect("h is best block hash: so it's header must exist: qed"),
 			self.build_last_hashes(h.clone()),
+			self.dao_rescue_block_gas_limit(h.clone()),
 			author,
-			gas_floor_target,
+			gas_range_target,
 			extra_data,
-		).expect("OpenBlock::new only fails if parent state root invalid. State root of best block's header is never invalid. \
-		         Therefore creating an OpenBlock with the best block's header will not fail.");
+		).expect("OpenBlock::new only fails if parent state root invalid; state root of best block's header is never invalid; qed");
 
 		// Add uncles
 		self.chain
@@ -824,10 +868,6 @@ impl<V> MiningBlockChainClient for Client<V> where V: Verifier {
 
 		open_block
 	}
-
-	fn try_seal(&self, block: LockedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock> {
-		block.try_seal(self.engine.deref().deref(), seal)
-	}
 }
 
 impl MayPanic for Client {

ethcore/src/client/config.rs

@@ -18,8 +18,22 @@ pub use block_queue::BlockQueueConfig;
 pub use blockchain::Config as BlockChainConfig;
 pub use trace::{Config as TraceConfig, Switch};
 pub use evm::VMType;
+pub use verification::VerifierType;
 use util::journaldb;
 
+/// Client state db compaction profile
+#[derive(Debug, PartialEq)]
+pub enum DatabaseCompactionProfile {
+	/// Default compaction profile
+	Default,
+	/// HDD or other slow storage io compaction profile
+	HDD,
+}
+
+impl Default for DatabaseCompactionProfile {
+	fn default() -> Self { DatabaseCompactionProfile::Default }
+}
+
 /// Client configuration. Includes configs for all sub-systems.
 #[derive(Debug, Default)]
 pub struct ClientConfig {
@@ -35,4 +49,10 @@ pub struct ClientConfig {
 	pub pruning: journaldb::Algorithm,
 	/// The name of the client instance.
 	pub name: String,
+	/// State db cache-size if not default
+	pub db_cache_size: Option<usize>,
+	/// State db compaction profile
+	pub db_compaction: DatabaseCompactionProfile,
+	/// Type of block verifier used by client.
+	pub verifier_type: VerifierType,
 }

ethcore/src/client/mod.rs

@@ -23,7 +23,7 @@ mod test_client;
 mod trace;
 
 pub use self::client::*;
-pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig, Switch, VMType};
+pub use self::config::{ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, Switch, VMType};
 pub use self::error::Error;
 pub use types::ids::*;
 pub use self::test_client::{TestBlockChainClient, EachBlockWith};
@@ -35,13 +35,15 @@ use std::path::Path;
 use util::bytes::Bytes;
 use util::hash::{Address, H256, H2048};
 use util::numbers::U256;
+use util::Itertools;
 use blockchain::TreeRoute;
 use block_queue::BlockQueueInfo;
-use block::{LockedBlock, SealedBlock, OpenBlock};
+use block::OpenBlock;
 use header::{BlockNumber, Header};
 use transaction::{LocalizedTransaction, SignedTransaction};
 use log_entry::LocalizedLogEntry;
 use filter::Filter;
+use views::{HeaderView, BlockView};
 use error::{ImportResult, ExecutionError};
 use receipt::LocalizedReceipt;
 use trace::LocalizedTrace;
@@ -192,20 +194,68 @@ pub trait BlockChainClient : Sync + Send {
 	/// import transactions from network/other 3rd party
 	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, EthError>>;
 
-	/// list all transactions
-	fn all_transactions(&self) -> Vec<SignedTransaction>;
+	/// Queue transactions for importing.
+	fn queue_transactions(&self, transactions: Vec<Bytes>);
 
 	/// Generate a PV64 snapshot for the current best block, saving it within the
 	/// root directory, whose path is given.
 	fn take_snapshot(&self, root_dir: &Path);
+
+	/// list all transactions
+	fn pending_transactions(&self) -> Vec<SignedTransaction>;
+
+	/// Get the gas price distribution.
+	fn gas_price_statistics(&self, sample_size: usize, distribution_size: usize) -> Result<Vec<U256>, ()> {
+		let mut h = self.chain_info().best_block_hash;
+		let mut corpus = Vec::new();
+		for _ in 0..sample_size {
+			let block_bytes = self.block(BlockID::Hash(h)).expect("h is either the best_block_hash or an ancestor; qed");
+			let block = BlockView::new(&block_bytes);
+			let header = block.header_view();
+			if header.number() == 0 {
+				break;
+			}
+			block.transaction_views().iter().foreach(|t| corpus.push(t.gas_price()));
+			h = header.parent_hash().clone();
+		}
+		corpus.sort();
+		let n = corpus.len();
+		if n > 0 {
+			Ok((0..(distribution_size + 1))
+				.map(|i| corpus[i * (n - 1) / distribution_size])
+				.collect::<Vec<_>>()
+			)
+		} else {
+			Err(())
+		}
+	}
+
+	/// Get `Some` gas limit of SOFT_FORK_BLOCK, or `None` if chain is not yet that long.
+	fn dao_rescue_block_gas_limit(&self, chain_hash: H256) -> Option<U256> {
+		const SOFT_FORK_BLOCK: u64 = 1800000;
+		// shortcut if the canon chain is already known.
+		if self.chain_info().best_block_number > SOFT_FORK_BLOCK + 1000 {
+			return self.block_header(BlockID::Number(SOFT_FORK_BLOCK)).map(|header| HeaderView::new(&header).gas_limit());
+		}
+		// otherwise check according to `chain_hash`.
+		if let Some(mut header) = self.block_header(BlockID::Hash(chain_hash)) {
+			if HeaderView::new(&header).number() < SOFT_FORK_BLOCK {
+				None
+			} else {
+				while HeaderView::new(&header).number() != SOFT_FORK_BLOCK {
+					header = self.block_header(BlockID::Hash(HeaderView::new(&header).parent_hash())).expect("chain is complete; parent of chain entry must be in chain; qed");
+				}
+				Some(HeaderView::new(&header).gas_limit())
+			}
+		} else {
+			None
+		}
+	}
 }
 
 /// Extended client interface used for mining
 pub trait MiningBlockChainClient : BlockChainClient {
-	/// Attempts to seal given block. Returns `SealedBlock` on success and the same block in case of error.
-	fn try_seal(&self, block: LockedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock>;
-
 	/// Returns OpenBlock prepared for closing.
-	fn prepare_open_block(&self, author: Address, gas_floor_target: U256, extra_data: Bytes)
+	fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes)
 		-> OpenBlock;
 }

ethcore/src/client/test_client.rs

@@ -29,9 +29,10 @@ use blockchain::extras::BlockReceipts;
 use error::{ImportResult};
 use evm::Factory as EvmFactory;
 use miner::{Miner, MinerService};
+use spec::Spec;
 
 use block_queue::BlockQueueInfo;
-use block::{SealedBlock, LockedBlock, OpenBlock};
+use block::OpenBlock;
 use executive::Executed;
 use error::{ExecutionError};
 use trace::LocalizedTrace;
@@ -105,7 +106,7 @@ impl TestBlockChainClient {
 			execution_result: RwLock::new(None),
 			receipts: RwLock::new(HashMap::new()),
 			queue_size: AtomicUsize::new(0),
-			miner: Arc::new(Miner::default()),
+			miner: Arc::new(Miner::with_spec(Spec::new_test())),
 		};
 		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
 		client.genesis_hash = client.last_hash.read().unwrap().clone();
@@ -187,7 +188,7 @@ impl TestBlockChainClient {
 					txs.append(&signed_tx);
 					txs.out()
 				},
-				_ => rlp::NULL_RLP.to_vec()
+				_ => rlp::EMPTY_LIST_RLP.to_vec()
 			};
 
 			let mut rlp = RlpStream::new_list(3);
@@ -240,12 +241,7 @@ impl TestBlockChainClient {
 }
 
 impl MiningBlockChainClient for TestBlockChainClient {
-	fn try_seal(&self, block: LockedBlock, _seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock> {
-		Err(block)
-	}
-
-
-	fn prepare_open_block(&self, _author: Address, _gas_floor_target: U256, _extra_data: Bytes) -> OpenBlock {
+	fn prepare_open_block(&self, _author: Address, _gas_range_target: (U256, U256), _extra_data: Bytes) -> OpenBlock {
 		unimplemented!();
 	}
 }
@@ -495,11 +491,17 @@ impl BlockChainClient for TestBlockChainClient {
 			balance: balances[a],
 		};
 
-		self.miner.import_transactions(transactions, &fetch_account)
+		self.miner.import_transactions(self, transactions, &fetch_account)
 	}
 
-	fn all_transactions(&self) -> Vec<SignedTransaction> {
-		self.miner.all_transactions()
+	fn queue_transactions(&self, transactions: Vec<Bytes>) {
+		// import right here
+		let tx = transactions.into_iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
+		self.import_transactions(tx);
+	}
+
+	fn pending_transactions(&self) -> Vec<SignedTransaction> {
+		self.miner.pending_transactions()
 	}
 
 	fn take_snapshot(&self, _root_dir: &Path) {

ethcore/src/engine.rs

@@ -17,7 +17,7 @@
 //! Consensus engine specification
 
 use common::*;
-use util::keys::store::AccountProvider;
+use account_provider::AccountProvider;
 use block::ExecutedBlock;
 use spec::CommonParams;
 use evm::Schedule;
@@ -96,7 +96,7 @@ pub trait Engine : Sync + Send {
 
 	/// Don't forget to call Super::populate_from_parent when subclassing & overriding.
 	// TODO: consider including State in the params.
-	fn populate_from_parent(&self, header: &mut Header, parent: &Header, _gas_floor_target: U256) {
+	fn populate_from_parent(&self, header: &mut Header, parent: &Header, _gas_floor_target: U256, _gas_ceil_target: U256) {
 		header.difficulty = parent.difficulty;
 		header.gas_limit = parent.gas_limit;
 		header.note_dirty();

ethcore/src/env_info.rs

@@ -39,6 +39,9 @@ pub struct EnvInfo {
 	pub last_hashes: LastHashes,
 	/// The gas used.
 	pub gas_used: U256,
+
+	/// Block gas limit at DAO rescue block SOFT_FORK_BLOCK or None if not yet there.
+	pub dao_rescue_block_gas_limit: Option<U256>,
 }
 
 impl Default for EnvInfo {
@@ -51,6 +54,7 @@ impl Default for EnvInfo {
 			gas_limit: 0.into(),
 			last_hashes: vec![],
 			gas_used: 0.into(),
+			dao_rescue_block_gas_limit: None,
 		}
 	}
 }
@@ -66,6 +70,7 @@ impl From<ethjson::vm::Env> for EnvInfo {
 			timestamp: e.timestamp.into(),
 			last_hashes: (1..cmp::min(number + 1, 257)).map(|i| format!("{}", number - i).as_bytes().sha3()).collect(),
 			gas_used: U256::zero(),
+			dao_rescue_block_gas_limit: None,
 		}
 	}
 }

ethcore/src/error.rs

@@ -58,6 +58,8 @@ pub enum TransactionError {
 	},
 	/// Transaction's gas limit (aka gas) is invalid.
 	InvalidGasLimit(OutOfBounds<U256>),
+	/// Transaction is invalid for some other reason.
+	DAORescue,
 }
 
 impl fmt::Display for TransactionError {
@@ -76,6 +78,7 @@ impl fmt::Display for TransactionError {
 			GasLimitExceeded { limit, got } =>
 				format!("Gas limit exceeded. Limit={}, Given={}", limit, got),
 			InvalidGasLimit(ref err) => format!("Invalid gas limit. {}", err),
+			DAORescue => "Transaction is invalid due to the DAO rescue.".into(),
 		};
 
 		f.write_fmt(format_args!("Transaction error ({})", msg))

ethcore/src/ethereum/ethash.rs

@@ -41,6 +41,8 @@ pub struct EthashParams {
 	pub registrar: Address,
 	/// Homestead transition block number.
 	pub frontier_compatibility_mode_limit: u64,
+	/// Enable the soft-fork logic.
+	pub dao_rescue_soft_fork: bool,
 }
 
 impl From<ethjson::spec::EthashParams> for EthashParams {
@@ -53,6 +55,7 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
 			block_reward: p.block_reward.into(),
 			registrar: p.registrar.into(),
 			frontier_compatibility_mode_limit: p.frontier_compatibility_mode_limit.into(),
+			dao_rescue_soft_fork: p.dao_rescue_soft_fork.into(),
 		}
 	}
 }
@@ -101,19 +104,28 @@ impl Engine for Ethash {
 		if env_info.number < self.ethash_params.frontier_compatibility_mode_limit {
 			Schedule::new_frontier()
 		} else {
-			Schedule::new_homestead()
+			let mut s = Schedule::new_homestead();
+			if self.ethash_params.dao_rescue_soft_fork {
+				s.reject_dao_transactions = env_info.dao_rescue_block_gas_limit.map_or(false, |x| x <= 4_000_000.into());
+			}
+			s
 		}
 	}
 
-	fn populate_from_parent(&self, header: &mut Header, parent: &Header, gas_floor_target: U256) {
+	fn populate_from_parent(&self, header: &mut Header, parent: &Header, gas_floor_target: U256, gas_ceil_target: U256) {
 		header.difficulty = self.calculate_difficuty(header, parent);
 		header.gas_limit = {
 			let gas_limit = parent.gas_limit;
 			let bound_divisor = self.ethash_params.gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
 				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+			} else if gas_limit > gas_ceil_target {
+				max(gas_ceil_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into() + (header.gas_used * 6.into() / 5.into()) / bound_divisor)
+				min(gas_ceil_target,
+					max(gas_floor_target,
+						gas_limit - gas_limit / bound_divisor + 1.into() +
+							(header.gas_used * 6.into() / 5.into()) / bound_divisor))
 			}
 		};
 		header.note_dirty();
@@ -230,8 +242,7 @@ impl Ethash {
 		let mut target = if header.number < frontier_limit {
 			if header.timestamp >= parent.timestamp + duration_limit {
 				parent.difficulty - (parent.difficulty / difficulty_bound_divisor)
-			}
-			else {
+			} else {
 				parent.difficulty + (parent.difficulty / difficulty_bound_divisor)
 			}
 		}
@@ -255,12 +266,21 @@ impl Ethash {
 
 	/// Convert an Ethash boundary to its original difficulty. Basically just `f(x) = 2^256 / x`.
 	pub fn boundary_to_difficulty(boundary: &H256) -> U256 {
-		U256::from((U512::one() << 256) / U256::from(boundary.as_slice()).into())
+		let d = U256::from(*boundary);
+		if d <= U256::one() {
+			U256::max_value()
+		} else {
+			((U256::one() << 255) / d) << 1
+		}
 	}
 
 	/// Convert an Ethash difficulty to the target boundary. Basically just `f(x) = 2^256 / x`.
 	pub fn difficulty_to_boundary(difficulty: &U256) -> H256 {
-		U256::from((U512::one() << 256) / difficulty.into()).into()
+		if *difficulty <= U256::one() {
+			U256::max_value().into()
+		} else {
+			(((U256::one() << 255) / *difficulty) << 1).into()
+		}
 	}
 
 	fn to_ethash(hash: H256) -> EH256 {
@@ -291,12 +311,11 @@ impl Header {
 
 #[cfg(test)]
 mod tests {
-	extern crate ethash;
-
 	use common::*;
 	use block::*;
 	use tests::helpers::*;
 	use super::super::new_morden;
+	use super::Ethash;
 
 	#[test]
 	fn on_close_block() {
@@ -308,7 +327,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, Address::zero(), 3141562.into(), vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let b = b.close();
 		assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244f40000").unwrap());
 	}
@@ -323,7 +342,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let mut b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, Address::zero(), 3141562.into(), vec![]).unwrap();
+		let mut b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let mut uncle = Header::new();
 		let uncle_author = address_from_hex("ef2d6d194084c2de36e0dabfce45d046b37d1106");
 		uncle.author = uncle_author.clone();
@@ -351,7 +370,8 @@ mod tests {
 			difficulty: 0.into(),
 			last_hashes: vec![],
 			gas_used: 0.into(),
-			gas_limit: 0.into()
+			gas_limit: 0.into(),
+			dao_rescue_block_gas_limit: None,
 		});
 
 		assert!(schedule.stack_limit > 0);
@@ -363,7 +383,8 @@ mod tests {
 			difficulty: 0.into(),
 			last_hashes: vec![],
 			gas_used: 0.into(),
-			gas_limit: 0.into()
+			gas_limit: 0.into(),
+			dao_rescue_block_gas_limit: None,
 		});
 
 		assert!(!schedule.have_delegate_call);
@@ -509,5 +530,15 @@ mod tests {
 		}
 	}
 
+	#[test]
+	fn test_difficulty_to_boundary() {
+		// result of f(0) is undefined, so do not assert the result
+		let _ = Ethash::difficulty_to_boundary(&U256::from(0));
+		assert_eq!(Ethash::difficulty_to_boundary(&U256::from(1)), H256::from(U256::max_value()));
+		assert_eq!(Ethash::difficulty_to_boundary(&U256::from(2)), H256::from_str("8000000000000000000000000000000000000000000000000000000000000000").unwrap());
+		assert_eq!(Ethash::difficulty_to_boundary(&U256::from(4)), H256::from_str("4000000000000000000000000000000000000000000000000000000000000000").unwrap());
+		assert_eq!(Ethash::difficulty_to_boundary(&U256::from(32)), H256::from_str("0800000000000000000000000000000000000000000000000000000000000000").unwrap());
+	}
+
 	// TODO: difficulty test
 }

ethcore/src/ethereum/mod.rs

@@ -33,7 +33,12 @@ use super::spec::*;
 pub fn new_olympic() -> Spec { Spec::load(include_bytes!("../../res/ethereum/olympic.json")) }
 
 /// Create a new Frontier mainnet chain spec.
-pub fn new_frontier() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier.json")) }
+pub fn new_frontier(dao_rescue: bool) -> Spec {
+	Spec::load(match dao_rescue {
+		true => include_bytes!("../../res/ethereum/frontier_dao_rescue.json"),
+		false => include_bytes!("../../res/ethereum/frontier.json"),
+	})
+}
 
 /// Create a new Frontier chain spec as though it never changes to Homestead.
 pub fn new_frontier_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier_test.json")) }
@@ -84,7 +89,7 @@ mod tests {
 
 	#[test]
 	fn frontier() {
-		let frontier = new_frontier();
+		let frontier = new_frontier(true);
 
 		assert_eq!(frontier.state_root(), H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap());
 		let genesis = frontier.genesis_block();

ethcore/src/evm/jit.rs

@@ -16,9 +16,8 @@
 
 //! Just in time compiler execution environment.
 use common::*;
-use trace::VMTracer;
 use evmjit;
-use evm::{self, Error, GasLeft};
+use evm::{self, GasLeft};
 
 /// Should be used to convert jit types to ethcore
 trait FromJit<T>: Sized {
@@ -303,7 +302,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 
 #[derive(Default)]
 pub struct JitEvm {
-	ctxt: Option<evmjit::ContextHandle>,
+	context: Option<evmjit::ContextHandle>,
 }
 
 impl evm::Evm for JitEvm {
@@ -347,7 +346,7 @@ impl evm::Evm for JitEvm {
 		data.timestamp = ext.env_info().timestamp as i64;
 
 		self.context = Some(unsafe { evmjit::ContextHandle::new(data, schedule, &mut ext_handle) });
-		let context = self.context.as_ref_mut().unwrap();
+		let mut context = self.context.as_mut().unwrap();
 		let res = context.exec();
 
 		match res {

ethcore/src/evm/schedule.rs

@@ -80,6 +80,8 @@ pub struct Schedule {
 	pub tx_data_non_zero_gas: usize,
 	/// Gas price for copying memory
 	pub copy_gas: usize,
+	/// DAO Rescue softfork block
+	pub reject_dao_transactions: bool,
 }
 
 impl Schedule {
@@ -126,6 +128,7 @@ impl Schedule {
 			tx_data_zero_gas: 4,
 			tx_data_non_zero_gas: 68,
 			copy_gas: 3,	
+			reject_dao_transactions: false,
 		}
 	}
 }

ethcore/src/externalities.rs

@@ -318,7 +318,8 @@ mod tests {
 			difficulty: 0.into(),
 			last_hashes: vec![],
 			gas_used: 0.into(),
-			gas_limit: 0.into()
+			gas_limit: 0.into(),
+			dao_rescue_block_gas_limit: None,
 		}
 	}
 

ethcore/src/json_tests/chain.rs

@@ -22,6 +22,7 @@ use tests::helpers::*;
 use devtools::*;
 use spec::Genesis;
 use ethjson;
+use ethjson::blockchain::BlockChain;
 use miner::Miner;
 
 pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
@@ -41,20 +42,28 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 
 			flush!("   - {}...", name);
 
-			let mut spec = match era {
-				ChainEra::Frontier => ethereum::new_frontier_test(),
-				ChainEra::Homestead => ethereum::new_homestead_test(),
+			let spec = |blockchain: &BlockChain| {
+				let genesis = Genesis::from(blockchain.genesis());
+				let state = From::from(blockchain.pre_state.clone());
+				let mut spec = match era {
+					ChainEra::Frontier => ethereum::new_frontier_test(),
+					ChainEra::Homestead => ethereum::new_homestead_test(),
+				};
+				spec.set_genesis_state(state);
+				spec.overwrite_genesis_params(genesis);
+				assert!(spec.is_state_root_valid());
+				spec
 			};
 
-			let genesis = Genesis::from(blockchain.genesis());
-			let state = From::from(blockchain.pre_state.clone());
-			spec.set_genesis_state(state);
-			spec.overwrite_genesis_params(genesis);
-			assert!(spec.is_state_root_valid());
-
 			let temp = RandomTempPath::new();
 			{
-				let client = Client::new(ClientConfig::default(), spec, temp.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
+				let client = Client::new(
+					ClientConfig::default(),
+					spec(&blockchain),
+					temp.as_path(),
+					Arc::new(Miner::with_spec(spec(&blockchain))),
+					IoChannel::disconnected()
+				).unwrap();
 				for b in &blockchain.blocks_rlp() {
 					if Block::is_good(&b) {
 						let _ = client.import_block(b.clone());

ethcore/src/lib.rs

@@ -91,10 +91,12 @@ extern crate ethjson;
 extern crate bloomchain;
 #[macro_use] extern crate ethcore_ipc as ipc;
 extern crate rayon;
+pub extern crate ethstore;
 
 #[cfg(test)] extern crate ethcore_devtools as devtools;
 #[cfg(feature = "jit" )] extern crate evmjit;
 
+pub mod account_provider;
 pub mod basic_authority;
 pub mod block;
 pub mod block_queue;
@@ -141,4 +143,4 @@ mod json_tests;
 
 pub use types::*;
 pub use evm::get_info;
-pub use executive::contract_address;
+pub use executive::contract_address;

ethcore/src/miner/miner.rs

@@ -18,7 +18,7 @@ use rayon::prelude::*;
 use std::sync::atomic::AtomicBool;
 
 use util::*;
-use util::keys::store::{AccountProvider};
+use account_provider::AccountProvider;
 use views::{BlockView, HeaderView};
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockID, CallAnalytics};
 use block::{ClosedBlock, IsBlock};
@@ -29,16 +29,59 @@ use spec::Spec;
 use engine::Engine;
 use miner::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
 
+/// Different possible definitions for pending transaction set.
+#[derive(Debug)]
+pub enum PendingSet {
+	/// Always just the transactions in the queue. These have had only cheap checks.
+	AlwaysQueue,
+	/// Always just the transactions in the sealing block. These have had full checks but
+	/// may be empty if the node is not actively mining or has force_sealing enabled.
+	AlwaysSealing,
+	/// Try the sealing block, but if it is not currently sealing, fallback to the queue.
+	SealingOrElseQueue,
+}
+
+/// Configures the behaviour of the miner.
+#[derive(Debug)]
+pub struct MinerOptions {
+	/// Force the miner to reseal, even when nobody has asked for work.
+	pub force_sealing: bool,
+	/// Reseal on receipt of new external transactions.
+	pub reseal_on_external_tx: bool,
+	/// Reseal on receipt of new local transactions.
+	pub reseal_on_own_tx: bool,
+	/// Maximum amount of gas to bother considering for block insertion.
+	pub tx_gas_limit: U256,
+	/// Maximum size of the transaction queue.
+	pub tx_queue_size: usize,
+	/// Whether we should fallback to providing all the queue's transactions or just pending.
+	pub pending_set: PendingSet,
+}
+
+impl Default for MinerOptions {
+	fn default() -> Self {
+		MinerOptions {
+			force_sealing: false,
+			reseal_on_external_tx: true,
+			reseal_on_own_tx: true,
+			tx_gas_limit: !U256::zero(),
+			tx_queue_size: 1024,
+			pending_set: PendingSet::AlwaysQueue,
+		}
+	}
+}
+
 /// Keeps track of transactions using priority queue and holds currently mined block.
 pub struct Miner {
+	// NOTE [ToDr]  When locking always lock in this order!
 	transaction_queue: Mutex<TransactionQueue>,
+	sealing_work: Mutex<UsingQueue<ClosedBlock>>,
 
 	// for sealing...
-	force_sealing: bool,
+	options: MinerOptions,
 	sealing_enabled: AtomicBool,
 	sealing_block_last_request: Mutex<u64>,
-	sealing_work: Mutex<UsingQueue<ClosedBlock>>,
-	gas_floor_target: RwLock<U256>,
+	gas_range_target: RwLock<(U256, U256)>,
 	author: RwLock<Address>,
 	extra_data: RwLock<Bytes>,
 	spec: Spec,
@@ -46,52 +89,35 @@ pub struct Miner {
 	accounts: Option<Arc<AccountProvider>>,
 }
 
-impl Default for Miner {
-	fn default() -> Miner {
+impl Miner {
+	/// Creates new instance of miner without accounts, but with given spec.
+	pub fn with_spec(spec: Spec) -> Miner {
 		Miner {
 			transaction_queue: Mutex::new(TransactionQueue::new()),
-			force_sealing: false,
+			options: Default::default(),
 			sealing_enabled: AtomicBool::new(false),
 			sealing_block_last_request: Mutex::new(0),
 			sealing_work: Mutex::new(UsingQueue::new(5)),
-			gas_floor_target: RwLock::new(U256::zero()),
-			author: RwLock::new(Address::default()),
-			extra_data: RwLock::new(Vec::new()),
-			accounts: None,
-			spec: Spec::new_test(),
-		}
-	}
-}
-
-impl Miner {
-	/// Creates new instance of miner
-	pub fn new(force_sealing: bool, spec: Spec) -> Arc<Miner> {
-		Arc::new(Miner {
-			transaction_queue: Mutex::new(TransactionQueue::new()),
-			force_sealing: force_sealing,
-			sealing_enabled: AtomicBool::new(force_sealing),
-			sealing_block_last_request: Mutex::new(0),
-			sealing_work: Mutex::new(UsingQueue::new(5)),
-			gas_floor_target: RwLock::new(U256::zero()),
+			gas_range_target: RwLock::new((U256::zero(), U256::zero())),
 			author: RwLock::new(Address::default()),
 			extra_data: RwLock::new(Vec::new()),
 			accounts: None,
 			spec: spec,
-		})
+		}
 	}
 
 	/// Creates new instance of miner
-	pub fn with_accounts(force_sealing: bool, spec: Spec, accounts: Arc<AccountProvider>) -> Arc<Miner> {
+	pub fn new(options: MinerOptions, spec: Spec, accounts: Option<Arc<AccountProvider>>) -> Arc<Miner> {
 		Arc::new(Miner {
-			transaction_queue: Mutex::new(TransactionQueue::new()),
-			force_sealing: force_sealing,
-			sealing_enabled: AtomicBool::new(force_sealing),
+			transaction_queue: Mutex::new(TransactionQueue::with_limits(options.tx_queue_size, options.tx_gas_limit)),
+			sealing_enabled: AtomicBool::new(options.force_sealing),
+			options: options,
 			sealing_block_last_request: Mutex::new(0),
 			sealing_work: Mutex::new(UsingQueue::new(5)),
-			gas_floor_target: RwLock::new(U256::zero()),
+			gas_range_target: RwLock::new((U256::zero(), U256::zero())),
 			author: RwLock::new(Address::default()),
 			extra_data: RwLock::new(Vec::new()),
-			accounts: Some(accounts),
+			accounts: accounts,
 			spec: spec,
 		})
 	}
@@ -105,34 +131,37 @@ impl Miner {
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn prepare_sealing(&self, chain: &MiningBlockChainClient) {
 		trace!(target: "miner", "prepare_sealing: entering");
-		let transactions = self.transaction_queue.lock().unwrap().top_transactions();
-		let mut sealing_work = self.sealing_work.lock().unwrap();
-		let best_hash = chain.best_block_header().sha3();
 
+		let (transactions, mut open_block) = {
+			let transactions = {self.transaction_queue.lock().unwrap().top_transactions()};
+			let mut sealing_work = self.sealing_work.lock().unwrap();
+			let best_hash = chain.best_block_header().sha3();
 /*
-		// check to see if last ClosedBlock in would_seals is actually same parent block.
-		// if so
-		//   duplicate, re-open and push any new transactions.
-		//   if at least one was pushed successfully, close and enqueue new ClosedBlock;
-		//   otherwise, leave everything alone.
-		// otherwise, author a fresh block.
+			// check to see if last ClosedBlock in would_seals is actually same parent block.
+			// if so
+			//   duplicate, re-open and push any new transactions.
+			//   if at least one was pushed successfully, close and enqueue new ClosedBlock;
+			//   otherwise, leave everything alone.
+			// otherwise, author a fresh block.
 */
-		let mut open_block = match sealing_work.pop_if(|b| b.block().fields().header.parent_hash() == &best_hash) {
-			Some(old_block) => {
-				trace!(target: "miner", "Already have previous work; updating and returning");
-				// add transactions to old_block
-				let e = self.engine();
-				old_block.reopen(e, chain.vm_factory())
-			}
-			None => {
-				// block not found - create it.
-				trace!(target: "miner", "No existing work - making new block");
-				chain.prepare_open_block(
-					self.author(),
-					self.gas_floor_target(),
-					self.extra_data()
-				)
-			}
+			let open_block = match sealing_work.pop_if(|b| b.block().fields().header.parent_hash() == &best_hash) {
+				Some(old_block) => {
+					trace!(target: "miner", "Already have previous work; updating and returning");
+					// add transactions to old_block
+					let e = self.engine();
+					old_block.reopen(e, chain.vm_factory())
+				}
+				None => {
+					// block not found - create it.
+					trace!(target: "miner", "No existing work - making new block");
+					chain.prepare_open_block(
+						self.author(),
+						(self.gas_floor_target(), self.gas_ceil_target()),
+						self.extra_data()
+					)
+				}
+			};
+			(transactions, open_block)
 		};
 
 		let mut invalid_transactions = HashSet::new();
@@ -162,14 +191,16 @@ impl Miner {
 
 		let block = open_block.close();
 
-		let mut queue = self.transaction_queue.lock().unwrap();
 		let fetch_account = |a: &Address| AccountDetails {
 			nonce: chain.latest_nonce(a),
 			balance: chain.latest_balance(a),
 		};
 
-		for hash in invalid_transactions.into_iter() {
-			queue.remove_invalid(&hash, &fetch_account);
+		{
+			let mut queue = self.transaction_queue.lock().unwrap();
+			for hash in invalid_transactions.into_iter() {
+				queue.remove_invalid(&hash, &fetch_account);
+			}
 		}
 
 		if !block.transactions().is_empty() {
@@ -181,7 +212,7 @@ impl Miner {
 			});
 			if let Some(seal) = s {
 				trace!(target: "miner", "prepare_sealing: managed internal seal. importing...");
-				if let Ok(sealed) = chain.try_seal(block.lock(), seal) {
+				if let Ok(sealed) = block.lock().try_seal(self.engine(), seal) {
 					if let Ok(_) = chain.import_block(sealed.rlp_bytes()) {
 						trace!(target: "miner", "prepare_sealing: sealed internally and imported. leaving.");
 					} else {
@@ -195,6 +226,8 @@ impl Miner {
 				trace!(target: "miner", "prepare_sealing: unable to generate seal internally");
 			}
 		}
+
+		let mut sealing_work = self.sealing_work.lock().unwrap();
 		if sealing_work.peek_last_ref().map_or(true, |pb| pb.block().fields().header.hash() != block.block().fields().header.hash()) {
 			trace!(target: "miner", "Pushing a new, refreshed or borrowed pending {}...", block.block().fields().header.hash());
 			sealing_work.push(block);
@@ -266,6 +299,7 @@ impl MinerService for Miner {
 					last_hashes: last_hashes,
 					gas_used: U256::zero(),
 					gas_limit: U256::max_value(),
+					dao_rescue_block_gas_limit: chain.dao_rescue_block_gas_limit(header.parent_hash().clone()),
 				};
 				// that's just a copy of the state.
 				let mut state = block.state().clone();
@@ -332,7 +366,11 @@ impl MinerService for Miner {
 
 	/// Set the gas limit we wish to target when sealing a new block.
 	fn set_gas_floor_target(&self, target: U256) {
-		*self.gas_floor_target.write().unwrap() = target;
+		self.gas_range_target.write().unwrap().0 = target;
+	}
+
+	fn set_gas_ceil_target(&self, target: U256) {
+		self.gas_range_target.write().unwrap().1 = target;
 	}
 
 	fn set_minimal_gas_price(&self, min_gas_price: U256) {
@@ -349,7 +387,7 @@ impl MinerService for Miner {
 	}
 
 	fn sensible_gas_limit(&self) -> U256 {
-		*self.gas_floor_target.read().unwrap() / 5.into()
+		self.gas_range_target.read().unwrap().0 / 5.into()
 	}
 
 	fn transactions_limit(&self) -> usize {
@@ -360,6 +398,10 @@ impl MinerService for Miner {
 		self.transaction_queue.lock().unwrap().set_limit(limit)
 	}
 
+	fn set_tx_gas_limit(&self, limit: U256) {
+		self.transaction_queue.lock().unwrap().set_tx_gas_limit(limit)
+	}
+
 	/// Get the author that we will seal blocks as.
 	fn author(&self) -> Address {
 		*self.author.read().unwrap()
@@ -372,21 +414,36 @@ impl MinerService for Miner {
 
 	/// Get the gas limit we wish to target when sealing a new block.
 	fn gas_floor_target(&self) -> U256 {
-		*self.gas_floor_target.read().unwrap()
+		self.gas_range_target.read().unwrap().0
 	}
 
-	fn import_transactions<T>(&self, transactions: Vec<SignedTransaction>, fetch_account: T) ->
+	/// Get the gas limit we wish to target when sealing a new block.
+	fn gas_ceil_target(&self) -> U256 {
+		self.gas_range_target.read().unwrap().1
+	}
+
+	fn import_transactions<T>(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>, fetch_account: T) ->
 		Vec<Result<TransactionImportResult, Error>>
 		where T: Fn(&Address) -> AccountDetails {
-		let mut transaction_queue = self.transaction_queue.lock().unwrap();
-		transactions.into_iter()
-			.map(|tx| transaction_queue.add(tx, &fetch_account, TransactionOrigin::External))
-			.collect()
+		let results: Vec<Result<TransactionImportResult, Error>> = {
+			let mut transaction_queue = self.transaction_queue.lock().unwrap();
+			transactions.into_iter()
+				.map(|tx| transaction_queue.add(tx, &fetch_account, TransactionOrigin::External))
+				.collect()
+		};
+		if !results.is_empty() && self.options.reseal_on_external_tx {
+			self.update_sealing(chain);
+		}
+		results
 	}
 
-	fn import_own_transaction<T>(&self, chain: &MiningBlockChainClient, transaction: SignedTransaction, fetch_account: T) ->
-		Result<TransactionImportResult, Error>
-		where T: Fn(&Address) -> AccountDetails {
+	fn import_own_transaction<T>(
+		&self,
+		chain: &MiningBlockChainClient,
+		transaction: SignedTransaction,
+		fetch_account: T
+	) -> Result<TransactionImportResult, Error> where T: Fn(&Address) -> AccountDetails {
+
 		let hash = transaction.hash();
 		trace!(target: "own_tx", "Importing transaction: {:?}", transaction);
 
@@ -409,7 +466,7 @@ impl MinerService for Miner {
 			import
 		};
 
-		if imported.is_ok() {
+		if imported.is_ok() && self.options.reseal_on_own_tx {
 			// Make sure to do it after transaction is imported and lock is droped.
 			// We need to create pending block and enable sealing
 			let prepared = self.enable_and_prepare_sealing(chain);
@@ -423,39 +480,48 @@ impl MinerService for Miner {
 		imported
 	}
 
-	fn pending_transactions_hashes(&self) -> Vec<H256> {
-		match (self.sealing_enabled.load(atomic::Ordering::Relaxed), self.sealing_work.lock().unwrap().peek_last_ref()) {
-			(true, Some(pending)) => pending.transactions().iter().map(|t| t.hash()).collect(),
-			_ => {
-				let queue = self.transaction_queue.lock().unwrap();
-				queue.pending_hashes()
-			}
-		}
-	}
-
-	fn transaction(&self, hash: &H256) -> Option<SignedTransaction> {
-		match (self.sealing_enabled.load(atomic::Ordering::Relaxed), self.sealing_work.lock().unwrap().peek_last_ref()) {
-			(true, Some(pending)) => pending.transactions().iter().find(|t| &t.hash() == hash).cloned(),
-			_ => {
-				let queue = self.transaction_queue.lock().unwrap();
-				queue.find(hash)
-			}
-		}
-	}
-
 	fn all_transactions(&self) -> Vec<SignedTransaction> {
 		let queue = self.transaction_queue.lock().unwrap();
 		queue.top_transactions()
 	}
 
 	fn pending_transactions(&self) -> Vec<SignedTransaction> {
+		let queue = self.transaction_queue.lock().unwrap();
+		let sw = self.sealing_work.lock().unwrap();
 		// TODO: should only use the sealing_work when it's current (it could be an old block)
-		match (self.sealing_enabled.load(atomic::Ordering::Relaxed), self.sealing_work.lock().unwrap().peek_last_ref()) {
-			(true, Some(pending)) => pending.transactions().clone(),
-			_ => {
-				let queue = self.transaction_queue.lock().unwrap();
-				queue.top_transactions()
-			}
+		let sealing_set = match self.sealing_enabled.load(atomic::Ordering::Relaxed) {
+			true => sw.peek_last_ref(),
+			false => None,
+		};
+		match (&self.options.pending_set, sealing_set) {
+			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.top_transactions(),
+			(_, sealing) => sealing.map_or_else(Vec::new, |s| s.transactions().clone()),
+		}
+	}
+
+	fn pending_transactions_hashes(&self) -> Vec<H256> {
+		let queue = self.transaction_queue.lock().unwrap();
+		let sw = self.sealing_work.lock().unwrap();
+		let sealing_set = match self.sealing_enabled.load(atomic::Ordering::Relaxed) {
+			true => sw.peek_last_ref(),
+			false => None,
+		};
+		match (&self.options.pending_set, sealing_set) {
+			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.pending_hashes(),
+			(_, sealing) => sealing.map_or_else(Vec::new, |s| s.transactions().iter().map(|t| t.hash()).collect()),
+		}
+	}
+
+	fn transaction(&self, hash: &H256) -> Option<SignedTransaction> {
+		let queue = self.transaction_queue.lock().unwrap();
+		let sw = self.sealing_work.lock().unwrap();
+		let sealing_set = match self.sealing_enabled.load(atomic::Ordering::Relaxed) {
+			true => sw.peek_last_ref(),
+			false => None,
+		};
+		match (&self.options.pending_set, sealing_set) {
+			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.find(hash),
+			(_, sealing) => sealing.and_then(|s| s.transactions().iter().find(|t| &t.hash() == hash).cloned()),
 		}
 	}
 
@@ -483,7 +549,7 @@ impl MinerService for Miner {
 			let current_no = chain.chain_info().best_block_number;
 			let has_local_transactions = self.transaction_queue.lock().unwrap().has_local_pending_transactions();
 			let last_request = *self.sealing_block_last_request.lock().unwrap();
-			let should_disable_sealing = !self.force_sealing
+			let should_disable_sealing = !self.options.force_sealing
 				&& !has_local_transactions
 				&& current_no > last_request
 				&& current_no - last_request > SEALING_TIMEOUT_IN_BLOCKS;
@@ -492,7 +558,7 @@ impl MinerService for Miner {
 				trace!(target: "miner", "Miner sleeping (current {}, last {})", current_no, last_request);
 				self.sealing_enabled.store(false, atomic::Ordering::Relaxed);
 				self.sealing_work.lock().unwrap().reset();
-			} else if self.sealing_enabled.load(atomic::Ordering::Relaxed) {
+			} else {
 				self.prepare_sealing(chain);
 			}
 		}
@@ -510,7 +576,7 @@ impl MinerService for Miner {
 
 	fn submit_seal(&self, chain: &MiningBlockChainClient, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error> {
 		if let Some(b) = self.sealing_work.lock().unwrap().take_used_if(|b| &b.hash() == &pow_hash) {
-			match chain.try_seal(b.lock(), seal) {
+			match b.lock().try_seal(self.engine(), seal) {
 				Err(_) => {
 					info!(target: "miner", "Mined block rejected, PoW was invalid.");
 					Err(Error::PowInvalid)
@@ -559,7 +625,7 @@ impl MinerService for Miner {
 				for tx in &txs {
 					let _sender = tx.sender();
 				}
-				let _ = self.import_transactions(txs, |a| AccountDetails {
+				let _ = self.import_transactions(chain, txs, |a| AccountDetails {
 					nonce: chain.latest_nonce(a),
 					balance: chain.latest_balance(a),
 				});
@@ -598,6 +664,7 @@ mod tests {
 	use util::*;
 	use client::{TestBlockChainClient, EachBlockWith};
 	use block::*;
+	use spec::Spec;
 
 	// TODO [ToDr] To uncomment` when TestBlockChainClient can actually return a ClosedBlock.
 	#[ignore]
@@ -605,7 +672,7 @@ mod tests {
 	fn should_prepare_block_to_seal() {
 		// given
 		let client = TestBlockChainClient::default();
-		let miner = Miner::default();
+		let miner = Miner::with_spec(Spec::new_test());
 
 		// when
 		let sealing_work = miner.map_sealing_work(&client, |_| ());
@@ -617,7 +684,7 @@ mod tests {
 	fn should_still_work_after_a_couple_of_blocks() {
 		// given
 		let client = TestBlockChainClient::default();
-		let miner = Miner::default();
+		let miner = Miner::with_spec(Spec::new_test());
 
 		let res = miner.map_sealing_work(&client, |b| b.block().fields().header.hash());
 		assert!(res.is_some());

ethcore/src/miner/mod.rs

@@ -28,11 +28,12 @@
 //! extern crate ethcore;
 //! use std::env;
 //! use util::network::{NetworkService, NetworkConfiguration};
+//! use ethcore::ethereum;
 //! use ethcore::client::{Client, ClientConfig};
 //! use ethcore::miner::{Miner, MinerService};
 //!
 //! fn main() {
-//!		let miner: Miner = Miner::default();
+//!		let miner: Miner = Miner::with_spec(ethereum::new_frontier(true));
 //!		// get status
 //!		assert_eq!(miner.status().transactions_in_pending_queue, 0);
 //!
@@ -46,7 +47,7 @@ mod external;
 mod transaction_queue;
 
 pub use self::transaction_queue::{TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
-pub use self::miner::{Miner};
+pub use self::miner::{Miner, MinerOptions, PendingSet};
 pub use self::external::{ExternalMiner, ExternalMinerService};
 
 use std::collections::BTreeMap;
@@ -81,20 +82,30 @@ pub trait MinerService : Send + Sync {
 	/// Set minimal gas price of transaction to be accepted for mining.
 	fn set_minimal_gas_price(&self, min_gas_price: U256);
 
-	/// Get the gas limit we wish to target when sealing a new block.
+	/// Get the lower bound of the gas limit we wish to target when sealing a new block.
 	fn gas_floor_target(&self) -> U256;
 
-	/// Set the gas limit we wish to target when sealing a new block.
+	/// Get the upper bound of the gas limit we wish to target when sealing a new block.
+	fn gas_ceil_target(&self) -> U256;
+
+	// TODO: coalesce into single set_range function.
+	/// Set the lower bound of gas limit we wish to target when sealing a new block.
 	fn set_gas_floor_target(&self, target: U256);
 
+	/// Set the upper bound of gas limit we wish to target when sealing a new block.
+	fn set_gas_ceil_target(&self, target: U256);
+
 	/// Get current transactions limit in queue.
 	fn transactions_limit(&self) -> usize;
 
 	/// Set maximal number of transactions kept in the queue (both current and future).
 	fn set_transactions_limit(&self, limit: usize);
 
+	/// Set maximum amount of gas allowed for any single transaction to mine.
+	fn set_tx_gas_limit(&self, limit: U256);
+
 	/// Imports transactions to transaction queue.
-	fn import_transactions<T>(&self, transactions: Vec<SignedTransaction>, fetch_account: T) ->
+	fn import_transactions<T>(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>, fetch_account: T) ->
 		Vec<Result<TransactionImportResult, Error>>
 		where T: Fn(&Address) -> AccountDetails, Self: Sized;
 

ethcore/src/miner/transaction_queue.rs

@@ -167,16 +167,17 @@ impl PartialOrd for TransactionOrder {
 
 impl Ord for TransactionOrder {
 	fn cmp(&self, b: &TransactionOrder) -> Ordering {
-		// Local transactions should always have priority
-		if self.origin != b.origin {
-			return self.origin.cmp(&b.origin);
-		}
-
 		// First check nonce_height
 		if self.nonce_height != b.nonce_height {
 			return self.nonce_height.cmp(&b.nonce_height);
 		}
 
+		// Local transactions should always have priority
+		// NOTE nonce has to be checked first, cause otherwise the order might be wrong.
+		if self.origin != b.origin {
+			return self.origin.cmp(&b.origin);
+		}
+
 		// Then compare gas_prices
 		let a_gas = self.gas_price;
 		let b_gas = b.gas_price;
@@ -235,22 +236,22 @@ impl TransactionSet {
 		self.by_priority.insert(order.clone());
 		let r = self.by_address.insert(sender, nonce, order);
 		// If transaction was replaced remove it from priority queue
-		if let Some(ref order) = r {
-			self.by_priority.remove(order);
+		if let Some(ref old_order) = r {
+			self.by_priority.remove(old_order);
 		}
+		assert_eq!(self.by_priority.len(), self.by_address.len());
 		r
 	}
 
 	/// Remove low priority transactions if there is more then specified by given `limit`.
 	///
 	/// It drops transactions from this set but also removes associated `VerifiedTransaction`.
-	/// Returns addresses and highes nonces of transactions removed because of limit.
+	/// Returns addresses and lowest nonces of transactions removed because of limit.
 	fn enforce_limit(&mut self, by_hash: &mut HashMap<H256, VerifiedTransaction>) -> Option<HashMap<Address, U256>> {
 		let len = self.by_priority.len();
 		if len <= self.limit {
 			return None;
 		}
-
 		let to_drop : Vec<(Address, U256)> = {
 			self.by_priority
 				.iter()
@@ -269,8 +270,8 @@ impl TransactionSet {
 				by_hash.remove(&order.hash)
 					.expect("Hash found in `by_priorty` matches the one dropped; so it is included in `by_hash`");
 
-				let max = removed.get(&sender).map_or(nonce, |val| cmp::max(*val, nonce));
-				removed.insert(sender, max);
+				let min = removed.get(&sender).map_or(nonce, |val| cmp::min(*val, nonce));
+				removed.insert(sender, min);
 				removed
 			}))
 	}
@@ -279,8 +280,10 @@ impl TransactionSet {
 	fn drop(&mut self, sender: &Address, nonce: &U256) -> Option<TransactionOrder> {
 		if let Some(tx_order) = self.by_address.remove(sender, nonce) {
 			self.by_priority.remove(&tx_order);
+			assert_eq!(self.by_priority.len(), self.by_address.len());
 			return Some(tx_order);
 		}
+		assert_eq!(self.by_priority.len(), self.by_address.len());
 		None
 	}
 
@@ -331,6 +334,8 @@ const GAS_LIMIT_HYSTERESIS: usize = 10; // %
 pub struct TransactionQueue {
 	/// Gas Price threshold for transactions that can be imported to this queue (defaults to 0)
 	minimal_gas_price: U256,
+	/// The maximum amount of gas any individual transaction may use.
+	tx_gas_limit: U256,
 	/// Current gas limit (block gas limit * factor). Transactions above the limit will not be accepted (default to !0)
 	gas_limit: U256,
 	/// Priority queue for transactions that can go to block
@@ -352,11 +357,11 @@ impl Default for TransactionQueue {
 impl TransactionQueue {
 	/// Creates new instance of this Queue
 	pub fn new() -> Self {
-		Self::with_limit(1024)
+		Self::with_limits(1024, !U256::zero())
 	}
 
 	/// Create new instance of this Queue with specified limits
-	pub fn with_limit(limit: usize) -> Self {
+	pub fn with_limits(limit: usize, tx_gas_limit: U256) -> Self {
 		let current = TransactionSet {
 			by_priority: BTreeSet::new(),
 			by_address: Table::new(),
@@ -371,6 +376,7 @@ impl TransactionQueue {
 
 		TransactionQueue {
 			minimal_gas_price: U256::zero(),
+			tx_gas_limit: tx_gas_limit,
 			gas_limit: !U256::zero(),
 			current: current,
 			future: future,
@@ -415,6 +421,12 @@ impl TransactionQueue {
 		};
 	}
 
+	/// Set the new limit for the amount of gas any individual transaction may have.
+	/// Any transaction already imported to the queue is not affected.
+	pub fn set_tx_gas_limit(&mut self, limit: U256) {
+		self.tx_gas_limit = limit;
+	}
+
 	/// Returns current status for this queue
 	pub fn status(&self) -> TransactionQueueStatus {
 		TransactionQueueStatus {
@@ -425,14 +437,16 @@ impl TransactionQueue {
 
 	/// Add signed transaction to queue to be verified and imported
 	pub fn add<T>(&mut self, tx: SignedTransaction, fetch_account: &T, origin: TransactionOrigin) -> Result<TransactionImportResult, Error>
-		where T: Fn(&Address) -> AccountDetails {
+	where T: Fn(&Address) -> AccountDetails {
 
 		trace!(target: "miner", "Importing: {:?}", tx.hash());
 
 		if tx.gas_price < self.minimal_gas_price {
 			trace!(target: "miner",
 				"Dropping transaction below minimal gas price threshold: {:?} (gp: {} < {})",
-				tx.hash(), tx.gas_price, self.minimal_gas_price
+				tx.hash(),
+				tx.gas_price,
+				self.minimal_gas_price
 			);
 
 			return Err(Error::Transaction(TransactionError::InsufficientGasPrice {
@@ -443,10 +457,13 @@ impl TransactionQueue {
 
 		try!(tx.check_low_s());
 
-		if tx.gas > self.gas_limit {
+		if tx.gas > self.gas_limit || tx.gas > self.tx_gas_limit {
 			trace!(target: "miner",
-				"Dropping transaction above gas limit: {:?} ({} > {})",
-				tx.hash(), tx.gas, self.gas_limit
+				"Dropping transaction above gas limit: {:?} ({} > min({}, {}))",
+				tx.hash(),
+				tx.gas,
+				self.gas_limit,
+				self.tx_gas_limit
 			);
 
 			return Err(Error::Transaction(TransactionError::GasLimitExceeded {
@@ -460,15 +477,22 @@ impl TransactionQueue {
 
 		let cost = vtx.transaction.value + vtx.transaction.gas_price * vtx.transaction.gas;
 		if client_account.balance < cost {
-			trace!(target: "miner", "Dropping transaction without sufficient balance: {:?} ({} < {})",
-				vtx.hash(), client_account.balance, cost);
+			trace!(target: "miner",
+				"Dropping transaction without sufficient balance: {:?} ({} < {})",
+				vtx.hash(),
+				client_account.balance,
+				cost
+			);
+
 			return Err(Error::Transaction(TransactionError::InsufficientBalance {
 				cost: cost,
 				balance: client_account.balance
 			}));
 		}
 
-		self.import_tx(vtx, client_account.nonce).map_err(Error::Transaction)
+		let r = self.import_tx(vtx, client_account.nonce).map_err(Error::Transaction);
+		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
+		r
 	}
 
 	/// Removes all transactions from particular sender up to (excluding) given client (state) nonce.
@@ -484,6 +508,7 @@ impl TransactionQueue {
 		// And now lets check if there is some batch of transactions in future
 		// that should be placed in current. It should also update last_nonces.
 		self.move_matching_future_to_current(sender, client_nonce, client_nonce);
+		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 	}
 
 	/// Removes invalid transaction identified by hash from queue.
@@ -493,6 +518,8 @@ impl TransactionQueue {
 	/// If gap is introduced marks subsequent transactions as future
 	pub fn remove_invalid<T>(&mut self, transaction_hash: &H256, fetch_account: &T)
 		where T: Fn(&Address) -> AccountDetails {
+
+		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 		let transaction = self.by_hash.remove(transaction_hash);
 		if transaction.is_none() {
 			// We don't know this transaction
@@ -511,22 +538,17 @@ impl TransactionQueue {
 			// And now lets check if there is some chain of transactions in future
 			// that should be placed in current
 			self.move_matching_future_to_current(sender, current_nonce, current_nonce);
+			assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 			return;
 		}
 
 		// Remove from current
 		let order = self.current.drop(&sender, &nonce);
 		if order.is_some() {
-			// We will either move transaction to future or remove it completely
-			// so there will be no transactions from this sender in current
-			self.last_nonces.remove(&sender);
-			// First update height of transactions in future to avoid collisions
-			self.update_future(&sender, current_nonce);
-			// This should move all current transactions to future and remove old transactions
-			self.move_all_to_future(&sender, current_nonce);
-			// And now lets check if there is some chain of transactions in future
-			// that should be placed in current. It should also update last_nonces.
-			self.move_matching_future_to_current(sender, current_nonce, current_nonce);
+			// This will keep consistency in queue
+			// Moves all to future and then promotes a batch from current:
+			self.remove_all(sender, current_nonce);
+			assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 			return;
 		}
 	}
@@ -545,7 +567,7 @@ impl TransactionQueue {
 			} else {
 				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				// Remove the transaction completely
-				self.by_hash.remove(&order.hash);
+				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
 		}
 	}
@@ -565,7 +587,7 @@ impl TransactionQueue {
 				self.future.insert(*sender, k, order.update_height(k, current_nonce));
 			} else {
 				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
-				self.by_hash.remove(&order.hash);
+				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
 		}
 		self.future.enforce_limit(&mut self.by_hash);
@@ -664,21 +686,27 @@ impl TransactionQueue {
 			.cloned()
 			.map_or(state_nonce, |n| n + U256::one());
 
-		// Check height
-		if nonce > next_nonce {
-			// We have a gap - put to future
-			try!(check_too_cheap(Self::replace_transaction(tx, next_nonce, &mut self.future, &mut self.by_hash)));
-			try!(check_if_removed(&address, &nonce, self.future.enforce_limit(&mut self.by_hash)));
-			return Ok(TransactionImportResult::Future);
-		} else if nonce < state_nonce {
+		// The transaction might be old, let's check that.
+		// This has to be the first test, otherwise calculating
+		// nonce height would result in overflow.
+		if nonce < state_nonce {
 			// Droping transaction
 			trace!(target: "miner", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, next_nonce);
 			return Err(TransactionError::Old);
+		} else if nonce > next_nonce {
+			// We have a gap - put to future.
+			// Update nonces of transactions in future (remove old transactions)
+			self.update_future(&address, state_nonce);
+			// Insert transaction (or replace old one with lower gas price)
+			try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, &mut self.future, &mut self.by_hash)));
+			// Return an error if this transaction is not imported because of limit.
+			try!(check_if_removed(&address, &nonce, self.future.enforce_limit(&mut self.by_hash)));
+			return Ok(TransactionImportResult::Future);
 		}
-
 		try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, &mut self.current, &mut self.by_hash)));
 		// Keep track of highest nonce stored in current
-		self.last_nonces.insert(address, nonce);
+		let new_max = self.last_nonces.get(&address).map_or(nonce, |n| cmp::max(nonce, *n));
+		self.last_nonces.insert(address, new_max);
 		// Update nonces of transactions in future
 		self.update_future(&address, state_nonce);
 		// Maybe there are some more items waiting in future?
@@ -687,15 +715,16 @@ impl TransactionQueue {
 		// same (sender, nonce), but above function would not move it.
 		if let Some(order) = self.future.drop(&address, &nonce) {
 			// Let's insert that transaction to current (if it has higher gas_price)
-			let future_tx = self.by_hash.remove(&order.hash).unwrap();
-			try!(check_too_cheap(Self::replace_transaction(future_tx, state_nonce, &mut self.current, &mut self.by_hash)));
+			let future_tx = self.by_hash.remove(&order.hash).expect("All transactions in `future` are always in `by_hash`.");
+			// if transaction in `current` (then one we are importing) is replaced it means that it has to low gas_price
+			try!(check_too_cheap(!Self::replace_transaction(future_tx, state_nonce, &mut self.current, &mut self.by_hash)));
 		}
 
 		// Also enforce the limit
 		let removed = self.current.enforce_limit(&mut self.by_hash);
 		// If some transaction were removed because of limit we need to update last_nonces also.
 		self.update_last_nonces(&removed);
-		// Trigger error if we were removed.
+		// Trigger error if the transaction we are importing was removed.
 		try!(check_if_removed(&address, &nonce, removed));
 
 		trace!(target: "miner", "status: {:?}", self.status());
@@ -703,9 +732,9 @@ impl TransactionQueue {
 	}
 
 	/// Updates
-	fn update_last_nonces(&mut self, removed_max_nonces: &Option<HashMap<Address, U256>>) {
-		if let Some(ref max_nonces) = *removed_max_nonces {
-			for (sender, nonce) in max_nonces.iter() {
+	fn update_last_nonces(&mut self, removed_min_nonces: &Option<HashMap<Address, U256>>) {
+		if let Some(ref min_nonces) = *removed_min_nonces {
+			for (sender, nonce) in min_nonces.iter() {
 				if *nonce == U256::zero() {
 					self.last_nonces.remove(sender);
 				} else {
@@ -728,7 +757,9 @@ impl TransactionQueue {
 		let address = tx.sender();
 		let nonce = tx.nonce();
 
-		by_hash.insert(hash, tx);
+		let old_hash = by_hash.insert(hash, tx);
+		assert!(old_hash.is_none(), "Each hash has to be inserted exactly once.");
+
 
 		if let Some(old) = set.insert(address, nonce, order.clone()) {
 			// There was already transaction in queue. Let's check which one should stay
@@ -738,11 +769,11 @@ impl TransactionQueue {
 				// Put back old transaction since it has greater priority (higher gas_price)
 				set.insert(address, nonce, old);
 				// and remove new one
-				by_hash.remove(&hash);
+				by_hash.remove(&hash).expect("The hash has been just inserted and no other line is altering `by_hash`.");
 				false
 			} else {
 				// Make sure we remove old transaction entirely
-				by_hash.remove(&old.hash);
+				by_hash.remove(&old.hash).expect("The hash is coming from `future` so it has to be in `by_hash`.");
 				true
 			}
 		} else {
@@ -762,7 +793,7 @@ fn check_too_cheap(is_in: bool) -> Result<(), TransactionError> {
 fn check_if_removed(sender: &Address, nonce: &U256, dropped: Option<HashMap<Address, U256>>) -> Result<(), TransactionError> {
 	match dropped {
 		Some(ref dropped) => match dropped.get(sender) {
-			Some(max) if nonce <= max => {
+			Some(min) if nonce >= min => {
 				Err(TransactionError::LimitReached)
 			},
 			_ => Ok(()),
@@ -939,7 +970,7 @@ mod test {
 		let res = txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External);
 
 		// and then there should be only one transaction in current (the one with higher gas_price)
-		assert_eq!(unwrap_tx_err(res), TransactionError::TooCheapToReplace);
+		assert_eq!(res.unwrap(), TransactionImportResult::Current);
 		assert_eq!(txq.status().pending, 1);
 		assert_eq!(txq.status().future, 0);
 		assert_eq!(txq.current.by_priority.len(), 1);
@@ -1087,7 +1118,28 @@ mod test {
 	}
 
 	#[test]
-	fn should_prioritize_local_transactions() {
+	fn should_prioritize_local_transactions_within_same_nonce_height() {
+		// given
+		let mut txq = TransactionQueue::new();
+		let tx = new_tx();
+		// the second one has same nonce but higher `gas_price`
+		let (_, tx2) = new_similar_txs();
+
+		// when
+		// first insert the one with higher gas price
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
+		// then the one with lower gas price, but local
+		txq.add(tx.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+
+		// then
+		let top = txq.top_transactions();
+		assert_eq!(top[0], tx); // local should be first
+		assert_eq!(top[1], tx2);
+		assert_eq!(top.len(), 2);
+	}
+
+	#[test]
+	fn should_not_prioritize_local_transactions_with_different_nonce_height() {
 		// given
 		let mut txq = TransactionQueue::new();
 		let (tx, tx2) = new_txs(U256::from(1));
@@ -1098,8 +1150,8 @@ mod test {
 
 		// then
 		let top = txq.top_transactions();
-		assert_eq!(top[0], tx2);
-		assert_eq!(top[1], tx);
+		assert_eq!(top[0], tx);
+		assert_eq!(top[1], tx2);
 		assert_eq!(top.len(), 2);
 	}
 
@@ -1255,7 +1307,7 @@ mod test {
 	#[test]
 	fn should_drop_old_transactions_when_hitting_the_limit() {
 		// given
-		let mut txq = TransactionQueue::with_limit(1);
+		let mut txq = TransactionQueue::with_limits(1, !U256::zero());
 		let (tx, tx2) = new_txs(U256::one());
 		let sender = tx.sender().unwrap();
 		let nonce = tx.nonce;
@@ -1277,7 +1329,7 @@ mod test {
 	#[test]
 	fn should_return_correct_nonces_when_dropped_because_of_limit() {
 		// given
-		let mut txq = TransactionQueue::with_limit(2);
+		let mut txq = TransactionQueue::with_limits(2, !U256::zero());
 		let tx = new_tx();
 		let (tx1, tx2) = new_txs(U256::one());
 		let sender = tx1.sender().unwrap();
@@ -1298,7 +1350,7 @@ mod test {
 
 	#[test]
 	fn should_limit_future_transactions() {
-		let mut txq = TransactionQueue::with_limit(1);
+		let mut txq = TransactionQueue::with_limits(1, !U256::zero());
 		txq.current.set_limit(10);
 		let (tx1, tx2) = new_txs_with_gas_price_diff(U256::from(4), U256::from(1));
 		let (tx3, tx4) = new_txs_with_gas_price_diff(U256::from(4), U256::from(2));
@@ -1555,4 +1607,54 @@ mod test {
 		assert_eq!(txq.has_local_pending_transactions(), true);
 	}
 
+	#[test]
+	fn should_keep_right_order_in_future() {
+		// given
+		let mut txq = TransactionQueue::with_limits(1, !U256::zero());
+		let (tx1, tx2) = new_txs(U256::from(1));
+		let prev_nonce = |a: &Address| AccountDetails { nonce: default_nonce(a).nonce - U256::one(), balance:
+			default_nonce(a).balance };
+
+		// when
+		assert_eq!(txq.add(tx2, &prev_nonce, TransactionOrigin::External).unwrap(), TransactionImportResult::Future);
+		assert_eq!(txq.add(tx1.clone(), &prev_nonce, TransactionOrigin::External).unwrap(), TransactionImportResult::Future);
+
+		// then
+		assert_eq!(txq.future.by_priority.len(), 1);
+		assert_eq!(txq.future.by_priority.iter().next().unwrap().hash, tx1.hash());
+	}
+
+	#[test]
+	fn should_return_correct_last_nonce() {
+		// given
+		let mut txq = TransactionQueue::new();
+		let (tx1, tx2, tx2_2, tx3) = {
+			let keypair = KeyPair::create().unwrap();
+			let secret = &keypair.secret();
+			let nonce = U256::from(123);
+			let tx = new_unsigned_tx(nonce);
+			let tx2 = new_unsigned_tx(nonce + 1.into());
+			let mut tx2_2 = new_unsigned_tx(nonce + 1.into());
+			tx2_2.gas_price = U256::from(5);
+			let tx3 = new_unsigned_tx(nonce + 2.into());
+
+
+			(tx.sign(secret), tx2.sign(secret), tx2_2.sign(secret), tx3.sign(secret))
+		};
+		let sender = tx1.sender().unwrap();
+		txq.add(tx1, &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx2, &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx3, &default_nonce, TransactionOrigin::Local).unwrap();
+		assert_eq!(txq.future.by_priority.len(), 0);
+		assert_eq!(txq.current.by_priority.len(), 3);
+
+		// when
+		let res = txq.add(tx2_2, &default_nonce, TransactionOrigin::Local);
+
+		// then
+		assert_eq!(txq.last_nonce(&sender).unwrap(), 125.into());
+		assert_eq!(res.unwrap(), TransactionImportResult::Current);
+		assert_eq!(txq.current.by_priority.len(), 3);
+	}
+
 }

ethcore/src/service.rs

@@ -41,6 +41,12 @@ pub enum SyncMessage {
 	NewChainHead,
 	/// A block is ready
 	BlockVerified,
+	/// New transaction RLPs are ready to be imported
+	NewTransactions(Vec<Bytes>),
+	/// Start network command.
+	StartNetwork,
+	/// Stop network command.
+	StopNetwork,
 }
 
 /// IO Message type used for Network service
@@ -48,17 +54,20 @@ pub type NetSyncMessage = NetworkIoMessage<SyncMessage>;
 
 /// Client service setup. Creates and registers client and network services with the IO subsystem.
 pub struct ClientService {
-	net_service: NetworkService<SyncMessage>,
+	net_service: Arc<NetworkService<SyncMessage>>,
 	client: Arc<Client>,
 	panic_handler: Arc<PanicHandler>
 }
 
 impl ClientService {
 	/// Start the service in a separate thread.
-	pub fn start(config: ClientConfig, spec: Spec, net_config: NetworkConfiguration, db_path: &Path, miner: Arc<Miner>) -> Result<ClientService, Error> {
+	pub fn start(config: ClientConfig, spec: Spec, net_config: NetworkConfiguration, db_path: &Path, miner: Arc<Miner>, enable_network: bool) -> Result<ClientService, Error> {
 		let panic_handler = PanicHandler::new_in_arc();
-		let mut net_service = try!(NetworkService::start(net_config));
+		let net_service = try!(NetworkService::new(net_config));
 		panic_handler.forward_from(&net_service);
+		if enable_network {
+			try!(net_service.start());
+		}
 
 		info!("Starting {}", net_service.host_info());
 		info!("Configured for {} using {:?} engine", spec.name, spec.engine.name());
@@ -70,7 +79,7 @@ impl ClientService {
 		try!(net_service.io().register_handler(client_io));
 
 		Ok(ClientService {
-			net_service: net_service,
+			net_service: Arc::new(net_service),
 			client: client,
 			panic_handler: panic_handler,
 		})
@@ -82,8 +91,8 @@ impl ClientService {
 	}
 
 	/// Get general IO interface
-	pub fn io(&mut self) -> &mut IoService<NetSyncMessage> {
-		self.net_service.io()
+	pub fn register_io_handler(&self, handler: Arc<IoHandler<NetSyncMessage> + Send>) -> Result<(), IoError> {
+		self.net_service.io().register_handler(handler)
 	}
 
 	/// Get client interface
@@ -92,8 +101,8 @@ impl ClientService {
 	}
 
 	/// Get network service component
-	pub fn network(&mut self) -> &mut NetworkService<SyncMessage> {
-		&mut self.net_service
+	pub fn network(&mut self) -> Arc<NetworkService<SyncMessage>> {
+		self.net_service.clone()
 	}
 }
 
@@ -129,6 +138,9 @@ impl IoHandler<NetSyncMessage> for ClientIoHandler {
 				SyncMessage::BlockVerified => {
 					self.client.import_verified_blocks(&io.channel());
 				},
+				SyncMessage::NewTransactions(ref transactions) => {
+					self.client.import_queued_transactions(&transactions);
+				},
 				_ => {}, // ignore other messages
 			}
 		}
@@ -147,9 +159,15 @@ mod tests {
 
 	#[test]
 	fn it_can_be_started() {
-		let spec = get_test_spec();
 		let temp_path = RandomTempPath::new();
-		let service = ClientService::start(ClientConfig::default(), spec, NetworkConfiguration::new_local(), &temp_path.as_path(), Arc::new(Miner::default()));
+		let service = ClientService::start(
+			ClientConfig::default(),
+			get_test_spec(),
+			NetworkConfiguration::new_local(),
+			&temp_path.as_path(),
+			Arc::new(Miner::with_spec(get_test_spec())),
+			false
+		);
 		assert!(service.is_ok());
 	}
 }

ethcore/src/snapshot/account.rs

@@ -85,7 +85,7 @@ impl Account {
 		if self.code_hash == SHA3_EMPTY {
 			account_stream.append(&false).append_empty_data();
 		} else {
-			match acct_db.lookup(&self.code_hash) {
+			match acct_db.get(&self.code_hash) {
 				Some(c) => {
 					account_stream.append(&true).append(&c);
 				}

ethcore/src/spec/spec.rs

@@ -244,6 +244,11 @@ impl Spec {
 	pub fn new_test() -> Spec {
 		Spec::load(include_bytes!("../../res/null_morden.json"))
 	}
+
+	/// Create a new Spec which is a NullEngine consensus with a premine of address whose secret is sha3('').
+	pub fn new_null() -> Spec {
+		Spec::load(include_bytes!("../../res/null.json"))
+	}
 }
 
 #[cfg(test)]

ethcore/src/state.rs

@@ -222,6 +222,30 @@ impl State {
 		let options = TransactOptions { tracing: tracing, vm_tracing: false, check_nonce: true };
 		let e = try!(Executive::new(self, env_info, engine, vm_factory).transact(t, options));
 
+		let broken_dao = H256::from("6a5d24750f78441e56fec050dc52fe8e911976485b7472faac7464a176a67caa");
+
+		// dao attack soft fork
+		if engine.schedule(&env_info).reject_dao_transactions {
+			let whitelisted = if let Action::Call(to) = t.action {
+				to == Address::from("Da4a4626d3E16e094De3225A751aAb7128e96526") ||
+				to == Address::from("2ba9D006C1D72E67A70b5526Fc6b4b0C0fd6D334")
+			} else { false };
+			if !whitelisted {
+				// collect all the addresses which have changed.
+				let addresses = self.cache.borrow().iter().map(|(addr, _)| addr.clone()).collect::<Vec<_>>();
+
+				for a in &addresses {
+					if self.code(a).map_or(false, |c| c.sha3() == broken_dao) {
+						// Figure out if the balance has been reduced.
+						let maybe_original = SecTrieDB::new(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR).get(&a).map(Account::from_rlp);
+						if maybe_original.map_or(false, |original| *original.balance() > self.balance(a)) {
+							return Err(Error::Transaction(TransactionError::DAORescue));
+						}
+					}
+				}
+			}
+		}
+
 		// TODO uncomment once to_pod() works correctly.
 //		trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod()));
 		self.commit();

ethcore/src/tests/client.rs

@@ -24,7 +24,7 @@ use miner::Miner;
 #[test]
 fn imports_from_empty() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::with_spec(get_test_spec())), IoChannel::disconnected()).unwrap();
 	client.import_verified_blocks(&IoChannel::disconnected());
 	client.flush_queue();
 }
@@ -42,7 +42,7 @@ fn returns_state_root_basic() {
 #[test]
 fn imports_good_block() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::with_spec(get_test_spec())), IoChannel::disconnected()).unwrap();
 	let good_block = get_good_dummy_block();
 	if let Err(_) = client.import_block(good_block) {
 		panic!("error importing block being good by definition");
@@ -57,7 +57,7 @@ fn imports_good_block() {
 #[test]
 fn query_none_block() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::with_spec(get_test_spec())), IoChannel::disconnected()).unwrap();
 
     let non_existant = client.block_header(BlockID::Number(188));
 	assert!(non_existant.is_none());
@@ -112,6 +112,19 @@ fn can_collect_garbage() {
 	assert!(client.blockchain_cache_info().blocks < 100 * 1024);
 }
 
+#[test]
+#[cfg_attr(feature="dev", allow(useless_vec))]
+fn can_generate_gas_price_statistics() {
+	let client_result = generate_dummy_client_with_data(16, 1, &vec_into![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
+	let client = client_result.reference();
+	let s = client.gas_price_statistics(8, 8).unwrap();
+	assert_eq!(s, vec_into![8, 8, 9, 10, 11, 12, 13, 14, 15]);
+	let s = client.gas_price_statistics(16, 8).unwrap();
+	assert_eq!(s, vec_into![0, 1, 3, 5, 7, 9, 11, 13, 15]);
+	let s = client.gas_price_statistics(32, 8).unwrap();
+	assert_eq!(s, vec_into![0, 1, 3, 5, 7, 9, 11, 13, 15]);
+}
+
 #[test]
 fn can_handle_long_fork() {
 	let client_result = generate_dummy_client(1200);
@@ -137,8 +150,7 @@ fn can_mine() {
 	let client_result = get_test_client_with_blocks(vec![dummy_blocks[0].clone()]);
 	let client = client_result.reference();
 
-	let b = client.prepare_open_block(Address::default(), 31415926.into(), vec![]).close();
+	let b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]).close();
 
 	assert_eq!(*b.block().header().parent_hash(), BlockView::new(&dummy_blocks[0]).header_view().sha3());
-	assert!(client.try_seal(b.lock(), vec![]).is_ok());
 }

ethcore/src/tests/helpers.rs

@@ -17,6 +17,7 @@
 use client::{BlockChainClient, Client, ClientConfig};
 use common::*;
 use spec::*;
+use block::{OpenBlock};
 use blockchain::{BlockChain, Config as BlockChainConfig};
 use state::*;
 use evm::Schedule;
@@ -85,6 +86,7 @@ impl Engine for TestEngine {
 	}
 }
 
+// TODO: move everything over to get_null_spec.
 pub fn get_test_spec() -> Spec {
 	Spec::new_test()
 }
@@ -126,7 +128,7 @@ fn create_unverifiable_block(order: u32, parent_hash: H256) -> Bytes {
 	create_test_block(&create_unverifiable_block_header(order, parent_hash))
 }
 
-pub fn create_test_block_with_data(header: &Header, transactions: &[&SignedTransaction], uncles: &[Header]) -> Bytes {
+pub fn create_test_block_with_data(header: &Header, transactions: &[SignedTransaction], uncles: &[Header]) -> Bytes {
 	let mut rlp = RlpStream::new_list(3);
 	rlp.append(header);
 	rlp.begin_list(transactions.len());
@@ -138,33 +140,75 @@ pub fn create_test_block_with_data(header: &Header, transactions: &[&SignedTrans
 }
 
 pub fn generate_dummy_client(block_number: u32) -> GuardedTempResult<Arc<Client>> {
+	generate_dummy_client_with_spec_and_data(Spec::new_test, block_number, 0, &[])
+}
+
+pub fn generate_dummy_client_with_data(block_number: u32, txs_per_block: usize, tx_gas_prices: &[U256]) -> GuardedTempResult<Arc<Client>> {
+	generate_dummy_client_with_spec_and_data(Spec::new_null, block_number, txs_per_block, tx_gas_prices)
+}
+
+pub fn generate_dummy_client_with_spec_and_data<F>(get_test_spec: F, block_number: u32, txs_per_block: usize, tx_gas_prices: &[U256]) -> GuardedTempResult<Arc<Client>> where F: Fn()->Spec {
 	let dir = RandomTempPath::new();
 
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
 	let test_spec = get_test_spec();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::with_spec(get_test_spec())), IoChannel::disconnected()).unwrap();
 	let test_engine = &test_spec.engine;
-	let state_root = test_spec.genesis_header().state_root;
-	let mut rolling_hash = test_spec.genesis_header().hash();
-	let mut rolling_block_number = 1;
+
+	let mut db_result = get_temp_journal_db();
+	let mut db = db_result.take();
+	test_spec.ensure_db_good(db.as_hashdb_mut());
+	let vm_factory = Default::default();
+	let genesis_header = test_spec.genesis_header();
+
 	let mut rolling_timestamp = 40;
+	let mut last_hashes = vec![];
+	let mut last_header = genesis_header.clone();
 
+	let kp = KeyPair::from_secret("".sha3()).unwrap()	;
+	let author = kp.address();
+
+	let mut n = 0;
 	for _ in 0..block_number {
-		let mut header = Header::new();
+		last_hashes.push(last_header.hash());
 
-		header.gas_limit = test_engine.params().min_gas_limit;
-		header.difficulty = U256::from(0x20000);
-		header.timestamp = rolling_timestamp;
-		header.number = rolling_block_number;
-		header.parent_hash = rolling_hash;
-		header.state_root = state_root.clone();
+		// forge block.
+		let mut b = OpenBlock::new(
+			test_engine.deref(),
+			&vm_factory,
+			false,
+			db,
+			&last_header,
+			last_hashes.clone(),
+			None,
+			author.clone(),
+			(3141562.into(), 31415620.into()),
+			vec![]
+		).unwrap();
+		b.set_difficulty(U256::from(0x20000));
+		rolling_timestamp += 10;
+		b.set_timestamp(rolling_timestamp);
 
-		rolling_hash = header.hash();
-		rolling_block_number = rolling_block_number + 1;
-		rolling_timestamp = rolling_timestamp + 10;
+		// first block we don't have any balance, so can't send any transactions.
+		for _ in 0..txs_per_block {
+			b.push_transaction(Transaction {
+				nonce: n.into(),
+				gas_price: tx_gas_prices[n % tx_gas_prices.len()],
+				gas: 100000.into(),
+				action: Action::Create,
+				data: vec![],
+				value: U256::zero(),
+			}.sign(kp.secret()), None).unwrap();
+			n += 1;
+		}
 
-		if let Err(e) = client.import_block(create_test_block(&header)) {
+		let b = b.close_and_lock().seal(test_engine.deref(), vec![]).unwrap();
+
+		if let Err(e) = client.import_block(b.rlp_bytes()) {
 			panic!("error importing block which is valid by definition: {:?}", e);
 		}
+
+		last_header = BlockView::new(&b.rlp_bytes()).header();
+		db = b.drain();
 	}
 	client.flush_queue();
 	client.import_verified_blocks(&IoChannel::disconnected());
@@ -206,7 +250,7 @@ pub fn push_blocks_to_client(client: &Arc<Client>, timestamp_salt: u64, starting
 
 pub fn get_test_client_with_blocks(blocks: Vec<Bytes>) -> GuardedTempResult<Arc<Client>> {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::default()), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::with_spec(get_test_spec())), IoChannel::disconnected()).unwrap();
 	for block in &blocks {
 		if let Err(_) = client.import_block(block.clone()) {
 			panic!("panic importing block which is well-formed");
@@ -259,7 +303,7 @@ pub fn generate_dummy_empty_blockchain() -> GuardedTempResult<BlockChain> {
 
 pub fn get_temp_journal_db() -> GuardedTempResult<Box<JournalDB>> {
 	let temp = RandomTempPath::new();
-	let journal_db = journaldb::new(temp.as_str(), journaldb::Algorithm::EarlyMerge);
+	let journal_db = journaldb::new(temp.as_str(), journaldb::Algorithm::EarlyMerge, DatabaseConfig::default());
 	GuardedTempResult {
 		_temp: temp,
 		result: Some(journal_db)
@@ -276,7 +320,7 @@ pub fn get_temp_state() -> GuardedTempResult<State> {
 }
 
 pub fn get_temp_journal_db_in(path: &Path) -> Box<JournalDB> {
-	journaldb::new(path.to_str().unwrap(), journaldb::Algorithm::EarlyMerge)
+	journaldb::new(path.to_str().unwrap(), journaldb::Algorithm::EarlyMerge, DatabaseConfig::default())
 }
 
 pub fn get_temp_state_in(path: &Path) -> State {

ethcore/src/trace/config.rs

@@ -48,6 +48,8 @@ pub struct Config {
 	pub enabled: Switch,
 	/// Traces blooms configuration.
 	pub blooms: BloomConfig,
+	/// Database cache-size if not default
+	pub db_cache_size: Option<usize>,
 }
 
 impl Default for Config {
@@ -57,7 +59,8 @@ impl Default for Config {
 			blooms: BloomConfig {
 				levels: 3,
 				elements_per_index: 16,
-			}
+			},
+			db_cache_size: None,
 		}
 	}
 }

ethcore/src/trace/db.rs

@@ -22,7 +22,7 @@ use std::sync::{RwLock, Arc};
 use std::path::Path;
 use bloomchain::{Number, Config as BloomConfig};
 use bloomchain::group::{BloomGroupDatabase, BloomGroupChain, GroupPosition, BloomGroup};
-use util::{H256, H264, Database, DBTransaction};
+use util::{H256, H264, Database, DatabaseConfig, DBTransaction};
 use header::BlockNumber;
 use trace::{BlockTraces, LocalizedTrace, Config, Switch, Filter, Database as TraceDatabase, ImportRequest,
 DatabaseExtras, Error};
@@ -118,7 +118,12 @@ impl<T> TraceDB<T> where T: DatabaseExtras {
 	pub fn new(config: Config, path: &Path, extras: Arc<T>) -> Result<Self, Error> {
 		let mut tracedb_path = path.to_path_buf();
 		tracedb_path.push("tracedb");
-		let tracesdb = Database::open_default(tracedb_path.to_str().unwrap()).unwrap();
+		let tracesdb = match config.db_cache_size {
+			None => Database::open_default(tracedb_path.to_str().unwrap()).unwrap(),
+			Some(db_cache) => Database::open(
+				&DatabaseConfig::with_cache(db_cache),
+				tracedb_path.to_str().unwrap()).unwrap(),
+		};
 
 		// check if in previously tracing was enabled
 		let old_tracing = match tracesdb.get(b"enabled").unwrap() {

ethcore/src/types/transaction.rs

@@ -140,8 +140,13 @@ impl Transaction {
 
 	/// Signs the transaction as coming from `sender`.
 	pub fn sign(self, secret: &Secret) -> SignedTransaction {
-		let sig = ec::sign(secret, &self.hash());
-		let (r, s, v) = sig.unwrap().to_rsv();
+		let sig = ec::sign(secret, &self.hash()).unwrap();
+		self.with_signature(sig)
+	}
+
+	/// Signs the transaction with signature.
+	pub fn with_signature(self, sig: H520) -> SignedTransaction {
+		let (r, s, v) = sig.to_rsv();
 		SignedTransaction {
 			unsigned: self,
 			r: r,

ethcore/src/verification/canon_verifier.rs

@@ -24,11 +24,11 @@ use super::verification;
 pub struct CanonVerifier;
 
 impl Verifier for CanonVerifier {
-	fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: &BlockProvider) -> Result<(), Error> {
+	fn verify_block_family(&self, header: &Header, bytes: &[u8], engine: &Engine, bc: &BlockProvider) -> Result<(), Error> {
 		verification::verify_block_family(header, bytes, engine, bc)
 	}
 
-	fn verify_block_final(expected: &Header, got: &Header) -> Result<(), Error> {
+	fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error> {
 		verification::verify_block_final(expected, got)
 	}
 }

ethcore/src/verification/mod.rs

@@ -17,11 +17,32 @@
 pub mod verification;
 pub mod verifier;
 mod canon_verifier;
-#[cfg(test)]
 mod noop_verifier;
 
 pub use self::verification::*;
 pub use self::verifier::Verifier;
 pub use self::canon_verifier::CanonVerifier;
-#[cfg(test)]
 pub use self::noop_verifier::NoopVerifier;
+
+/// Verifier type.
+#[derive(Debug)]
+pub enum VerifierType {
+	/// Verifies block normally.
+	Canon,
+	/// Does not verify block at all.
+	/// Used in tests.
+	Noop,
+}
+
+impl Default for VerifierType {
+	fn default() -> Self {
+		VerifierType::Canon
+	}
+}
+
+pub fn new(v: VerifierType) -> Box<Verifier> {
+	match v {
+		VerifierType::Canon => Box::new(CanonVerifier),
+		VerifierType::Noop => Box::new(NoopVerifier),
+	}
+}

ethcore/src/verification/noop_verifier.rs

@@ -24,11 +24,11 @@ use super::Verifier;
 pub struct NoopVerifier;
 
 impl Verifier for NoopVerifier {
-	fn verify_block_family(_header: &Header, _bytes: &[u8], _engine: &Engine, _bc: &BlockProvider) -> Result<(), Error> {
+	fn verify_block_family(&self, _header: &Header, _bytes: &[u8], _engine: &Engine, _bc: &BlockProvider) -> Result<(), Error> {
 		Ok(())
 	}
 
-	fn verify_block_final(_expected: &Header, _got: &Header) -> Result<(), Error> {
+	fn verify_block_final(&self, _expected: &Header, _got: &Header) -> Result<(), Error> {
 		Ok(())
 	}
 }

ethcore/src/verification/verification.rs

@@ -361,7 +361,7 @@ mod tests {
 			nonce: U256::from(2)
 		}.sign(&keypair.secret());
 
-		let good_transactions = [ &tr1, &tr2 ];
+		let good_transactions = [ tr1.clone(), tr2.clone() ];
 
 		let diff_inc = U256::from(0x40);
 

ethcore/src/verification/verifier.rs

@@ -21,6 +21,6 @@ use header::Header;
 
 /// Should be used to verify blocks.
 pub trait Verifier: Send + Sync {
-	fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: &BlockProvider) -> Result<(), Error>;
-	fn verify_block_final(expected: &Header, got: &Header) -> Result<(), Error>;
+	fn verify_block_family(&self, header: &Header, bytes: &[u8], engine: &Engine, bc: &BlockProvider) -> Result<(), Error>;
+	fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error>;
 }

ethcore/src/views.rs

@@ -1,339 +0,0 @@
-// Copyright 2015, 2016 Ethcore (UK) Ltd.
-// This file is part of Parity.
-
-// Parity is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Block oriented views onto rlp.
-use util::*;
-use header::*;
-use transaction::*;
-
-/// View onto transaction rlp.
-pub struct TransactionView<'a> {
-	rlp: Rlp<'a>
-}
-
-impl<'a> TransactionView<'a> {
-	/// Creates new view onto block from raw bytes.
-	pub fn new(bytes: &'a [u8]) -> TransactionView<'a> {
-		TransactionView {
-			rlp: Rlp::new(bytes)
-		}
-	}
-
-	/// Creates new view onto block from rlp.
-	pub fn new_from_rlp(rlp: Rlp<'a>) -> TransactionView<'a> {
-		TransactionView {
-			rlp: rlp
-		}
-	}
-
-	/// Return reference to underlaying rlp.
-	pub fn rlp(&self) -> &Rlp<'a> {
-		&self.rlp
-	}
-
-	/// Get the nonce field of the transaction.
-	pub fn nonce(&self) -> U256 { self.rlp.val_at(0) }
-
-	/// Get the gas_price field of the transaction.
-	pub fn gas_price(&self) -> U256 { self.rlp.val_at(1) }
-
-	/// Get the gas field of the transaction.
-	pub fn gas(&self) -> U256 { self.rlp.val_at(2) }
-
-	/// Get the value field of the transaction.
-	pub fn value(&self) -> U256 { self.rlp.val_at(4) }
-
-	/// Get the data field of the transaction.
-	pub fn data(&self) -> Bytes { self.rlp.val_at(5) }
-
-	/// Get the v field of the transaction.
-	pub fn v(&self) -> u8 { let r: u16 = self.rlp.val_at(6); r as u8 }
-
-	/// Get the r field of the transaction.
-	pub fn r(&self) -> U256 { self.rlp.val_at(7) }
-
-	/// Get the s field of the transaction.
-	pub fn s(&self) -> U256 { self.rlp.val_at(8) }
-
-	// TODO: something like pub fn action(&self) -> Action { self.rlp.val_at(3) }
-}
-
-impl<'a> Hashable for TransactionView<'a> {
-	fn sha3(&self) -> H256 {
-		self.rlp.as_raw().sha3()
-	}
-}
-
-/// View onto transaction rlp.
-pub struct AccountView<'a> {
-	rlp: Rlp<'a>
-}
-
-impl<'a> AccountView<'a> {
-	/// Creates new view onto block from raw bytes.
-	pub fn new(bytes: &'a [u8]) -> AccountView<'a> {
-		AccountView {
-			rlp: Rlp::new(bytes)
-		}
-	}
-
-	/// Creates new view onto block from rlp.
-	pub fn new_from_rlp(rlp: Rlp<'a>) -> AccountView<'a> {
-		AccountView {
-			rlp: rlp
-		}
-	}
-
-	/// Return reference to underlaying rlp.
-	pub fn rlp(&self) -> &Rlp<'a> {
-		&self.rlp
-	}
-
-	/// Get the nonce field of the transaction.
-	pub fn nonce(&self) -> U256 { self.rlp.val_at(0) }
-
-	/// Get the gas_price field of the transaction.
-	pub fn balance(&self) -> U256 { self.rlp.val_at(1) }
-
-	/// Get the gas field of the transaction.
-	pub fn storage_root(&self) -> H256 { self.rlp.val_at(2) }
-
-	/// Get the value field of the transaction.
-	pub fn code_hash(&self) -> H256 { self.rlp.val_at(3) }
-}
-
-/// View onto block rlp.
-pub struct BlockView<'a> {
-	rlp: Rlp<'a>
-}
-
-impl<'a> BlockView<'a> {
-	/// Creates new view onto block from raw bytes.
-	pub fn new(bytes: &'a [u8]) -> BlockView<'a> {
-		BlockView {
-			rlp: Rlp::new(bytes)
-		}
-	}
-
-	/// Creates new view onto block from rlp.
-	pub fn new_from_rlp(rlp: Rlp<'a>) -> BlockView<'a> {
-		BlockView {
-			rlp: rlp
-		}
-	}
-
-	/// Return reference to underlaying rlp.
-	pub fn rlp(&self) -> &Rlp<'a> {
-		&self.rlp
-	}
-
-	/// Create new Header object from header rlp.
-	pub fn header(&self) -> Header {
-		self.rlp.val_at(0)
-	}
-
-	/// Create new header view onto block head rlp.
-	pub fn header_view(&self) -> HeaderView<'a> {
-		HeaderView::new_from_rlp(self.rlp.at(0))
-	}
-
-	/// Return List of transactions in given block.
-	pub fn transactions(&self) -> Vec<SignedTransaction> {
-		self.rlp.val_at(1)
-	}
-
-	/// Return List of transactions with additional localization info.
-	pub fn localized_transactions(&self) -> Vec<LocalizedTransaction> {
-		let header = self.header_view();
-		let block_hash = header.sha3();
-		let block_number = header.number();
-		self.transactions()
-			.into_iter()
-			.enumerate()
-			.map(|(i, t)| LocalizedTransaction {
-				signed: t,
-				block_hash: block_hash.clone(),
-				block_number: block_number,
-				transaction_index: i
-			}).collect()
-	}
-
-	/// Return number of transactions in given block, without deserializing them.
-	pub fn transactions_count(&self) -> usize {
-		self.rlp.at(1).iter().count()
-	}
-
-	/// Return List of transactions in given block.
-	pub fn transaction_views(&self) -> Vec<TransactionView> {
-		self.rlp.at(1).iter().map(TransactionView::new_from_rlp).collect()
-	}
-
-	/// Return transaction hashes.
-	pub fn transaction_hashes(&self) -> Vec<H256> {
-		self.rlp.at(1).iter().map(|rlp| rlp.as_raw().sha3()).collect()
-	}
-
-	/// Returns transaction at given index without deserializing unnecessary data.
-	pub fn transaction_at(&self, index: usize) -> Option<SignedTransaction> {
-		self.rlp.at(1).iter().nth(index).map(|rlp| rlp.as_val())
-	}
-
-	/// Returns localized transaction at given index.
-	pub fn localized_transaction_at(&self, index: usize) -> Option<LocalizedTransaction> {
-		let header = self.header_view();
-		let block_hash = header.sha3();
-		let block_number = header.number();
-		self.transaction_at(index).map(|t| LocalizedTransaction {
-			signed: t,
-			block_hash: block_hash,
-			block_number: block_number,
-			transaction_index: index
-		})
-	}
-
-	/// Return list of uncles of given block.
-	pub fn uncles(&self) -> Vec<Header> {
-		self.rlp.val_at(2)
-	}
-
-	/// Return number of uncles in given block, without deserializing them.
-	pub fn uncles_count(&self) -> usize {
-		self.rlp.at(2).iter().count()
-	}
-
-	/// Return List of transactions in given block.
-	pub fn uncle_views(&self) -> Vec<HeaderView> {
-		self.rlp.at(2).iter().map(HeaderView::new_from_rlp).collect()
-	}
-
-	/// Return list of uncle hashes of given block.
-	pub fn uncle_hashes(&self) -> Vec<H256> {
-		self.rlp.at(2).iter().map(|rlp| rlp.as_raw().sha3()).collect()
-	}
-
-	/// Return nth uncle.
-	pub fn uncle_at(&self, index: usize) -> Option<Header> {
-		self.rlp.at(2).iter().nth(index).map(|rlp| rlp.as_val())
-	}
-}
-
-impl<'a> Hashable for BlockView<'a> {
-	fn sha3(&self) -> H256 {
-		self.header_view().sha3()
-	}
-}
-
-/// View onto block header rlp.
-pub struct HeaderView<'a> {
-	rlp: Rlp<'a>
-}
-
-impl<'a> HeaderView<'a> {
-	/// Creates new view onto header from raw bytes.
-	pub fn new(bytes: &'a [u8]) -> HeaderView<'a> {
-		HeaderView {
-			rlp: Rlp::new(bytes)
-		}
-	}
-
-	/// Creates new view onto header from rlp.
-	pub fn new_from_rlp(rlp: Rlp<'a>) -> HeaderView<'a> {
-		HeaderView {
-			rlp: rlp
-		}
-	}
-
-	/// Returns header hash.
-	pub fn hash(&self) -> H256 { self.sha3() }
-
-	/// Returns raw rlp.
-	pub fn rlp(&self) -> &Rlp<'a> { &self.rlp }
-
-	/// Returns parent hash.
-	pub fn parent_hash(&self) -> H256 { self.rlp.val_at(0) }
-
-	/// Returns uncles hash.
-	pub fn uncles_hash(&self) -> H256 { self.rlp.val_at(1) }
-
-	/// Returns author.
-	pub fn author(&self) -> Address { self.rlp.val_at(2) }
-
-	/// Returns state root.
-	pub fn state_root(&self) -> H256 { self.rlp.val_at(3) }
-
-	/// Returns transactions root.
-	pub fn transactions_root(&self) -> H256 { self.rlp.val_at(4) }
-
-	/// Returns block receipts root.
-	pub fn receipts_root(&self) -> H256 { self.rlp.val_at(5) }
-
-	/// Returns block log bloom.
-	pub fn log_bloom(&self) -> H2048 { self.rlp.val_at(6) }
-
-	/// Returns block difficulty.
-	pub fn difficulty(&self) -> U256 { self.rlp.val_at(7) }
-
-	/// Returns block number.
-	pub fn number(&self) -> BlockNumber { self.rlp.val_at(8) }
-
-	/// Returns block gas limit.
-	pub fn gas_limit(&self) -> U256 { self.rlp.val_at(9) }
-
-	/// Returns block gas used.
-	pub fn gas_used(&self) -> U256 { self.rlp.val_at(10) }
-
-	/// Returns timestamp.
-	pub fn timestamp(&self) -> u64 { self.rlp.val_at(11) }
-
-	/// Returns block extra data.
-	pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) }
-
-	/// Returns a vector of post-RLP-encoded seal fields.
-	pub fn seal(&self) -> Vec<Bytes> {
-		let mut seal = vec![];
-		for i in 13..self.rlp.item_count() {
-			seal.push(self.rlp.at(i).as_raw().to_vec());
-		}
-		seal
-	}
-}
-
-impl<'a> Hashable for HeaderView<'a> {
-	fn sha3(&self) -> H256 {
-		self.rlp.as_raw().sha3()
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use rustc_serialize::hex::FromHex;
-	use super::BlockView;
-
-	#[test]
-	fn test_header_view_seal_fields() {
-		// that's rlp of block created with ethash engine.
-		let block_rlp = "f90261f901f9a0d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a088d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158a007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefba82524d84568e932a80a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd88ab4e252a7e8c2a23f862f86002018304cb2f94ec0e71ad0a90ffe1909d27dac207f7680abba42d01801ba03a347e72953c860f32b1eb2c78a680d8734b2ea08085d949d729479796f218d5a047ea6239d9e31ccac8af3366f5ca37184d26e7646e3191a3aeb81c4cf74de500c0".from_hex().unwrap();
-		let mix_hash = "a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd".from_hex().unwrap();
-		let nonce = "88ab4e252a7e8c2a23".from_hex().unwrap();
-
-		let block_view = BlockView::new(&block_rlp);
-		let header_view = block_view.header_view();
-		let seal_fields = header_view.seal();
-		assert_eq!(seal_fields.len(), 2);
-		assert_eq!(seal_fields[0], mix_hash);
-		assert_eq!(seal_fields[1], nonce);
-	}
-}

ethcore/src/views/block.rs

@@ -0,0 +1,167 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! View onto block rlp.
+
+use util::*;
+use header::*;
+use transaction::*;
+use super::{TransactionView, HeaderView};
+
+/// View onto block rlp.
+pub struct BlockView<'a> {
+	rlp: Rlp<'a>
+}
+
+impl<'a> BlockView<'a> {
+	/// Creates new view onto block from raw bytes.
+	pub fn new(bytes: &'a [u8]) -> BlockView<'a> {
+		BlockView {
+			rlp: Rlp::new(bytes)
+		}
+	}
+
+	/// Creates new view onto block from rlp.
+	pub fn new_from_rlp(rlp: Rlp<'a>) -> BlockView<'a> {
+		BlockView {
+			rlp: rlp
+		}
+	}
+
+	/// Block header hash.
+	pub fn hash(&self) -> H256 {
+		self.sha3()
+	}
+
+	/// Return reference to underlaying rlp.
+	pub fn rlp(&self) -> &Rlp<'a> {
+		&self.rlp
+	}
+
+	/// Create new Header object from header rlp.
+	pub fn header(&self) -> Header {
+		self.rlp.val_at(0)
+	}
+
+	/// Create new header view obto block head rlp.
+	pub fn header_view(&self) -> HeaderView<'a> {
+		HeaderView::new_from_rlp(self.rlp.at(0))
+	}
+
+	/// Return List of transactions in given block.
+	pub fn transactions(&self) -> Vec<SignedTransaction> {
+		self.rlp.val_at(1)
+	}
+
+	/// Return List of transactions with additional localization info.
+	pub fn localized_transactions(&self) -> Vec<LocalizedTransaction> {
+		let header = self.header_view();
+		let block_hash = header.sha3();
+		let block_number = header.number();
+		self.transactions()
+			.into_iter()
+			.enumerate()
+			.map(|(i, t)| LocalizedTransaction {
+				signed: t,
+				block_hash: block_hash.clone(),
+				block_number: block_number,
+				transaction_index: i
+			}).collect()
+	}
+
+	/// Return number of transactions in given block, without deserializing them.
+	pub fn transactions_count(&self) -> usize {
+		self.rlp.at(1).iter().count()
+	}
+
+	/// Return List of transactions in given block.
+	pub fn transaction_views(&self) -> Vec<TransactionView> {
+		self.rlp.at(1).iter().map(TransactionView::new_from_rlp).collect()
+	}
+
+	/// Return transaction hashes.
+	pub fn transaction_hashes(&self) -> Vec<H256> {
+		self.rlp.at(1).iter().map(|rlp| rlp.as_raw().sha3()).collect()
+	}
+
+	/// Returns transaction at given index without deserializing unnecessary data.
+	pub fn transaction_at(&self, index: usize) -> Option<SignedTransaction> {
+		self.rlp.at(1).iter().nth(index).map(|rlp| rlp.as_val())
+	}
+
+	/// Returns localized transaction at given index.
+	pub fn localized_transaction_at(&self, index: usize) -> Option<LocalizedTransaction> {
+		let header = self.header_view();
+		let block_hash = header.sha3();
+		let block_number = header.number();
+		self.transaction_at(index).map(|t| LocalizedTransaction {
+			signed: t,
+			block_hash: block_hash,
+			block_number: block_number,
+			transaction_index: index
+		})
+	}
+
+	/// Return list of uncles of given block.
+	pub fn uncles(&self) -> Vec<Header> {
+		self.rlp.val_at(2)
+	}
+
+	/// Return number of uncles in given block, without deserializing them.
+	pub fn uncles_count(&self) -> usize {
+		self.rlp.at(2).iter().count()
+	}
+
+	/// Return List of transactions in given block.
+	pub fn uncle_views(&self) -> Vec<HeaderView> {
+		self.rlp.at(2).iter().map(HeaderView::new_from_rlp).collect()
+	}
+
+	/// Return list of uncle hashes of given block.
+	pub fn uncle_hashes(&self) -> Vec<H256> {
+		self.rlp.at(2).iter().map(|rlp| rlp.as_raw().sha3()).collect()
+	}
+
+	/// Return nth uncle.
+	pub fn uncle_at(&self, index: usize) -> Option<Header> {
+		self.rlp.at(2).iter().nth(index).map(|rlp| rlp.as_val())
+	}
+}
+
+impl<'a> Hashable for BlockView<'a> {
+	fn sha3(&self) -> H256 {
+		self.header_view().sha3()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use rustc_serialize::hex::FromHex;
+	use util::H256;
+	use super::BlockView;
+
+	#[test]
+	fn test_block_view() {
+		// that's rlp of block created with ethash engine.
+		let rlp = "f90261f901f9a0d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a088d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158a007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefba82524d84568e932a80a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd88ab4e252a7e8c2a23f862f86002018304cb2f94ec0e71ad0a90ffe1909d27dac207f7680abba42d01801ba03a347e72953c860f32b1eb2c78a680d8734b2ea08085d949d729479796f218d5a047ea6239d9e31ccac8af3366f5ca37184d26e7646e3191a3aeb81c4cf74de500c0".from_hex().unwrap();
+
+		let view = BlockView::new(&rlp);
+		assert_eq!(view.hash(), H256::from_str("2c9747e804293bd3f1a986484343f23bc88fd5be75dfe9d5c2860aff61e6f259").unwrap());
+		assert_eq!(view.transactions_count(), 1);
+		assert_eq!(view.uncles_count(), 0);
+	}
+}

ethcore/src/views/header.rs

@@ -0,0 +1,134 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! View onto block header rlp
+
+use util::{Rlp, U256, Bytes, Hashable, H256, Address, H2048, View};
+use header::BlockNumber;
+
+/// View onto block header rlp.
+pub struct HeaderView<'a> {
+	rlp: Rlp<'a>
+}
+
+impl<'a> HeaderView<'a> {
+	/// Creates new view onto header from raw bytes.
+	pub fn new(bytes: &'a [u8]) -> HeaderView<'a> {
+		HeaderView {
+			rlp: Rlp::new(bytes)
+		}
+	}
+
+	/// Creates new view onto header from rlp.
+	pub fn new_from_rlp(rlp: Rlp<'a>) -> HeaderView<'a> {
+		HeaderView {
+			rlp: rlp
+		}
+	}
+
+	/// Returns header hash.
+	pub fn hash(&self) -> H256 { self.sha3() }
+
+	/// Returns raw rlp.
+	pub fn rlp(&self) -> &Rlp<'a> { &self.rlp }
+
+	/// Returns parent hash.
+	pub fn parent_hash(&self) -> H256 { self.rlp.val_at(0) }
+
+	/// Returns uncles hash.
+	pub fn uncles_hash(&self) -> H256 { self.rlp.val_at(1) }
+
+	/// Returns author.
+	pub fn author(&self) -> Address { self.rlp.val_at(2) }
+
+	/// Returns state root.
+	pub fn state_root(&self) -> H256 { self.rlp.val_at(3) }
+
+	/// Returns transactions root.
+	pub fn transactions_root(&self) -> H256 { self.rlp.val_at(4) }
+
+	/// Returns block receipts root.
+	pub fn receipts_root(&self) -> H256 { self.rlp.val_at(5) }
+
+	/// Returns block log bloom.
+	pub fn log_bloom(&self) -> H2048 { self.rlp.val_at(6) }
+
+	/// Returns block difficulty.
+	pub fn difficulty(&self) -> U256 { self.rlp.val_at(7) }
+
+	/// Returns block number.
+	pub fn number(&self) -> BlockNumber { self.rlp.val_at(8) }
+
+	/// Returns block gas limit.
+	pub fn gas_limit(&self) -> U256 { self.rlp.val_at(9) }
+
+	/// Returns block gas used.
+	pub fn gas_used(&self) -> U256 { self.rlp.val_at(10) }
+
+	/// Returns timestamp.
+	pub fn timestamp(&self) -> u64 { self.rlp.val_at(11) }
+
+	/// Returns block extra data.
+	pub fn extra_data(&self) -> Bytes { self.rlp.val_at(12) }
+
+	/// Returns a vector of post-RLP-encoded seal fields.
+	pub fn seal(&self) -> Vec<Bytes> {
+		let mut seal = vec![];
+		for i in 13..self.rlp.item_count() {
+			seal.push(self.rlp.at(i).as_raw().to_vec());
+		}
+		seal
+	}
+}
+
+impl<'a> Hashable for HeaderView<'a> {
+	fn sha3(&self) -> H256 {
+		self.rlp.as_raw().sha3()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use rustc_serialize::hex::FromHex;
+	use util::{H256, Address, H2048, U256};
+	use super::HeaderView;
+
+	#[test]
+	fn test_header_view() {
+		// that's rlp of block header created with ethash engine.
+		let rlp = "f901f9a0d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a088d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158a007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefba82524d84568e932a80a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd88ab4e252a7e8c2a23".from_hex().unwrap();
+		let mix_hash = "a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd".from_hex().unwrap();
+		let nonce = "88ab4e252a7e8c2a23".from_hex().unwrap();
+
+		let view = HeaderView::new(&rlp);
+		assert_eq!(view.hash(), H256::from_str("2c9747e804293bd3f1a986484343f23bc88fd5be75dfe9d5c2860aff61e6f259").unwrap());
+		assert_eq!(view.parent_hash(), H256::from_str("d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7").unwrap());
+		assert_eq!(view.uncles_hash(), H256::from_str("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347").unwrap());
+		assert_eq!(view.author(), Address::from_str("8888f1f195afa192cfee860698584c030f4c9db1").unwrap());
+		assert_eq!(view.state_root(), H256::from_str("5fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25").unwrap());
+		assert_eq!(view.transactions_root(), H256::from_str("88d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158").unwrap());
+		assert_eq!(view.receipts_root(), H256::from_str("07c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1").unwrap());
+		assert_eq!(view.log_bloom(), H2048::default());
+		assert_eq!(view.difficulty(), U256::from(0x02_00_80));
+		assert_eq!(view.number(), 3);
+		assert_eq!(view.gas_limit(), U256::from(0x2f_ef_ba));
+		assert_eq!(view.gas_used(), U256::from(0x52_4d));
+		assert_eq!(view.timestamp(), 0x56_8e_93_2a);
+		assert_eq!(view.extra_data(), vec![] as Vec<u8>);
+		assert_eq!(view.seal(), vec![mix_hash, nonce]);
+	}
+}

ethcore/src/views/mod.rs

@@ -0,0 +1,25 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Block oriented views onto rlp.
+
+mod block;
+mod header;
+mod transaction;
+
+pub use self::block::BlockView;
+pub use self::header::HeaderView;
+pub use self::transaction::TransactionView;

ethcore/src/views/transaction.rs

@@ -0,0 +1,97 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! View onto transaction rlp
+use util::{Rlp, U256, Bytes, Hashable, H256, View};
+
+/// View onto transaction rlp.
+pub struct TransactionView<'a> {
+	rlp: Rlp<'a>
+}
+
+impl<'a> TransactionView<'a> {
+	/// Creates new view onto block from raw bytes.
+	pub fn new(bytes: &'a [u8]) -> TransactionView<'a> {
+		TransactionView {
+			rlp: Rlp::new(bytes)
+		}
+	}
+
+	/// Creates new view onto block from rlp.
+	pub fn new_from_rlp(rlp: Rlp<'a>) -> TransactionView<'a> {
+		TransactionView {
+			rlp: rlp
+		}
+	}
+
+	/// Return reference to underlaying rlp.
+	pub fn rlp(&self) -> &Rlp<'a> {
+		&self.rlp
+	}
+
+	/// Get the nonce field of the transaction.
+	pub fn nonce(&self) -> U256 { self.rlp.val_at(0) }
+
+	/// Get the gas_price field of the transaction.
+	pub fn gas_price(&self) -> U256 { self.rlp.val_at(1) }
+
+	/// Get the gas field of the transaction.
+	pub fn gas(&self) -> U256 { self.rlp.val_at(2) }
+
+	/// Get the value field of the transaction.
+	pub fn value(&self) -> U256 { self.rlp.val_at(4) }
+
+	/// Get the data field of the transaction.
+	pub fn data(&self) -> Bytes { self.rlp.val_at(5) }
+
+	/// Get the v field of the transaction.
+	pub fn v(&self) -> u8 { let r: u16 = self.rlp.val_at(6); r as u8 }
+
+	/// Get the r field of the transaction.
+	pub fn r(&self) -> U256 { self.rlp.val_at(7) }
+
+	/// Get the s field of the transaction.
+	pub fn s(&self) -> U256 { self.rlp.val_at(8) }
+}
+
+impl<'a> Hashable for TransactionView<'a> {
+	fn sha3(&self) -> H256 {
+		self.rlp.as_raw().sha3()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use rustc_serialize::hex::FromHex;
+	use util::U256;
+	use super::TransactionView;
+
+	#[test]
+	fn test_transaction_view() {
+		let rlp = "f87c80018261a894095e7baea6a6c7c4c2dfeb977efac326af552d870a9d00000000000000000000000000000000000000000000000000000000001ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804".from_hex().unwrap();
+
+		let view = TransactionView::new(&rlp);
+		assert_eq!(view.nonce(), U256::from(0));
+		assert_eq!(view.gas_price(), U256::from(1));
+		assert_eq!(view.gas(), U256::from(0x61a8));
+		assert_eq!(view.value(), U256::from(0xa));
+		assert_eq!(view.data(), "0000000000000000000000000000000000000000000000000000000000".from_hex().unwrap());
+		assert_eq!(view.r(), U256::from_str("48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353").unwrap());
+		assert_eq!(view.s(), U256::from_str("efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
+		assert_eq!(view.v(), 0x1b);
+	}
+}