Merge branch 'master' into tx_queue_live

Conflicts:
	sync/src/chain.rs

rpc/src/v1/impls/eth.rs

@@ -19,7 +19,7 @@ use std::collections::HashSet;
 use std::sync::{Arc, Weak, Mutex};
 use std::ops::Deref;
 use ethsync::{SyncProvider, SyncState};
-use ethminer::{MinerService};
+use ethminer::{MinerService, AccountDetails};
 use jsonrpc_core::*;
 use util::numbers::*;
 use util::sha3::*;
@@ -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())))
 			})
@@ -379,7 +381,10 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM>
 						let signed_transaction = transaction.sign(&secret);
 						let hash = signed_transaction.hash();
 
-						let import = miner.import_transactions(vec![signed_transaction], |a: &Address| client.nonce(a));
+						let import = miner.import_transactions(vec![signed_transaction], |a: &Address| AccountDetails {
+							nonce: client.nonce(a),
+							balance: client.balance(a),
+						});
 						match import {
 							Ok(_) => to_value(&hash),
 							Err(e) => {

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

@@ -14,13 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::{Address, H256, U256, Bytes};
+use util::{Address, H256, Bytes};
 use util::standard::*;
 use ethcore::error::Error;
 use ethcore::client::BlockChainClient;
 use ethcore::block::ClosedBlock;
 use ethcore::transaction::SignedTransaction;
-use ethminer::{MinerService, MinerStatus};
+use ethminer::{MinerService, MinerStatus, AccountDetails};
 
 pub struct TestMinerService {
 	pub imported_transactions: RwLock<Vec<H256>>,
@@ -39,10 +39,17 @@ 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!(); }
+	fn import_transactions<T>(&self, _transactions: Vec<SignedTransaction>, _fetch_account: T) -> Result<(), Error>
+		where T: Fn(&Address) -> AccountDetails { unimplemented!(); }
 
 	/// Returns hashes of transactions currently in pending
 	fn pending_transactions_hashes(&self) -> Vec<H256> { unimplemented!(); }