flush work

ethcore/src/client/client.rs

@@ -38,7 +38,9 @@ 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, DatabaseCompactionProfile, BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics};
+use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, DatabaseCompactionProfile,
+	BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics, TransactionImportError,
+	BlockImportError, TransactionImportResult};
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -49,7 +51,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};
+use miner::{Miner, MinerService, AccountDetails};
 
 const MAX_TX_QUEUE_SIZE: usize = 4096;
 
@@ -648,17 +650,17 @@ impl BlockChainClient for Client {
 		self.chain.block_receipts(hash).map(|receipts| rlp::encode(&receipts).to_vec())
 	}
 
-	fn import_block(&self, bytes: Bytes) -> ImportResult {
+	fn import_block(&self, bytes: Bytes) -> Result<H256, BlockImportError> {
 		{
 			let header = BlockView::new(&bytes).header_view();
 			if self.chain.is_known(&header.sha3()) {
-				return Err(ImportError::AlreadyInChain.into());
+				return Err(BlockImportError::Import(ImportError::AlreadyInChain));
 			}
 			if self.block_status(BlockID::Hash(header.parent_hash())) == BlockStatus::Unknown {
-				return Err(BlockError::UnknownParent(header.parent_hash()).into());
+				return Err(BlockImportError::Block(BlockError::UnknownParent(header.parent_hash())));
 			}
 		}
-		self.block_queue.import_block(bytes)
+		Ok(try!(self.block_queue.import_block(bytes)))
 	}
 
 	fn queue_info(&self) -> BlockQueueInfo {
@@ -772,7 +774,7 @@ impl BlockChainClient for Client {
 		self.build_last_hashes(self.chain.best_block_hash())
 	}
 
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, Error>> {
+	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, TransactionImportError>> {
 		let fetch_account = |a: &Address| AccountDetails {
 			nonce: self.latest_nonce(a),
 			balance: self.latest_balance(a),

ethcore/src/client/mod.rs

@@ -47,7 +47,6 @@ use error::{ImportResult, ExecutionError};
 use receipt::LocalizedReceipt;
 use trace::LocalizedTrace;
 use evm::Factory as EvmFactory;
-use miner::{TransactionImportResult};
 use error::Error as EthError;
 pub use block_import_error::BlockImportError;
 pub use transaction_import::{TransactionImportResult, TransactionImportError};
@@ -147,7 +146,7 @@ pub trait BlockChainClient : Sync + Send {
 	fn block_receipts(&self, hash: &H256) -> Option<Bytes>;
 
 	/// Import a block into the blockchain.
-	fn import_block(&self, bytes: Bytes) -> ImportResult;
+	fn import_block(&self, bytes: Bytes) -> Result<H256, BlockImportError>;
 
 	/// Get block queue information.
 	fn queue_info(&self) -> BlockQueueInfo;

ethcore/src/client/test_client.rs

@@ -20,7 +20,9 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use util::*;
 use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action};
 use blockchain::TreeRoute;
-use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID, TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics};
+use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID,
+	TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics,
+	TransactionImportError, BlockImportError};
 use header::{Header as BlockHeader, BlockNumber};
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
@@ -402,7 +404,7 @@ impl BlockChainClient for TestBlockChainClient {
 		None
 	}
 
-	fn import_block(&self, b: Bytes) -> ImportResult {
+	fn import_block(&self, b: Bytes) -> Result<H256, BlockImportError> {
 		let header = Rlp::new(&b).val_at::<BlockHeader>(0);
 		let h = header.hash();
 		let number: usize = header.number as usize;
@@ -487,7 +489,7 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, EthError>> {
+	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, TransactionImportError>> {
 		let nonces = self.nonces.read().unwrap();
 		let balances = self.balances.read().unwrap();
 		let fetch_account = |a: &Address| AccountDetails {

ethcore/src/error.rs

@@ -20,8 +20,10 @@ use util::*;
 use header::BlockNumber;
 use basic_types::LogBloom;
 use client::Error as ClientError;
-
 pub use types::executed::ExecutionError;
+use ipc::binary::{BinaryConvertError, BinaryConvertable};
+use types::transaction_import::TransactionImportError;
+use types::block_import_error::BlockImportError;
 
 #[derive(Debug, PartialEq)]
 /// Errors concerning transaction processing.
@@ -250,7 +252,7 @@ impl fmt::Display for Error {
 }
 
 /// Result of import block operation.
-pub type ImportResult = Result<H256, BlockImportError>;
+pub type ImportResult = Result<H256, Error>;
 
 impl From<ClientError> for Error {
 	fn from(err: ClientError) -> Error {

ethcore/src/miner/miner.rs

@@ -29,8 +29,10 @@ use transaction::SignedTransaction;
 use receipt::{Receipt};
 use spec::Spec;
 use engine::Engine;
-use miner::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
+use miner::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionOrigin};
 use miner::work_notify::WorkPoster;
+use client::TransactionImportResult;
+
 
 /// Different possible definitions for pending transaction set.
 #[derive(Debug)]

ethcore/src/miner/mod.rs

@@ -47,9 +47,10 @@ mod external;
 mod transaction_queue;
 mod work_notify;
 
-pub use self::transaction_queue::{TransactionQueue, AccountDetails, TransactionImportResult, TransactionOrigin};
+pub use self::transaction_queue::{TransactionQueue, AccountDetails, TransactionOrigin};
 pub use self::miner::{Miner, MinerOptions, PendingSet};
 pub use self::external::{ExternalMiner, ExternalMinerService};
+pub use client::TransactionImportResult;
 
 use std::collections::BTreeMap;
 use util::{H256, U256, Address, Bytes};

ethcore/src/miner/transaction_queue.rs

@@ -90,6 +90,7 @@ use util::hash::{Address, H256};
 use util::table::*;
 use transaction::*;
 use error::{Error, TransactionError};
+use client::TransactionImportResult;
 
 /// Transaction origin
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -309,15 +310,6 @@ pub struct TransactionQueueStatus {
 	pub future: usize,
 }
 
-#[derive(Debug, PartialEq)]
-/// Represents the result of importing transaction.
-pub enum TransactionImportResult {
-	/// Transaction was imported to current queue.
-	Current,
-	/// Transaction was imported to future queue.
-	Future
-}
-
 /// Details of account
 pub struct AccountDetails {
 	/// Most recent account nonce

ethcore/src/types/transaction_import.rs

@@ -16,8 +16,10 @@
 
 //! Transaction import result related types
 
-use ipc::binary::BinaryConvertError;
+use ipc::binary::{BinaryConvertError, BinaryConvertable};
 use std::collections::VecDeque;
+use error::{TransactionError, Error};
+use std::mem;
 
 #[derive(Debug, Clone, PartialEq)]
 /// Represents the result of importing transaction.
@@ -36,10 +38,10 @@ pub enum TransactionImportError {
 	Other(String),
 }
 
-impl From<Error> for BlockImportError {
+impl From<Error> for TransactionImportError {
 	fn from(e: Error) -> Self {
 		match e {
-			Error::Transaction(transaction_error) => TransactionImportError::Transaction(block_error),
+			Error::Transaction(transaction_error) => TransactionImportError::Transaction(transaction_error),
 			_ => TransactionImportError::Other(format!("other block import error: {:?}", e)),
 		}
 	}