Merge branch 'master' into tx_queue_timeout

Conflicts:
	ethcore/src/client/test_client.rs
	miner/src/miner.rs

ethcore/Cargo.toml

@@ -17,7 +17,7 @@ ethcore-util = { path = "../util" }
 evmjit = { path = "../evmjit", optional = true }
 ethash = { path = "../ethash" }
 num_cpus = "0.2"
-clippy = { version = "0.0.50", optional = true }
+clippy = { version = "0.0.54", optional = true }
 crossbeam = "0.1.5"
 lazy_static = "0.1"
 ethcore-devtools = { path = "../devtools" }

ethcore/src/client/client.rs

@@ -391,7 +391,8 @@ impl<V> BlockChainClient 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> {
+	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();
 		let h = self.chain.best_block_hash();
 
@@ -417,21 +418,40 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 
 		// Add transactions
 		let block_number = b.block().header().number();
+		let min_tx_gas = U256::from(self.engine.schedule(&b.env_info()).tx_gas);
+		let mut invalid_transactions = HashSet::new();
+
 		for tx in transactions {
+			// Push transaction to block
+			let hash = tx.hash();
 			let import = b.push_transaction(tx, None);
-			if let Err(e) = import {
-				trace!("Error adding transaction to block: number={}. Error: {:?}", block_number, e);
+
+			match import {
+				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
+					if gas_limit - gas_used < min_tx_gas {
+						break;
+					}
+				},
+				Err(e) => {
+					invalid_transactions.insert(hash);
+					trace!(target: "miner",
+						   "Error adding transaction to block: number={}. transaction_hash={:?}, Error: {:?}",
+						   block_number, hash, e);
+				},
+				_ => {}
 			}
 		}
 
 		// And close
 		let b = b.close();
-		trace!("Sealing: number={}, hash={}, diff={}",
+		trace!(target: "miner", "Sealing: number={}, hash={}, diff={}",
 			   b.block().header().number(),
 			   b.hash(),
 			   b.block().header().difficulty()
 		);
-		Some(b)
+		Some((b, invalid_transactions))
 	}
 
 	fn block_header(&self, id: BlockId) -> Option<Bytes> {

ethcore/src/client/mod.rs

@@ -26,6 +26,7 @@ pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig};
 pub use self::ids::{BlockId, TransactionId};
 pub use self::test_client::{TestBlockChainClient, EachBlockWith};
 
+use std::collections::HashSet;
 use util::bytes::Bytes;
 use util::hash::{Address, H256, H2048};
 use util::numbers::U256;
@@ -110,7 +111,8 @@ pub trait BlockChainClient : Sync + Send {
 
 	// TODO [todr] Should be moved to miner crate eventually.
 	/// Returns ClosedBlock prepared for sealing.
-	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>) -> Option<ClosedBlock>;
+	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>)
+		-> Option<(ClosedBlock, HashSet<H256>)>;
 
 	// TODO [todr] Should be moved to miner crate eventually.
 	/// Attempts to seal given block. Returns `SealedBlock` on success and the same block in case of error.

ethcore/src/client/test_client.rs

@@ -111,6 +111,7 @@ impl TestBlockChainClient {
 			header.difficulty = From::from(n);
 			header.parent_hash = self.last_hash.read().unwrap().clone();
 			header.number = n as BlockNumber;
+			header.gas_limit = U256::from(1_000_000);
 			let uncles = match with {
 				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
 					let mut uncles = RlpStream::new_list(1);
@@ -217,7 +218,7 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn prepare_sealing(&self, _author: Address, _gas_floor_target: U256, _extra_data: Bytes, _transactions: Vec<SignedTransaction>) -> Option<ClosedBlock> {
+	fn prepare_sealing(&self, _author: Address, _gas_floor_target: U256, _extra_data: Bytes, _transactions: Vec<SignedTransaction>) -> Option<(ClosedBlock, HashSet<H256>)> {
 		None
 	}
 

ethcore/src/error.rs

@@ -83,6 +83,13 @@ pub enum TransactionError {
 		/// Transaction cost
 		cost: U256,
 	},
+	/// Transactions gas is higher then current gas limit
+	GasLimitExceeded {
+		/// Current gas limit
+		limit: U256,
+		/// Declared transaction gas
+		got: U256,
+	},
 	/// Transaction's gas limit (aka gas) is invalid.
 	InvalidGasLimit(OutOfBounds<U256>),
 }

ethcore/src/evm/ext.rs

@@ -67,6 +67,7 @@ pub trait Ext {
 	/// Returns Err, if we run out of gas.
 	/// Otherwise returns call_result which contains gas left
 	/// and true if subcall was successfull.
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	fn call(&mut self,
 			gas: &U256,
 			sender_address: &Address,

ethcore/src/evm/interpreter.rs

@@ -521,6 +521,7 @@ impl Interpreter {
 		Ok(overflowing!(offset.overflowing_add(size.clone())))
 	}
 
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	fn exec_instruction(&self,
 						gas: Gas,
 						params: &ActionParams,

ethcore/src/tests/client.rs

@@ -144,7 +144,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_sealing(Address::default(), x!(31415926), vec![], vec![]).unwrap();
+	let b = client.prepare_sealing(Address::default(), x!(31415926), vec![], vec![]).unwrap().0;
 
 	assert_eq!(*b.block().header().parent_hash(), BlockView::new(&dummy_blocks[0]).header_view().sha3());
 	assert!(client.try_seal(b, vec![]).is_ok());