implemented rpc eth_estimateGas method, added tests for rpc eth_call and eth_estimateGas

ethcore/src/client/mod.rs

@@ -25,6 +25,7 @@ pub use self::client::*;
 pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig};
 pub use self::ids::{BlockId, TransactionId};
 pub use self::test_client::{TestBlockChainClient, EachBlockWith};
+pub use executive::Executed;
 
 use std::collections::HashSet;
 use util::bytes::Bytes;
@@ -38,7 +39,6 @@ use transaction::{LocalizedTransaction, SignedTransaction};
 use log_entry::LocalizedLogEntry;
 use filter::Filter;
 use error::{ImportResult, Error};
-use executive::Executed;
 
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
 pub trait BlockChainClient : Sync + Send {

ethcore/src/client/test_client.rs

@@ -50,6 +50,8 @@ pub struct TestBlockChainClient {
 	pub storage: RwLock<HashMap<(Address, H256), H256>>,
 	/// Code.
 	pub code: RwLock<HashMap<Address, Bytes>>,
+	/// Execution result.
+	pub execution_result: RwLock<Option<Executed>>,
 }
 
 #[derive(Clone)]
@@ -84,12 +86,18 @@ impl TestBlockChainClient {
 			balances: RwLock::new(HashMap::new()),
 			storage: RwLock::new(HashMap::new()),
 			code: RwLock::new(HashMap::new()),
+			execution_result: RwLock::new(None),
 		};
 		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
 		client.genesis_hash = client.last_hash.read().unwrap().clone();
 		client
 	}
 
