refactored to merge client & client

ethcore/src/client/client.rs

@@ -48,6 +48,7 @@ use trace;
 pub use types::blockchain_info::BlockChainInfo;
 pub use types::block_status::BlockStatus;
 use evm::Factory as EvmFactory;
+use miner::{Miner, MinerService, TransactionImportResult, AccountDetails};
 
 impl fmt::Display for BlockChainInfo {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -90,7 +91,7 @@ pub struct Client<V = CanonVerifier> where V: Verifier {
 	panic_handler: Arc<PanicHandler>,
 	verifier: PhantomData<V>,
 	vm_factory: Arc<EvmFactory>,
-	miner: Arc<MinerService>,
+	miner: Arc<Miner>,
 }
 
 const HISTORY: u64 = 1200;
@@ -103,8 +104,8 @@ const CLIENT_DB_VER_STR: &'static str = "5.3";
 
 impl Client<CanonVerifier> {
 	/// Create a new client with given spec and DB path.
-	pub fn new(config: ClientConfig, spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Result<Arc<Client>, ClientError> {
-		Client::<CanonVerifier>::new_with_verifier(config, spec, path, message_channel)
+	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)
 	}
 }
 
@@ -131,6 +132,7 @@ impl<V> Client<V> where V: Verifier {
 		config: ClientConfig,
 		spec: Spec,
 		path: &Path,
+		miner: Arc<Miner>,
 		message_channel: IoChannel<NetSyncMessage>)
 		-> Result<Arc<Client<V>>, ClientError>
 	{
@@ -162,6 +164,7 @@ impl<V> Client<V> where V: Verifier {
 			panic_handler: panic_handler,
 			verifier: PhantomData,
 			vm_factory: Arc::new(EvmFactory::new(config.vm_type)),
+			miner: miner,
 		};
 
 		Ok(Arc::new(client))
@@ -335,13 +338,13 @@ impl<V> Client<V> where V: Verifier {
 		{
 			if !imported_blocks.is_empty() && self.block_queue.queue_info().is_empty() {
 				let (enacted, retracted) = self.calculate_enacted_retracted(import_results);
-				self.miner.chain_new_blocks(imported_blocks, invalid_blocks, enacted, retracted);
+				self.miner.chain_new_blocks(self, &imported_blocks, &invalid_blocks, &enacted, &retracted);
 			}
 		}
 
 		{
 			if self.chain_info().best_block_hash != original_best {
-				self.miner.update_sealing(&self);
+				self.miner.update_sealing(self);
 			}
 		}
 
@@ -705,10 +708,21 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 	fn last_hashes(&self) -> LastHashes {
 		self.build_last_hashes(self.chain.best_block_hash())
 	}
+
+	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, Error>> {
+		let fetch_account = |a: &Address| AccountDetails {
+			nonce: self.latest_nonce(a),
+			balance: self.latest_balance(a),
+		};
+		self.miner.import_transactions(transactions, fetch_account)
+	}
+
+	fn all_transactions(&self) -> Vec<SignedTransaction> {
+		self.miner.all_transactions()
+	}
 }
 
 impl<V> ExtendedBlockChainClient for Client<V> where V: Verifier {
-		// TODO [todr] Should be moved to miner crate eventually.
 	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>)
 		-> (Option<ClosedBlock>, HashSet<H256>) {
 		let engine = self.engine.deref().deref();
@@ -774,26 +788,11 @@ impl<V> ExtendedBlockChainClient for Client<V> where V: Verifier {
 		(Some(b), invalid_transactions)
 	}
 
-	// TODO [todr] Should be moved to miner crate eventually.
 	fn try_seal(&self, block: LockedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock> {
 		block.try_seal(self.engine.deref().deref(), seal)
 	}
 }
 
-impl MiningClient for Client {
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, Error>> {
-		let fetch_account = |a: &Address| AccountDetails {
-			nonce: self.latest_nonce(a),
-			balance: self.latest_balance(a),
-		};
-		self.miner.import_transactions(transactions, fetch_account)
-	}
-
-	fn all_transactions(&self) -> Vec<SignedTransaction> {
-		self.miner.all_transactions()
-	}
-}
-
 impl MayPanic for Client {
 	fn on_panic<F>(&self, closure: F) where F: OnPanicListener {
 		self.panic_handler.on_panic(closure);

ethcore/src/client/mod.rs

@@ -46,6 +46,8 @@ use error::{ImportResult, ExecutionError};
 use receipt::LocalizedReceipt;
 use trace::LocalizedTrace;
 use evm::Factory as EvmFactory;
+use miner::{TransactionImportResult, AccountDetails};
+use error::Error as EthError;
 
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
 pub trait BlockChainClient : Sync + Send {
@@ -174,6 +176,12 @@ pub trait BlockChainClient : Sync + Send {
 
 	/// Get last hashes starting from best block.
 	fn last_hashes(&self) -> LastHashes;
+
+	/// 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>;
 }
 
 /// Extended client interface used for mining
@@ -185,12 +193,3 @@ pub trait ExtendedBlockChainClient : BlockChainClient {
 	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>)
 		-> (Option<ClosedBlock>, HashSet<H256>);
 }
-
-/// Extended client interface that supports mining
-pub trait MiningClient : BlockChainClient {
-	/// import transactions from network/other 3rd party
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, Error>>;
-
-	/// list all transactions
-	fn all_transactions(&self) -> Vec<SignedTransaction>;
-}

ethcore/src/client/test_client.rs

@@ -35,6 +35,9 @@ use executive::Executed;
 use error::{ExecutionError};
 use trace::LocalizedTrace;
 
+use miner::{TransactionImportResult, AccountDetails};
+use error::Error as EthError;
+
 /// Test client.
 pub struct TestBlockChainClient {
 	/// Blocks.
@@ -479,4 +482,12 @@ impl BlockChainClient for TestBlockChainClient {
 	fn block_traces(&self, _trace: BlockID) -> Option<Vec<LocalizedTrace>> {
 		unimplemented!();
 	}
+
+	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, EthError>> {
+		unimplemented!();
+	}
+
+	fn all_transactions(&self) -> Vec<SignedTransaction> {
+		unimplemented!();
+	}
 }

ethcore/src/lib.rs

@@ -90,6 +90,7 @@ extern crate crossbeam;
 extern crate ethjson;
 extern crate bloomchain;
 #[macro_use] extern crate ethcore_ipc as ipc;
+extern crate rayon;
 
 #[cfg(test)] extern crate ethcore_devtools as devtools;
 #[cfg(feature = "jit" )] extern crate evmjit;
@@ -109,6 +110,7 @@ pub mod views;
 pub mod pod_state;
 pub mod engine;
 pub mod migrations;
+pub mod miner;
 
 mod blooms;
 mod db;

ethcore/src/miner/external.rs

@@ -0,0 +1,108 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use util::numbers::U256;
+use util::hash::H256;
+
+/// External miner interface.
+pub trait ExternalMinerService: Send + Sync {
+	/// Submit hashrate for given miner.
+	fn submit_hashrate(&self, hashrate: U256, id: H256);
+
+	/// Total hashrate.
+	fn hashrate(&self) -> U256;
+
+	/// Returns true if external miner is mining.
+	fn is_mining(&self) -> bool;
+}
+
+/// External Miner.
+pub struct ExternalMiner {
+	hashrates: Arc<RwLock<HashMap<H256, U256>>>,
+}
+
+impl Default for ExternalMiner {
+	fn default() -> Self {
+		ExternalMiner {
+			hashrates: Arc::new(RwLock::new(HashMap::new())),
+		}
+	}
+}
+
+impl ExternalMiner {
+	/// Creates new external miner with prefilled hashrates.
+	pub fn new(hashrates: Arc<RwLock<HashMap<H256, U256>>>) -> Self {
+		ExternalMiner {
+			hashrates: hashrates
+		}
+	}
+}
+
+impl ExternalMinerService for ExternalMiner {
+	fn submit_hashrate(&self, hashrate: U256, id: H256) {
+		self.hashrates.write().unwrap().insert(id, hashrate);
+	}
+
+	fn hashrate(&self) -> U256 {
+		self.hashrates.read().unwrap().iter().fold(U256::from(0), |sum, (_, v)| sum + *v)
+	}
+
+	fn is_mining(&self) -> bool {
+		!self.hashrates.read().unwrap().is_empty()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use util::{H256, U256};
+
+	fn miner() -> ExternalMiner {
+		ExternalMiner::default()
+	}
+
+	#[test]
+	fn should_return_that_is_mining_if_there_is_at_least_one_entry() {
+		// given
+		let m = miner();
+		assert_eq!(m.is_mining(), false);
+
+		// when
+		m.submit_hashrate(U256::from(10), H256::from(1));
+
+		// then
+		assert_eq!(m.is_mining(), true);
+	}
+
+	#[test]
+	fn should_sum_up_hashrate() {
+		// given
+		let m = miner();
+		assert_eq!(m.hashrate(), U256::from(0));
+		m.submit_hashrate(U256::from(10), H256::from(1));
+		assert_eq!(m.hashrate(), U256::from(10));
+
+		// when
+		m.submit_hashrate(U256::from(15), H256::from(1));
+		m.submit_hashrate(U256::from(20), H256::from(2));
+
+
+		// then
+		assert_eq!(m.hashrate(), U256::from(35));
+	}
+}

ethcore/src/miner/miner.rs

@@ -0,0 +1,628 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use rayon::prelude::*;
+use std::sync::atomic::AtomicBool;
+
+use util::*;
+use util::keys::store::{AccountService, AccountProvider};
+use views::{BlockView, HeaderView};
+use client::{ExtendedBlockChainClient, BlockID};
+use block::{ClosedBlock, IsBlock};
+use error::*;
+use client::{Executive, Executed, EnvInfo, TransactOptions};
+use transaction::SignedTransaction;
+use receipt::{Receipt};
+use spec::Spec;
+use engine::Engine;
+use miner::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
+
+/// Keeps track of transactions using priority queue and holds currently mined block.
+pub struct Miner {
+	transaction_queue: Mutex<TransactionQueue>,
+
+	// for sealing...
+	force_sealing: bool,
+	sealing_enabled: AtomicBool,
+	sealing_block_last_request: Mutex<u64>,
+	sealing_work: Mutex<UsingQueue<ClosedBlock>>,
+	gas_floor_target: RwLock<U256>,
+	author: RwLock<Address>,
+	extra_data: RwLock<Bytes>,
+	spec: Spec,
+
+	accounts: RwLock<Option<Arc<AccountService>>>,		// TODO: this is horrible since AccountService already contains a single RwLock field. refactor.
+}
+
+impl Default for Miner {
+	fn default() -> Miner {
+		Miner {
+			transaction_queue: Mutex::new(TransactionQueue::new()),
+			force_sealing: false,
+			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: RwLock::new(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()),
+			author: RwLock::new(Address::default()),
+			extra_data: RwLock::new(Vec::new()),
+			accounts: RwLock::new(None),
+			spec: spec,
+		})
+	}
+
+	/// Creates new instance of miner
+	pub fn with_accounts(force_sealing: bool, spec: Spec, accounts: Arc<AccountService>) -> 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()),
+			author: RwLock::new(Address::default()),
+			extra_data: RwLock::new(Vec::new()),
+			accounts: RwLock::new(Some(accounts)),
+			spec: spec,
+		})
+	}
+
+	fn engine(&self) -> &Engine {
+		self.spec.engine.deref()
+	}
+
+	/// Prepares new block for sealing including top transactions from queue.
+	#[cfg_attr(feature="dev", allow(match_same_arms))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
+	fn prepare_sealing(&self, chain: &ExtendedBlockChainClient) {
+		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();
+
+/*
+		// 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 (b, invalid_transactions) = 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();
+				let mut invalid_transactions = HashSet::new();
+				let mut block = old_block.reopen(e, chain.vm_factory());
+				let block_number = block.block().fields().header.number();
+
+				// TODO: push new uncles, too.
+				// TODO: refactor with chain.prepare_sealing
+				for tx in transactions {
+					let hash = tx.hash();
+					let res = block.push_transaction(tx, None);
+					match res {
+						Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, .. })) => {
+							trace!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?}", hash);
+							// Exit early if gas left is smaller then min_tx_gas
+							let min_tx_gas: U256 = x!(21000);	// TODO: figure this out properly.
+							if gas_limit - gas_used < min_tx_gas {
+								break;
+							}
+						},
+						Err(Error::Transaction(TransactionError::AlreadyImported)) => {}	// already have transaction - ignore
+						Err(e) => {
+							invalid_transactions.insert(hash);
+							trace!(target: "miner",
+								   "Error adding transaction to block: number={}. transaction_hash={:?}, Error: {:?}",
+								   block_number, hash, e);
+						},
+						_ => {}	// imported ok
+					}
+				}
+				(Some(block.close()), invalid_transactions)
+			}
+			None => {
+				// block not found - create it.
+				trace!(target: "miner", "No existing work - making new block");
+				chain.prepare_sealing(
+					self.author(),
+					self.gas_floor_target(),
+					self.extra_data(),
+					transactions,
+				)
+			}
+		};
+		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);
+		}
+		if let Some(block) = b {
+			if !block.transactions().is_empty() {
+				trace!(target: "miner", "prepare_sealing: block has transaction - attempting internal seal.");
+				// block with transactions - see if we can seal immediately.
+				let a = self.accounts.read().unwrap();
+				let s = self.engine().generate_seal(block.block(), match *a.deref() {
+					Some(ref x) => Some(x.deref() as &AccountProvider),
+					None => None,
+				});
+				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(_) = chain.import_block(sealed.rlp_bytes()) {
+							trace!(target: "miner", "prepare_sealing: sealed internally and imported. leaving.");
+						} else {
+							warn!("prepare_sealing: ERROR: could not import internally sealed block. WTF?");
+						}
+					} else {
+						warn!("prepare_sealing: ERROR: try_seal failed when given internally generated seal. WTF?");
+					}
+					return;
+				} else {
+					trace!(target: "miner", "prepare_sealing: unable to generate seal internally");
+				}
+			}
+			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);
+			}
+		}
+		trace!(target: "miner", "prepare_sealing: leaving (last={:?})", sealing_work.peek_last_ref().map(|b| b.block().fields().header.hash()));
+	}
+
+	fn update_gas_limit(&self, chain: &ExtendedBlockChainClient) {
+		let gas_limit = HeaderView::new(&chain.best_block_header()).gas_limit();
+		let mut queue = self.transaction_queue.lock().unwrap();
+		queue.set_gas_limit(gas_limit);
+	}
+
+	/// Returns true if we had to prepare new pending block
+	fn enable_and_prepare_sealing(&self, chain: &ExtendedBlockChainClient) -> bool {
+		trace!(target: "miner", "enable_and_prepare_sealing: entering");
+		let have_work = self.sealing_work.lock().unwrap().peek_last_ref().is_some();
+		trace!(target: "miner", "enable_and_prepare_sealing: have_work={}", have_work);
+		if !have_work {
+			self.sealing_enabled.store(true, atomic::Ordering::Relaxed);
+			self.prepare_sealing(chain);
+		}
+		let mut sealing_block_last_request = self.sealing_block_last_request.lock().unwrap();
+		let best_number = chain.chain_info().best_block_number;
+		if *sealing_block_last_request != best_number {
+			trace!(target: "miner", "enable_and_prepare_sealing: Miner received request (was {}, now {}) - waking up.", *sealing_block_last_request, best_number);
+			*sealing_block_last_request = best_number;
+		}
+
+		// Return if
+		!have_work
+	}
+}
+
+const SEALING_TIMEOUT_IN_BLOCKS : u64 = 5;
+
+impl MinerService for Miner {
+
+	fn clear_and_reset(&self, chain: &ExtendedBlockChainClient) {
+		self.transaction_queue.lock().unwrap().clear();
+		self.update_sealing(chain);
+	}
+
+	fn status(&self) -> MinerStatus {
+		let status = self.transaction_queue.lock().unwrap().status();
+		let sealing_work = self.sealing_work.lock().unwrap();
+		MinerStatus {
+			transactions_in_pending_queue: status.pending,
+			transactions_in_future_queue: status.future,
+			transactions_in_pending_block: sealing_work.peek_last_ref().map_or(0, |b| b.transactions().len()),
+		}
+	}
+
+	fn call(&self, chain: &ExtendedBlockChainClient, t: &SignedTransaction) -> Result<Executed, ExecutionError> {
+		let sealing_work = self.sealing_work.lock().unwrap();
+		match sealing_work.peek_last_ref() {
+			Some(work) => {
+				let block = work.block();
+				let header = block.header();
+				let last_hashes = chain.last_hashes();
+				let env_info = EnvInfo {
+					number: header.number(),
+					author: *header.author(),
+					timestamp: header.timestamp(),
+					difficulty: *header.difficulty(),
+					last_hashes: last_hashes,
+					gas_used: U256::zero(),
+					gas_limit: U256::max_value(),
+				};
+				// that's just a copy of the state.
+				let mut state = block.state().clone();
+				let sender = try!(t.sender().map_err(|e| {
+					let message = format!("Transaction malformed: {:?}", e);
+					ExecutionError::TransactionMalformed(message)
+				}));
+				let balance = state.balance(&sender);
+				// give the sender max balance
+				state.sub_balance(&sender, &balance);
+				state.add_balance(&sender, &U256::max_value());
+				let options = TransactOptions { tracing: false, check_nonce: false };
+
+				Executive::new(&mut state, &env_info, self.engine(), chain.vm_factory()).transact(t, options)
+			},
+			None => {
+				chain.call(t)
+			}
+		}
+	}
+
+	fn balance(&self, chain: &ExtendedBlockChainClient, address: &Address) -> U256 {
+		let sealing_work = self.sealing_work.lock().unwrap();
+		sealing_work.peek_last_ref().map_or_else(
+			|| chain.latest_balance(address),
+			|b| b.block().fields().state.balance(address)
+		)
+	}
+
+	fn storage_at(&self, chain: &ExtendedBlockChainClient, address: &Address, position: &H256) -> H256 {
+		let sealing_work = self.sealing_work.lock().unwrap();
+		sealing_work.peek_last_ref().map_or_else(
+			|| chain.latest_storage_at(address, position),
+			|b| b.block().fields().state.storage_at(address, position)
+		)
+	}
+
+	fn nonce(&self, chain: &ExtendedBlockChainClient, address: &Address) -> U256 {
+		let sealing_work = self.sealing_work.lock().unwrap();
+		sealing_work.peek_last_ref().map_or_else(|| chain.latest_nonce(address), |b| b.block().fields().state.nonce(address))
+	}
+
+	fn code(&self, chain: &ExtendedBlockChainClient, address: &Address) -> Option<Bytes> {
+		let sealing_work = self.sealing_work.lock().unwrap();
+		sealing_work.peek_last_ref().map_or_else(|| chain.code(address), |b| b.block().fields().state.code(address))
+	}
+
+	fn set_author(&self, author: Address) {
+		*self.author.write().unwrap() = author;
+	}
+
+	fn set_extra_data(&self, extra_data: Bytes) {
+		*self.extra_data.write().unwrap() = extra_data;
+	}
+
+	/// 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;
+	}
+
+	fn set_minimal_gas_price(&self, min_gas_price: U256) {
+		self.transaction_queue.lock().unwrap().set_minimal_gas_price(min_gas_price);
+	}
+
+	fn minimal_gas_price(&self) -> U256 {
+		*self.transaction_queue.lock().unwrap().minimal_gas_price()
+	}
+
+	fn sensible_gas_price(&self) -> U256 {
+		// 10% above our minimum.
+		*self.transaction_queue.lock().unwrap().minimal_gas_price() * x!(110) / x!(100)
+	}
+
+	fn sensible_gas_limit(&self) -> U256 {
+		*self.gas_floor_target.read().unwrap() / x!(5)
+	}
+
+	fn transactions_limit(&self) -> usize {
+		self.transaction_queue.lock().unwrap().limit()
+	}
+
+	fn set_transactions_limit(&self, limit: usize) {
+		self.transaction_queue.lock().unwrap().set_limit(limit)
+	}
+
+	/// Get the author that we will seal blocks as.
+	fn author(&self) -> Address {
+		*self.author.read().unwrap()
+	}
+
+	/// Get the extra_data that we will seal blocks with.
+	fn extra_data(&self) -> Bytes {
+		self.extra_data.read().unwrap().clone()
+	}
+
+	/// 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()
+	}
+
+	fn import_transactions<T>(&self, 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()
+	}
+
+	fn import_own_transaction<T>(&self, chain: &ExtendedBlockChainClient, transaction: SignedTransaction, fetch_account: T) ->
+		Result<TransactionImportResult, Error>
+		where T: Fn(&Address) -> AccountDetails {
+		let hash = transaction.hash();
+		trace!(target: "own_tx", "Importing transaction: {:?}", transaction);
+
+		let imported = {
+			// Be sure to release the lock before we call enable_and_prepare_sealing
+			let mut transaction_queue = self.transaction_queue.lock().unwrap();
+			let import = transaction_queue.add(transaction, &fetch_account, TransactionOrigin::Local);
+
+			match import {
+				Ok(ref res) => {
+					trace!(target: "own_tx", "Imported transaction to {:?} (hash: {:?})", res, hash);
+					trace!(target: "own_tx", "Status: {:?}", transaction_queue.status());
+				},
+				Err(ref e) => {
+					trace!(target: "own_tx", "Failed to import transaction {:?} (hash: {:?})", e, hash);
+					trace!(target: "own_tx", "Status: {:?}", transaction_queue.status());
+					warn!(target: "own_tx", "Error importing transaction: {:?}", e);
+				},
+			}
+			import
+		};
+
+		if imported.is_ok() {
+			// 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);
+			// If new block has not been prepared (means we already had one)
+			// we need to update sealing
+			if !prepared {
+				self.update_sealing(chain);
+			}
+		}
+
+		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> {
+		// 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()
+			}
+		}
+	}
+
+	fn pending_receipts(&self) -> BTreeMap<H256, Receipt> {
+		match (self.sealing_enabled.load(atomic::Ordering::Relaxed), self.sealing_work.lock().unwrap().peek_last_ref()) {
+			(true, Some(pending)) => {
+				let hashes = pending.transactions()
+					.iter()
+					.map(|t| t.hash());
+
+				let receipts = pending.receipts().clone().into_iter();
+
+				hashes.zip(receipts).collect()
+			},
+			_ => BTreeMap::new()
+		}
+	}
+
+	fn last_nonce(&self, address: &Address) -> Option<U256> {
+		self.transaction_queue.lock().unwrap().last_nonce(address)
+	}
+
+	fn update_sealing(&self, chain: &ExtendedBlockChainClient) {
+		if self.sealing_enabled.load(atomic::Ordering::Relaxed) {
+			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
+				&& !has_local_transactions
+				&& current_no > last_request
+				&& current_no - last_request > SEALING_TIMEOUT_IN_BLOCKS;
+
+			if should_disable_sealing {
+				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) {
+				self.prepare_sealing(chain);
+			}
+		}
+	}
+
+	fn map_sealing_work<F, T>(&self, chain: &ExtendedBlockChainClient, f: F) -> Option<T> where F: FnOnce(&ClosedBlock) -> T {
+		trace!(target: "miner", "map_sealing_work: entering");
+		self.enable_and_prepare_sealing(chain);
+		trace!(target: "miner", "map_sealing_work: sealing prepared");
+		let mut sealing_work = self.sealing_work.lock().unwrap();
+		let ret = sealing_work.use_last_ref();
+		trace!(target: "miner", "map_sealing_work: leaving use_last_ref={:?}", ret.as_ref().map(|b| b.block().fields().header.hash()));
+		ret.map(f)
+	}
+
+	fn submit_seal(&self, chain: &ExtendedBlockChainClient, 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) {
+				Err(_) => {
+					info!(target: "miner", "Mined block rejected, PoW was invalid.");
+					Err(Error::PowInvalid)
+				}
+				Ok(sealed) => {
+					info!(target: "miner", "New block mined, hash: {}", sealed.header().hash());
+					// TODO: commit DB from `sealed.drain` and make a VerifiedBlock to skip running the transactions twice.
+					let b = sealed.rlp_bytes();
+					let h = b.sha3();
+					try!(chain.import_block(b));
+					info!("Block {} submitted and imported.", h);
+					Ok(())
+				}
+			}
+		} else {
+			info!(target: "miner", "Mined block rejected, PoW hash invalid or out of date.");
+			Err(Error::PowHashInvalid)
+		}
+	}
+
+	fn chain_new_blocks(&self, chain: &ExtendedBlockChainClient, _imported: &[H256], _invalid: &[H256], enacted: &[H256], retracted: &[H256]) {
+		fn fetch_transactions(chain: &ExtendedBlockChainClient, hash: &H256) -> Vec<SignedTransaction> {
+			let block = chain
+				.block(BlockID::Hash(*hash))
+				// Client should send message after commit to db and inserting to chain.
+				.expect("Expected in-chain blocks.");
+			let block = BlockView::new(&block);
+			block.transactions()
+		}
+
+		// 1. We ignore blocks that were `imported` (because it means that they are not in canon-chain, and transactions
+		//	  should be still available in the queue.
+		// 2. We ignore blocks that are `invalid` because it doesn't have any meaning in terms of the transactions that
+		//    are in those blocks
+
+		// First update gas limit in transaction queue
+		self.update_gas_limit(chain);
+
+		// Then import all transactions...
+		{
+			let out_of_chain = retracted
+				.par_iter()
+				.map(|h| fetch_transactions(chain, h));
+			out_of_chain.for_each(|txs| {
+				// populate sender
+				for tx in &txs {
+					let _sender = tx.sender();
+				}
+				let _ = self.import_transactions(txs, |a| AccountDetails {
+					nonce: chain.latest_nonce(a),
+					balance: chain.latest_balance(a),
+				});
+			});
+		}
+
+		// ...and at the end remove old ones
+		{
+			let in_chain = enacted
+				.par_iter()
+				.map(|h: &H256| fetch_transactions(chain, h));
+
+			in_chain.for_each(|mut txs| {
+				let mut transaction_queue = self.transaction_queue.lock().unwrap();
+
+				let to_remove = txs.drain(..)
+						.map(|tx| {
+							tx.sender().expect("Transaction is in block, so sender has to be defined.")
+						})
+						.collect::<HashSet<Address>>();
+				for sender in to_remove.into_iter() {
+					transaction_queue.remove_all(sender, chain.latest_nonce(&sender));
+				}
+			});
+		}
+
+		self.update_sealing(chain);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+
+	use MinerService;
+	use super::{Miner};
+	use util::*;
+	use ethcore::client::{TestBlockChainClient, EachBlockWith};
+	use ethcore::block::*;
+
+	// TODO [ToDr] To uncomment` when TestBlockChainClient can actually return a ClosedBlock.
+	#[ignore]
+	#[test]
+	fn should_prepare_block_to_seal() {
+		// given
+		let client = TestBlockChainClient::default();
+		let miner = Miner::default();
+
+		// when
+		let sealing_work = miner.map_sealing_work(&client, |_| ());
+		assert!(sealing_work.is_some(), "Expected closed block");
+	}
+
+	#[ignore]
+	#[test]
+	fn should_still_work_after_a_couple_of_blocks() {
+		// given
+		let client = TestBlockChainClient::default();
+		let miner = Miner::default();
+
+		let res = miner.map_sealing_work(&client, |b| b.block().fields().header.hash());
+		assert!(res.is_some());
+		assert!(miner.submit_seal(&client, res.unwrap(), vec![]).is_ok());
+
+		// two more blocks mined, work requested.
+		client.add_blocks(1, EachBlockWith::Uncle);
+		miner.map_sealing_work(&client, |b| b.block().fields().header.hash());
+
+		client.add_blocks(1, EachBlockWith::Uncle);
+		miner.map_sealing_work(&client, |b| b.block().fields().header.hash());
+
+		// solution to original work submitted.
+		assert!(miner.submit_seal(&client, res.unwrap(), vec![]).is_ok());
+	}
+}

ethcore/src/miner/mod.rs

@@ -0,0 +1,173 @@
+// 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/>.
+
+#![warn(missing_docs)]
+#![cfg_attr(all(nightly, feature="dev"), feature(plugin))]
+#![cfg_attr(all(nightly, feature="dev"), plugin(clippy))]
+
+//! Miner module
+//! Keeps track of transactions and mined block.
+//!
+//! Usage example:
+//!
+//! ```rust
+//! extern crate ethcore_util as util;
+//! extern crate ethcore;
+//! use std::env;
+//! use util::network::{NetworkService, NetworkConfiguration};
+//! use client::{Client, ClientConfig};
+//! use ethereum;
+//! use ethcore::miner::{Miner, MinerService};
+//!
+//! fn main() {
+//!		let miner: Miner = Miner::default();
+//!		// get status
+//!		assert_eq!(miner.status().transactions_in_pending_queue, 0);
+//!
+//!		// Check block for sealing
+//!		//assert!(miner.sealing_block(client.deref()).lock().unwrap().is_some());
+//! }
+//! ```
+
+mod miner;
+mod external;
+mod transaction_queue;
+
+pub use self::transaction_queue::{TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
+pub use self::miner::{Miner};
+pub use self::external::{ExternalMiner, ExternalMinerService};
+
+use std::collections::BTreeMap;
+use util::{H256, U256, Address, Bytes};
+use client::{ExtendedBlockChainClient, Executed};
+use block::ClosedBlock;
+use receipt::Receipt;
+use error::{Error, ExecutionError};
+use transaction::SignedTransaction;
+
+/// Miner client API
+pub trait MinerService : Send + Sync {
+
+	/// Returns miner's status.
+	fn status(&self) -> MinerStatus;
+
+	/// Get the author that we will seal blocks as.
+	fn author(&self) -> Address;
+
+	/// Set the author that we will seal blocks as.
+	fn set_author(&self, author: Address);
+
+	/// Get the extra_data that we will seal blocks with.
+	fn extra_data(&self) -> Bytes;
+
+	/// Set the extra_data that we will seal blocks with.
+	fn set_extra_data(&self, extra_data: Bytes);
+
+	/// Get current minimal gas price for transactions accepted to queue.
+	fn minimal_gas_price(&self) -> U256;
+
+	/// 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.
+	fn gas_floor_target(&self) -> U256;
+
+	/// Set the gas limit we wish to target when sealing a new block.
+	fn set_gas_floor_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);
+
+	/// Imports transactions to transaction queue.
+	fn import_transactions<T>(&self, transactions: Vec<SignedTransaction>, fetch_account: T) ->
+		Vec<Result<TransactionImportResult, Error>>
+		where T: Fn(&Address) -> AccountDetails, Self: Sized;
+
+	/// Imports own (node owner) transaction to queue.
+	fn import_own_transaction<T>(&self, chain: &ExtendedBlockChainClient, transaction: SignedTransaction, fetch_account: T) ->
+		Result<TransactionImportResult, Error>
+		where T: Fn(&Address) -> AccountDetails, Self: Sized;
+
+	/// Returns hashes of transactions currently in pending
+	fn pending_transactions_hashes(&self) -> Vec<H256>;
+
+	/// Removes all transactions from the queue and restart mining operation.
+	fn clear_and_reset(&self, chain: &ExtendedBlockChainClient);
+
+	/// Called when blocks are imported to chain, updates transactions queue.
+	fn chain_new_blocks(&self, chain: &ExtendedBlockChainClient, imported: &[H256], invalid: &[H256], enacted: &[H256], retracted: &[H256]);
+
+	/// New chain head event. Restart mining operation.
+	fn update_sealing(&self, chain: &ExtendedBlockChainClient);
+
+	/// Submit `seal` as a valid solution for the header of `pow_hash`.
+	/// Will check the seal, but not actually insert the block into the chain.
+	fn submit_seal(&self, chain: &ExtendedBlockChainClient, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error>;
+
+	/// Get the sealing work package and if `Some`, apply some transform.
+	fn map_sealing_work<F, T>(&self, chain: &ExtendedBlockChainClient, f: F) -> Option<T>
+		where F: FnOnce(&ClosedBlock) -> T, Self: Sized;
+
+	/// Query pending transactions for hash.
+	fn transaction(&self, hash: &H256) -> Option<SignedTransaction>;
+
+	/// Get a list of all transactions.
+	fn all_transactions(&self) -> Vec<SignedTransaction>;
+
+	/// Get a list of all pending transactions.
+	fn pending_transactions(&self) -> Vec<SignedTransaction>;
+
+	/// Get a list of all pending receipts.
+	fn pending_receipts(&self) -> BTreeMap<H256, Receipt>;
+
+	/// Returns highest transaction nonce for given address.
+	fn last_nonce(&self, address: &Address) -> Option<U256>;
+
+	/// Suggested gas price.
+	fn sensible_gas_price(&self) -> U256 { x!(20000000000u64) }
+
+	/// Suggested gas limit.
+	fn sensible_gas_limit(&self) -> U256 { x!(21000) }
+
+	/// Latest account balance in pending state.
+	fn balance(&self, chain: &ExtendedBlockChainClient, address: &Address) -> U256;
+
+	/// Call into contract code using pending state.
+	fn call(&self, chain: &ExtendedBlockChainClient, t: &SignedTransaction) -> Result<Executed, ExecutionError>;
+
+	/// Get storage value in pending state.
+	fn storage_at(&self, chain: &ExtendedBlockChainClient, address: &Address, position: &H256) -> H256;
+
+	/// Get account nonce in pending state.
+	fn nonce(&self, chain: &ExtendedBlockChainClient, address: &Address) -> U256;
+
+	/// Get contract code in pending state.
+	fn code(&self, chain: &ExtendedBlockChainClient, address: &Address) -> Option<Bytes>;
+}
+
+/// Mining status
+#[derive(Debug)]
+pub struct MinerStatus {
+	/// Number of transactions in queue with state `pending` (ready to be included in block)
+	pub transactions_in_pending_queue: usize,
+	/// Number of transactions in queue with state `future` (not yet ready to be included in block)
+	pub transactions_in_future_queue: usize,
+	/// Number of transactions included in currently mined block
+	pub transactions_in_pending_block: usize,
+}

ethcore/src/service.rs

@@ -21,6 +21,7 @@ use util::panics::*;
 use spec::Spec;
 use error::*;
 use client::{Client, ClientConfig};
+use miner::Miner;
 
 /// Message type for external and internal events
 #[derive(Clone)]
@@ -54,14 +55,14 @@ pub struct ClientService {
 
 impl ClientService {
 	/// Start the service in a separate thread.
-	pub fn start(config: ClientConfig, spec: Spec, net_config: NetworkConfiguration, db_path: &Path) -> Result<ClientService, Error> {
+	pub fn start(config: ClientConfig, spec: Spec, net_config: NetworkConfiguration, db_path: &Path, miner: Arc<Miner>) -> Result<ClientService, Error> {
 		let panic_handler = PanicHandler::new_in_arc();
 		let mut net_service = try!(NetworkService::start(net_config));
 		panic_handler.forward_from(&net_service);
 
 		info!("Starting {}", net_service.host_info());
 		info!("Configured for {} using {:?} engine", spec.name, spec.engine.name());
-		let client = try!(Client::new(config, spec, db_path, net_service.io().channel()));
+		let client = try!(Client::new(config, spec, db_path, miner, net_service.io().channel()));
 		panic_handler.forward_from(client.deref());
 		let client_io = Arc::new(ClientIoHandler {
 			client: client.clone()