refactored to merge client & client

ethcore/Cargo.toml

@@ -29,7 +29,7 @@ ethcore-devtools = { path = "../devtools" }
 ethjson = { path = "../json" }
 bloomchain = "0.1"
 "ethcore-ipc" = { path = "../ipc/rpc" }
-ethminer = { path = "../miner" }
+rayon = "0.3.1"
 
 [features]
 jit = ["evmjit"]

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/miner.rs

@@ -19,16 +19,16 @@ use std::sync::atomic::AtomicBool;
 
 use util::*;
 use util::keys::store::{AccountService, AccountProvider};
-use ethcore::views::{BlockView, HeaderView};
-use ethcore::client::{ExtendedBlockChainClient, BlockID};
-use ethcore::block::{ClosedBlock, IsBlock};
-use ethcore::error::*;
-use ethcore::client::{Executive, Executed, EnvInfo, TransactOptions};
-use ethcore::transaction::SignedTransaction;
-use ethcore::receipt::{Receipt};
-use ethcore::spec::Spec;
-use ethcore::engine::Engine;
-use super::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
+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 {

ethcore/src/miner/mod.rs

@@ -26,12 +26,11 @@
 //! ```rust
 //! extern crate ethcore_util as util;
 //! extern crate ethcore;
-//! extern crate ethminer;
 //! use std::env;
 //! use util::network::{NetworkService, NetworkConfiguration};
-//! use ethcore::client::{Client, ClientConfig};
-//! use ethcore::ethereum;
-//! use ethminer::{Miner, MinerService};
+//! use client::{Client, ClientConfig};
+//! use ethereum;
+//! use ethcore::miner::{Miner, MinerService};
 //!
 //! fn main() {
 //!		let miner: Miner = Miner::default();
@@ -43,30 +42,21 @@
 //! }
 //! ```
 
-
-#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate ethcore_util as util;
-extern crate ethcore;
-extern crate env_logger;
-extern crate rayon;
-
 mod miner;
 mod external;
 mod transaction_queue;
 
-pub use transaction_queue::{TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
-pub use miner::{Miner};
-pub use external::{ExternalMiner, ExternalMinerService};
+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 ethcore::client::{ExtendedBlockChainClient, Executed};
-use ethcore::block::ClosedBlock;
-use ethcore::receipt::Receipt;
-use ethcore::error::{Error, ExecutionError};
-use ethcore::transaction::SignedTransaction;
+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 {

ethcore/src/miner/transaction_queue.rs

@@ -89,8 +89,8 @@ use std::collections::{HashMap, BTreeSet};
 use util::numbers::{Uint, U256};
 use util::hash::{Address, H256};
 use util::table::*;
-use ethcore::transaction::*;
-use ethcore::error::{Error, TransactionError};
+use transaction::*;
+use error::{Error, TransactionError};
 
 /// Transaction origin
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]

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()