Merge pull request #750 from ethcore/tx_block_pending

Returning number of transactions pending in block not queue

miner/src/lib.rs

@@ -42,7 +42,7 @@
 //!
 //!		let miner: Miner = Miner::default();
 //!		// get status
-//!		assert_eq!(miner.status().transaction_queue_pending, 0);
+//!		assert_eq!(miner.status().transactions_in_pending_queue, 0);
 //!
 //!		// Check block for sealing
 //!		miner.prepare_sealing(client.deref());
@@ -105,7 +105,9 @@ pub trait MinerService : Send + Sync {
 /// Mining status
 pub struct MinerStatus {
 	/// Number of transactions in queue with state `pending` (ready to be included in block)
-	pub transaction_queue_pending: usize,
+	pub transactions_in_pending_queue: usize,
 	/// Number of transactions in queue with state `future` (not yet ready to be included in block)
-	pub transaction_queue_future: usize,
+	pub transactions_in_future_queue: usize,
+	/// Number of transactions included in currently mined block
+	pub transactions_in_pending_block: usize,
 }

miner/src/miner.rs

@@ -22,7 +22,7 @@ use std::sync::atomic::AtomicBool;
 use util::{H256, U256, Address, Bytes, Uint};
 use ethcore::views::{BlockView};
 use ethcore::client::{BlockChainClient, BlockId};
-use ethcore::block::{ClosedBlock};
+use ethcore::block::{ClosedBlock, IsBlock};
 use ethcore::error::{Error};
 use ethcore::transaction::SignedTransaction;
 use super::{MinerService, MinerStatus, TransactionQueue};
@@ -104,9 +104,11 @@ impl MinerService for Miner {
 
 	fn status(&self) -> MinerStatus {
 		let status = self.transaction_queue.lock().unwrap().status();
+		let block = self.sealing_block.lock().unwrap();
 		MinerStatus {
-			transaction_queue_pending: status.pending,
-			transaction_queue_future: status.future,
+			transactions_in_pending_queue: status.pending,
+			transactions_in_future_queue: status.future,
+			transactions_in_pending_block: block.as_ref().map_or(0, |b| b.transactions().len()),
 		}
 	}
 

rpc/src/v1/impls/eth.rs

@@ -236,7 +236,9 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM>
 	fn block_transaction_count_by_number(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(BlockNumber,)>(params)
 			.and_then(|(block_number,)| match block_number {
-				BlockNumber::Pending => to_value(&U256::from(take_weak!(self.miner).status().transaction_queue_pending)),
+				BlockNumber::Pending => to_value(
+					&U256::from(take_weak!(self.miner).status().transactions_in_pending_block)
+				),
 				_ => to_value(&take_weak!(self.client).block(block_number.into())
 						.map_or_else(U256::zero, |bytes| U256::from(BlockView::new(&bytes).transactions_count())))
 			})

rpc/src/v1/tests/eth.rs

@@ -242,6 +242,20 @@ fn rpc_eth_transaction_count_by_number() {
 	assert_eq!(EthTester::default().io.handle_request(request), Some(response.to_owned()));
 }
 
+#[test]
+fn rpc_eth_transaction_count_by_number_pending() {
+	let request = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_getBlockTransactionCountByNumber",
+		"params": ["pending"],
+		"id": 1
+	}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x01","id":1}"#;
+
+	assert_eq!(EthTester::default().io.handle_request(request), Some(response.to_owned()));
+}
+
+
 #[test]
 fn rpc_eth_uncle_count_by_block_hash() {
 	let request = r#"{

rpc/src/v1/tests/helpers/miner_service.rs

@@ -39,7 +39,13 @@ impl Default for TestMinerService {
 impl MinerService for TestMinerService {
 
 	/// Returns miner's status.
-	fn status(&self) -> MinerStatus { unimplemented!(); }
+	fn status(&self) -> MinerStatus {
+		MinerStatus {
+			transactions_in_pending_queue: 0,
+			transactions_in_future_queue: 0,
+			transactions_in_pending_block: 1
+		}
+	}
 
 	/// Imports transactions to transaction queue.
 	fn import_transactions<T>(&self, _transactions: Vec<SignedTransaction>, _fetch_nonce: T) -> Result<(), Error> where T: Fn(&Address) -> U256 { unimplemented!(); }

sync/src/chain.rs

@@ -403,7 +403,7 @@ impl ChainSync {
 							self.remove_downloaded_blocks(number + 1);
 						}
 						if self.have_common_block && number < self.current_base_block() + 1 {
-							// unkown header 
+							// unkown header
 							debug!(target: "sync", "Old block header {:?} ({}) is unknown, restarting sync", hash, number);
 							self.restart(io);
 							return Ok(());
@@ -1633,14 +1633,14 @@ mod tests {
 
 		// when
 		sync.chain_new_blocks(&mut io, &[], &[], &[], &good_blocks);
-		assert_eq!(sync.miner.status().transaction_queue_future, 0);
-		assert_eq!(sync.miner.status().transaction_queue_pending, 1);
+		assert_eq!(sync.miner.status().transactions_in_future_queue, 0);
+		assert_eq!(sync.miner.status().transactions_in_pending_queue, 1);
 		sync.chain_new_blocks(&mut io, &good_blocks, &[], &[], &retracted_blocks);
 
 		// then
 		let status = sync.miner.status();
-		assert_eq!(status.transaction_queue_pending, 1);
-		assert_eq!(status.transaction_queue_future, 0);
+		assert_eq!(status.transactions_in_pending_queue, 1);
+		assert_eq!(status.transactions_in_future_queue, 0);
 	}
 
 	#[test]