+	/// Set the execution result.
+	pub fn set_execution_result(&self, result: Executed) {
+		*self.execution_result.write().unwrap() = Some(result);
+	}
+
 	/// Set the balance of account `address` to `balance`.
 	pub fn set_balance(&self, address: Address, balance: U256) {
 		self.balances.write().unwrap().insert(address, balance);
@@ -185,7 +193,7 @@ impl TestBlockChainClient {
 
 impl BlockChainClient for TestBlockChainClient {
 	fn call(&self, _t: &SignedTransaction) -> Result<Executed, Error> {
-		unimplemented!()
+		Ok(self.execution_result.read().unwrap().clone().unwrap())
 	}
 
 	fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {

ethcore/src/executive.rs

@@ -37,7 +37,7 @@ pub fn contract_address(address: &Address, nonce: &U256) -> Address {
 }
 
 /// Transaction execution receipt.
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct Executed {
 	/// Gas paid up front for execution of transaction.
 	pub gas: U256,

rpc/src/v1/impls/eth.rs

@@ -432,9 +432,11 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM>
 						let transaction: EthTransaction = transaction_request.into();
 						let signed_transaction = transaction.sign(&secret);
 
-						to_value(&client.call(&signed_transaction)
+						let gas_used = client.call(&signed_transaction)
-								 .map(|e| e.gas_used)
+							.map(|e| e.gas_used + e.refunded)
-								 .unwrap_or(U256::zero()))
+							.unwrap_or(U256::zero());
+
+						to_value(&gas_used)
 					},
 					Err(_) => { to_value(&U256::zero()) }
 				}

rpc/src/v1/tests/eth.rs

@@ -18,8 +18,8 @@ use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 use jsonrpc_core::IoHandler;
 use util::hash::{Address, H256};
-use util::numbers::U256;
+use util::numbers::{Uint, U256};
-use ethcore::client::{TestBlockChainClient, EachBlockWith};
+use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed};
 use v1::{Eth, EthClient};
 use v1::tests::helpers::{TestAccount, TestAccountProvider, TestSyncProvider, Config, TestMinerService, TestExternalMiner};
 
@@ -299,9 +299,69 @@ fn rpc_eth_code() {
 }
 
 #[test]
-#[ignore]
 fn rpc_eth_call() {
-	unimplemented!()
+	let tester = EthTester::default();
+	tester.client.set_execution_result(Executed {
+		gas: U256::zero(),
+		gas_used: U256::from(0xff30),
+		refunded: U256::from(0x5),
+		cumulative_gas_used: U256::zero(),
+		logs: vec![],
+		contracts_created: vec![],
+		output: vec![0x12, 0x34, 0xff],
+		trace: None,
+	});
+
+	let request = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_call",
+		"params": [{
+			"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+			"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
+			"gas": "0x76c0",
+			"gasPrice": "0x9184e72a000",
+			"value": "0x9184e72a",
+			"data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+		},
+		"latest"],
+		"id": 1
+	}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x1234ff","id":1}"#;
+
+	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_eth_estimate_gas() {
+	let tester = EthTester::default();
+	tester.client.set_execution_result(Executed {
+		gas: U256::zero(),
+		gas_used: U256::from(0xff30),
+		refunded: U256::from(0x5),
+		cumulative_gas_used: U256::zero(),
+		logs: vec![],
+		contracts_created: vec![],
+		output: vec![0x12, 0x34, 0xff],
+		trace: None,
+	});
+
+	let request = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_estimateGas",
+		"params": [{
+			"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+			"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
+			"gas": "0x76c0",
+			"gasPrice": "0x9184e72a000",
+			"value": "0x9184e72a",
+			"data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+		},
+		"latest"],
+		"id": 1
+	}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0xff35","id":1}"#;
+
+	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
 }
 
 #[test]
@@ -322,12 +382,6 @@ fn rpc_eth_sign() {
 	unimplemented!()
 }
 
-#[test]
-#[ignore]
-fn rpc_eth_estimate_gas() {
-	unimplemented!()
-}
-
 #[test]
 fn rpc_eth_compilers() {
 	let request = r#"{"jsonrpc": "2.0", "method": "eth_getCompilers", "params": [], "id": 1}"#;

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

@@ -19,7 +19,7 @@
 use std::sync::RwLock;
 use std::collections::HashMap;
 use std::io;
-use util::hash::{Address, H256};
+use util::hash::{Address, H256, FixedHash};
 use util::crypto::{Secret, Signature};
 use util::keys::store::{AccountProvider, SigningError, EncryptedHashMapError};
 
@@ -83,7 +83,7 @@ impl AccountProvider for TestAccountProvider {
 	}
 
 	fn account_secret(&self, _account: &Address) -> Result<Secret, SigningError> {
-		unimplemented!()
+		Ok(Secret::random())
 	}
 
 	fn sign(&self, _account: &Address, _message: &H256) -> Result<Signature, SigningError> {

rpc/src/v1/types/transaction_request.rs

@@ -46,6 +46,8 @@ impl Into<Transaction> for TransactionRequest {
 
 #[cfg(test)]
 mod tests {
+	use std::str::FromStr;
+	use rustc_serialize::hex::FromHex;
 	use serde_json;
 	use util::numbers::{Uint, U256};
 	use util::hash::Address;
@@ -121,6 +123,29 @@ mod tests {
 		});
 	}
 
+	#[test]
+	fn transaction_request_deserialize2() {
+		let s = r#"{
+			"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+			"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
+			"gas": "0x76c0",
+			"gasPrice": "0x9184e72a000",
+			"value": "0x9184e72a",
+			"data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+		}"#;
+		let deserialized: TransactionRequest = serde_json::from_str(s).unwrap();
+
+		assert_eq!(deserialized, TransactionRequest {
+			from: Address::from_str("b60e8dd61c5d32be8058bb8eb970870f07233155").unwrap(),
+			to: Some(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap()),
+			gas_price: Some(U256::from_str("9184e72a000").unwrap()),
+			gas: Some(U256::from_str("76c0").unwrap()),
+			value: Some(U256::from_str("9184e72a").unwrap()),
+			data: Some(Bytes::new("d46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675".from_hex().unwrap())),
+			nonce: None
+		});
+	}
+
 	#[test]
 	fn transaction_request_deserialize_empty() {
 		let s = r#"{"from":"0x0000000000000000000000000000000000000001"}"#;