From fb2ea765d5bcf4bec02f5e65fd0f48dd19f36b13 Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Fri, 27 May 2016 20:04:41 +0200
Subject: [PATCH 1/8] remove default implementations using rpc_unimplemented!()

---
 rpc/src/v1/traits/eth.rs      | 86 +++++++++++++++++------------------
 rpc/src/v1/traits/ethcore.rs  | 34 +++++++-------
 rpc/src/v1/traits/net.rs      |  6 +--
 rpc/src/v1/traits/personal.rs |  8 ++--
 rpc/src/v1/traits/rpc.rs      |  4 +-
 rpc/src/v1/traits/traces.rs   |  8 ++--
 rpc/src/v1/traits/web3.rs     |  4 +-
 7 files changed, 75 insertions(+), 75 deletions(-)

diff --git a/rpc/src/v1/traits/eth.rs b/rpc/src/v1/traits/eth.rs
index a28f72c5c..1577053f4 100644
--- a/rpc/src/v1/traits/eth.rs
+++ b/rpc/src/v1/traits/eth.rs
@@ -21,115 +21,115 @@ use jsonrpc_core::*;
 /// Eth rpc interface.
 pub trait Eth: Sized + Send + Sync + 'static {
 	/// Returns protocol version.
-	fn protocol_version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn protocol_version(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns an object with data about the sync status or false. (wtf?)
-	fn syncing(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn syncing(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the number of hashes per second that the node is mining with.
-	fn hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn hashrate(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns block author.
-	fn author(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn author(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns true if client is actively mining new blocks.
-	fn is_mining(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn is_mining(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns current gas_price.
-	fn gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn gas_price(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns accounts list.
-	fn accounts(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn accounts(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns highest block number.
-	fn block_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_number(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns balance of the given account.
-	fn balance(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn balance(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns content of the storage at given address.
-	fn storage_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn storage_at(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns block with given hash.
-	fn block_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_by_hash(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns block with given number.
-	fn block_by_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_by_number(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the number of transactions sent from given address at given time (block number).
-	fn transaction_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transaction_count(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the number of transactions in a block with given hash.
-	fn block_transaction_count_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_transaction_count_by_hash(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the number of transactions in a block with given block number.
-	fn block_transaction_count_by_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_transaction_count_by_number(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the number of uncles in a block with given hash.
-	fn block_uncles_count_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_uncles_count_by_hash(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the number of uncles in a block with given block number.
-	fn block_uncles_count_by_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_uncles_count_by_number(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the code at given address at given time (block number).
-	fn code_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn code_at(&self, _: Params) -> Result<Value, Error>;
 
 	/// Signs the data with given address signature.
-	fn sign(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn sign(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sends transaction.
-	fn send_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn send_transaction(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sends signed transaction.
-	fn send_raw_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn send_raw_transaction(&self, _: Params) -> Result<Value, Error>;
 
 	/// Call contract.
-	fn call(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn call(&self, _: Params) -> Result<Value, Error>;
 
 	/// Estimate gas needed for execution of given contract.
-	fn estimate_gas(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn estimate_gas(&self, _: Params) -> Result<Value, Error>;
 
 	/// Get transaction by it's hash.
-	fn transaction_by_hash(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transaction_by_hash(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns transaction at given block hash and index.
-	fn transaction_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transaction_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns transaction by given block number and index.
-	fn transaction_by_block_number_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transaction_by_block_number_and_index(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns transaction receipt.
-	fn transaction_receipt(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transaction_receipt(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns an uncles at given block and index.
-	fn uncle_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn uncle_by_block_hash_and_index(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns an uncles at given block and index.
-	fn uncle_by_block_number_and_index(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn uncle_by_block_number_and_index(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns available compilers.
-	fn compilers(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn compilers(&self, _: Params) -> Result<Value, Error>;
 
 	/// Compiles lll code.
-	fn compile_lll(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn compile_lll(&self, _: Params) -> Result<Value, Error>;
 
 	/// Compiles solidity.
-	fn compile_solidity(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn compile_solidity(&self, _: Params) -> Result<Value, Error>;
 
 	/// Compiles serpent.
-	fn compile_serpent(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn compile_serpent(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns logs matching given filter object.
-	fn logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn logs(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns the hash of the current block, the seedHash, and the boundary condition to be met.
-	fn work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn work(&self, _: Params) -> Result<Value, Error>;
 
 	/// Used for submitting a proof-of-work solution.
-	fn submit_work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn submit_work(&self, _: Params) -> Result<Value, Error>;
 
 	/// Used for submitting mining hashrate.
-	fn submit_hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn submit_hashrate(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
@@ -179,22 +179,22 @@ pub trait Eth: Sized + Send + Sync + 'static {
 // TODO: do filters api properly
 pub trait EthFilter: Sized + Send + Sync + 'static {
 	/// Returns id of new filter.
-	fn new_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn new_filter(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns id of new block filter.
-	fn new_block_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn new_block_filter(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns id of new block filter.
-	fn new_pending_transaction_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn new_pending_transaction_filter(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns filter changes since last poll.
-	fn filter_changes(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn filter_changes(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns all logs matching given filter (in a range 'from' - 'to').
-	fn filter_logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn filter_logs(&self, _: Params) -> Result<Value, Error>;
 
 	/// Uninstalls filter.
-	fn uninstall_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn uninstall_filter(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
diff --git a/rpc/src/v1/traits/ethcore.rs b/rpc/src/v1/traits/ethcore.rs
index 2a2159bd9..3646f6c5a 100644
--- a/rpc/src/v1/traits/ethcore.rs
+++ b/rpc/src/v1/traits/ethcore.rs
@@ -22,55 +22,55 @@ use jsonrpc_core::*;
 pub trait Ethcore: Sized + Send + Sync + 'static {
 
 	/// Sets new minimal gas price for mined blocks.
-	fn set_min_gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn set_min_gas_price(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sets new gas floor target for mined blocks.
-	fn set_gas_floor_target(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn set_gas_floor_target(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sets new extra data for mined blocks.
-	fn set_extra_data(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn set_extra_data(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sets new author for mined block.
-	fn set_author(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn set_author(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sets the limits for transaction queue.
-	fn set_transactions_limit(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn set_transactions_limit(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns current transactions limit.
-	fn transactions_limit(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transactions_limit(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns mining extra data.
-	fn extra_data(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn extra_data(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns mining gas floor target.
-	fn gas_floor_target(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn gas_floor_target(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns minimal gas price for transaction to be included in queue.
-	fn min_gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn min_gas_price(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns latest logs
-	fn dev_logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn dev_logs(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns logs levels
-	fn dev_logs_levels(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn dev_logs_levels(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns chain name
-	fn net_chain(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn net_chain(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns max peers
-	fn net_max_peers(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn net_max_peers(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns network port
-	fn net_port(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn net_port(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns rpc settings
-	fn rpc_settings(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn rpc_settings(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns node name
-	fn node_name(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn node_name(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns default extra data
-	fn default_extra_data(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn default_extra_data(&self, _: Params) -> Result<Value, Error>;
 
 
 	/// Should be used to convert object to io delegate.
diff --git a/rpc/src/v1/traits/net.rs b/rpc/src/v1/traits/net.rs
index 732d6efb2..56fba3e32 100644
--- a/rpc/src/v1/traits/net.rs
+++ b/rpc/src/v1/traits/net.rs
@@ -21,14 +21,14 @@ use jsonrpc_core::*;
 /// Net rpc interface.
 pub trait Net: Sized + Send + Sync + 'static {
 	/// Returns protocol version.
-	fn version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn version(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns number of peers connected to node.
-	fn peer_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn peer_count(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns true if client is actively listening for network connections.
 	/// Otherwise false.
-	fn is_listening(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn is_listening(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
diff --git a/rpc/src/v1/traits/personal.rs b/rpc/src/v1/traits/personal.rs
index 0619d7ada..d66161c54 100644
--- a/rpc/src/v1/traits/personal.rs
+++ b/rpc/src/v1/traits/personal.rs
@@ -22,16 +22,16 @@ use jsonrpc_core::*;
 pub trait Personal: Sized + Send + Sync + 'static {
 
 	/// Lists all stored accounts
-	fn accounts(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn accounts(&self, _: Params) -> Result<Value, Error>;
 
 	/// Creates new account (it becomes new current unlocked account)
-	fn new_account(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn new_account(&self, _: Params) -> Result<Value, Error>;
 
 	/// Unlocks specified account for use (can only be one unlocked account at one moment)
-	fn unlock_account(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn unlock_account(&self, _: Params) -> Result<Value, Error>;
 
 	/// Sends transaction and signs it in single call. The account is not unlocked in such case.
-	fn sign_and_send_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn sign_and_send_transaction(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
diff --git a/rpc/src/v1/traits/rpc.rs b/rpc/src/v1/traits/rpc.rs
index 5c981c8a1..669d0d8c6 100644
--- a/rpc/src/v1/traits/rpc.rs
+++ b/rpc/src/v1/traits/rpc.rs
@@ -23,10 +23,10 @@ use jsonrpc_core::*;
 pub trait Rpc: Sized + Send + Sync + 'static {
 
 	/// Returns supported modules for Geth 1.3.6
-	fn modules(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn modules(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns supported modules for Geth 1.4.0
-	fn rpc_modules(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn rpc_modules(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
diff --git a/rpc/src/v1/traits/traces.rs b/rpc/src/v1/traits/traces.rs
index b42feede5..54d04b954 100644
--- a/rpc/src/v1/traits/traces.rs
+++ b/rpc/src/v1/traits/traces.rs
@@ -21,16 +21,16 @@ use jsonrpc_core::*;
 /// Traces specific rpc interface.
 pub trait Traces: Sized + Send + Sync + 'static {
 	/// Returns traces matching given filter.
-	fn filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn filter(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns transaction trace at given index.
-	fn trace(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn trace(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns all traces of given transaction.
-	fn transaction_traces(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn transaction_traces(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns all traces produced at given block.
-	fn block_traces(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn block_traces(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
diff --git a/rpc/src/v1/traits/web3.rs b/rpc/src/v1/traits/web3.rs
index c7b21a1a1..335911025 100644
--- a/rpc/src/v1/traits/web3.rs
+++ b/rpc/src/v1/traits/web3.rs
@@ -21,10 +21,10 @@ use jsonrpc_core::*;
 /// Web3 rpc interface.
 pub trait Web3: Sized + Send + Sync + 'static {
 	/// Returns current client version.
-	fn client_version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn client_version(&self, _: Params) -> Result<Value, Error>;
 
 	/// Returns sha3 of the given data
-	fn sha3(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	fn sha3(&self, _: Params) -> Result<Value, Error>;
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {

From 191bae5cd47a1804a96b216fc61511239f37c05f Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Sat, 28 May 2016 15:25:37 +0200
Subject: [PATCH 2/8] add stubs for missing eth_* rpc methods

---
 rpc/src/v1/impls/eth.rs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 7627dd61e..026459d9f 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -494,6 +494,16 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 		})
 	}
 
+	fn sign(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(Address, Bytes)>(params).and_then(|(addr, data)| {
+			let accounts = take_weak!(self.accounts);
+			match accounts.account_secret(&addr) {
+				Ok(secret) => rpc_unimplemented!(),
+				Err(_) => rpc_unimplemented!(),
+			}
+		})
+	}
+
 	fn send_transaction(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(TransactionRequest, )>(params)
 			.and_then(|(request, )| {
@@ -542,6 +552,18 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 				to_value(&r.map(|res| res.gas_used + res.refunded).unwrap_or(From::from(0)))
 			})
 	}
+
+	fn compile_lll(&self, _: params) -> Result<Value, Error> {
+		rpc_unimplemented!()
+	}
+
+	fn compile_serpent(&self, _: params) -> Result<Value, Error> {
+		rpc_unimplemented!()
+	}
+
+	fn compile_solidity(&self, _: params) -> Result<Value, Error> {
+		rpc_unimplemented!()
+	}
 }
 
 /// Eth filter rpc implementation.

From 7cea3eb5ed8757e816ad4afb6590fb7748ed51c9 Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Sun, 29 May 2016 14:53:50 +0200
Subject: [PATCH 3/8] move rpc_unimplemented into impls module

---
 rpc/src/v1/impls/mod.rs  | 4 ++++
 rpc/src/v1/traits/mod.rs | 4 ----
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/rpc/src/v1/impls/mod.rs b/rpc/src/v1/impls/mod.rs
index b79772103..94b4fecc1 100644
--- a/rpc/src/v1/impls/mod.rs
+++ b/rpc/src/v1/impls/mod.rs
@@ -25,6 +25,10 @@ macro_rules! take_weak {
 	}
 }
 
+macro_rules! rpc_unimplemented {
+	() => (Err(Error::internal_error()))
+}
+
 mod web3;
 mod eth;
 mod net;
diff --git a/rpc/src/v1/traits/mod.rs b/rpc/src/v1/traits/mod.rs
index bebf95bb7..0728fd06a 100644
--- a/rpc/src/v1/traits/mod.rs
+++ b/rpc/src/v1/traits/mod.rs
@@ -16,10 +16,6 @@
 
 //! Ethereum rpc interfaces.
 
-macro_rules! rpc_unimplemented {
-	() => (Err(Error::internal_error()))
-}
-
 pub mod web3;
 pub mod eth;
 pub mod net;

From be1ec93271b5cefd9f4dd3c39d4b35c21da89b83 Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Sun, 29 May 2016 15:46:57 +0200
Subject: [PATCH 4/8] implement eth_sign

---
 rpc/src/v1/impls/eth.rs        | 16 ++++++----------
 rpc/src/v1/tests/eth.rs        |  2 +-
 rpc/src/v1/tests/mocked/eth.rs | 30 +++++++++++++++++++++++-------
 3 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 026459d9f..100770ae1 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -27,6 +27,7 @@ use jsonrpc_core::*;
 use util::numbers::*;
 use util::sha3::*;
 use util::rlp::{encode, decode, UntrustedRlp, View};
+use util::keys::store::AccountProvider;
 use ethcore::client::{BlockChainClient, BlockID, TransactionID, UncleID};
 use ethcore::block::IsBlock;
 use ethcore::views::*;
@@ -39,7 +40,6 @@ use v1::traits::{Eth, EthFilter};
 use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, TransactionRequest, CallRequest, OptionalValue, Index, Filter, Log, Receipt};
 use v1::helpers::{PollFilter, PollManager};
 use v1::impls::{dispatch_transaction, sign_and_dispatch};
-use util::keys::store::AccountProvider;
 use serde;
 
 /// Eth rpc implementation.
@@ -495,12 +495,8 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 	}
 
 	fn sign(&self, params: Params) -> Result<Value, Error> {
-		from_params::<(Address, Bytes)>(params).and_then(|(addr, data)| {
-			let accounts = take_weak!(self.accounts);
-			match accounts.account_secret(&addr) {
-				Ok(secret) => rpc_unimplemented!(),
-				Err(_) => rpc_unimplemented!(),
-			}
+		from_params::<(Address, H256)>(params).and_then(|(addr, msg)| {
+			to_value(&take_weak!(self.accounts).sign(&addr, &msg).unwrap_or(H520::zero()))
 		})
 	}
 
@@ -553,15 +549,15 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 			})
 	}
 
-	fn compile_lll(&self, _: params) -> Result<Value, Error> {
+	fn compile_lll(&self, _: Params) -> Result<Value, Error> {
 		rpc_unimplemented!()
 	}
 
-	fn compile_serpent(&self, _: params) -> Result<Value, Error> {
+	fn compile_serpent(&self, _: Params) -> Result<Value, Error> {
 		rpc_unimplemented!()
 	}
 
-	fn compile_solidity(&self, _: params) -> Result<Value, Error> {
+	fn compile_solidity(&self, _: Params) -> Result<Value, Error> {
 		rpc_unimplemented!()
 	}
 }
diff --git a/rpc/src/v1/tests/eth.rs b/rpc/src/v1/tests/eth.rs
index eac5bafcb..80a856aca 100644
--- a/rpc/src/v1/tests/eth.rs
+++ b/rpc/src/v1/tests/eth.rs
@@ -27,7 +27,7 @@ use ethcore::transaction::{Transaction, Action};
 use ethminer::{MinerService, ExternalMiner};
 use devtools::RandomTempPath;
 use util::io::IoChannel;
-use util::hash::{Address, FixedHash};
+use util::hash::Address;
 use util::numbers::{Uint, U256};
 use util::keys::{AccountProvider, TestAccount, TestAccountProvider};
 use jsonrpc_core::IoHandler;
diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs
index 32a2cd99a..9f6f9881f 100644
--- a/rpc/src/v1/tests/mocked/eth.rs
+++ b/rpc/src/v1/tests/mocked/eth.rs
@@ -20,7 +20,7 @@ use std::sync::{Arc, RwLock};
 use jsonrpc_core::IoHandler;
 use util::hash::{Address, H256, FixedHash};
 use util::numbers::{Uint, U256};
-use util::keys::{TestAccount, TestAccountProvider};
+use util::keys::{AccountProvider, TestAccount, TestAccountProvider};
 use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, TransactionID};
 use ethcore::log_entry::{LocalizedLogEntry, LogEntry};
 use ethcore::receipt::LocalizedReceipt;
@@ -129,6 +129,28 @@ fn rpc_eth_submit_hashrate() {
 		Some(U256::from(0x500_000)));
 }
 
+#[test]
+fn rpc_eth_sign() {
+	let tester = EthTester::default();
+
+	let account = tester.accounts_provider.new_account("abcd").unwrap();
+	let message = H256::from("0x0cc175b9c0f1b6a831c399e26977266192eb5ffee6ae2fec3ad71c777531578f");
+	let signed = tester.accounts_provider.sign(&account, &message).unwrap();
+
+	let req = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_sign",
+		"params": [
+			""#.to_owned() + &format!("0x{:?}", account) + r#"",
+			"0x0cc175b9c0f1b6a831c399e26977266192eb5ffee6ae2fec3ad71c777531578f"
+		],
+		"id": 1
+	}"#;
+	let res = r#"{"jsonrpc":"2.0","result":""#.to_owned() + &format!("0x{:?}", signed) + r#"","id":1}"#;
+
+	assert_eq!(tester.io.handle_request(&req), Some(res));
+}
+
 #[test]
 #[ignore]
 fn rpc_eth_author() {
@@ -527,12 +549,6 @@ fn rpc_eth_send_raw_transaction() {
 	unimplemented!()
 }
 
-#[test]
-#[ignore]
-fn rpc_eth_sign() {
-	unimplemented!()
-}
-
 #[test]
 fn rpc_eth_transaction_receipt() {
 	let receipt = LocalizedReceipt {

From 89659606dd9a98ccbef87db96d63439ea388de1c Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Sun, 29 May 2016 17:07:39 +0200
Subject: [PATCH 5/8] add mocked test for eth_sendRawTransaction

---
 rpc/src/v1/impls/mod.rs        | 22 ++++++-----------
 rpc/src/v1/tests/mocked/eth.rs | 44 ++++++++++++++++++++++++++++------
 2 files changed, 44 insertions(+), 22 deletions(-)

diff --git a/rpc/src/v1/impls/mod.rs b/rpc/src/v1/impls/mod.rs
index 94b4fecc1..7ee8b8b8a 100644
--- a/rpc/src/v1/impls/mod.rs
+++ b/rpc/src/v1/impls/mod.rs
@@ -59,22 +59,14 @@ fn dispatch_transaction<C, M>(client: &C, miner: &M, signed_transaction: SignedT
 	where C: BlockChainClient, M: MinerService {
 	let hash = signed_transaction.hash();
 
-	let import = {
-		miner.import_own_transaction(client, signed_transaction, |a: &Address| {
-			AccountDetails {
-				nonce: client.latest_nonce(&a),
-				balance: client.latest_balance(&a),
-			}
-		})
-	};
-
-	match import {
-		Ok(_) => to_value(&hash),
-		Err(e) => {
-			warn!("Error sending transaction: {:?}", e);
-			to_value(&H256::zero())
+	let import = miner.import_own_transaction(client, signed_transaction, |a: &Address| {
+		AccountDetails {
+			nonce: client.latest_nonce(&a),
+			balance: client.latest_balance(&a),
 		}
-	}
+	});
+
+	to_value(&import.map(|_| hash).unwrap_or(H256::zero()))
 }
 
 fn sign_and_dispatch<C, M>(client: &Weak<C>, miner: &Weak<M>, request: TransactionRequest, secret: H256) -> Result<Value, Error>
diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs
index 9f6f9881f..031616450 100644
--- a/rpc/src/v1/tests/mocked/eth.rs
+++ b/rpc/src/v1/tests/mocked/eth.rs
@@ -28,6 +28,7 @@ use ethcore::transaction::{Transaction, Action};
 use ethminer::ExternalMiner;
 use v1::{Eth, EthClient};
 use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService};
+use rustc_serialize::hex::ToHex;
 
 fn blockchain_client() -> Arc<TestBlockChainClient> {
 	let client = TestBlockChainClient::new();
@@ -215,18 +216,22 @@ fn rpc_eth_balance() {
 	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
 }
 
-#[ignore] //TODO: propert test
 #[test]
 fn rpc_eth_balance_pending() {
 	let tester = EthTester::default();
+	tester.client.set_balance(Address::from(1), U256::from(5));
 
 	let request = r#"{
 		"jsonrpc": "2.0",
 		"method": "eth_getBalance",
-		"params": ["0x0000000000000000000000000000000000000001", "latest"],
+		"params": ["0x0000000000000000000000000000000000000001", "pending"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x","id":1}"#;
+
+	// the TestMinerService doesn't communicate with the the TestBlockChainClient in any way.
+	// if this returns zero, we know that the "pending" call is being properly forwarded to the
+	// miner.
+	let response = r#"{"jsonrpc":"2.0","result":"0x00","id":1}"#;
 
 	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
 }
@@ -525,7 +530,7 @@ fn rpc_eth_send_transaction() {
 
 	let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#;
 
-	assert_eq!(tester.io.handle_request(request.as_ref()), Some(response));
+	assert_eq!(tester.io.handle_request(&request), Some(response));
 
 	tester.miner.last_nonces.write().unwrap().insert(address.clone(), U256::zero());
 
@@ -540,13 +545,38 @@ fn rpc_eth_send_transaction() {
 
 	let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#;
 
-	assert_eq!(tester.io.handle_request(request.as_ref()), Some(response));
+	assert_eq!(tester.io.handle_request(&request), Some(response));
 }
 
 #[test]
-#[ignore]
 fn rpc_eth_send_raw_transaction() {
-	unimplemented!()
+	let tester = EthTester::default();
+	let address = tester.accounts_provider.new_account("abcd").unwrap();
+	let secret = tester.accounts_provider.account_secret(&address).unwrap();
+
+	let t = Transaction {
+		nonce: U256::zero(),
+		gas_price: U256::from(0x9184e72a000u64),
+		gas: U256::from(0x76c0),
+		action: Action::Call(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap()),
+		value: U256::from(0x9184e72au64),
+		data: vec![]
+	}.sign(&secret);
+
+	let rlp = ::util::rlp::encode(&t).to_vec().to_hex();
+
+	let req = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_sendRawTransaction",
+		"params": [
+			"0x"#.to_owned() + &rlp + r#""
+		],
+		"id": 1
+	}"#;
+
+	let res = r#"{"jsonrpc":"2.0","result":""#.to_owned() + &format!("0x{:?}", t.hash()) + r#"","id":1}"#;
+
+	assert_eq!(tester.io.handle_request(&req), Some(res));
 }
 
 #[test]

From bbe6a287f896f327c5eb475cd8444725b50be7c4 Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Sun, 29 May 2016 17:18:37 +0200
Subject: [PATCH 6/8] add mocked test for eth_coinbase

---
 rpc/src/v1/tests/mocked/eth.rs | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs
index 031616450..06f1d97b3 100644
--- a/rpc/src/v1/tests/mocked/eth.rs
+++ b/rpc/src/v1/tests/mocked/eth.rs
@@ -25,7 +25,7 @@ use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, Transaction
 use ethcore::log_entry::{LocalizedLogEntry, LogEntry};
 use ethcore::receipt::LocalizedReceipt;
 use ethcore::transaction::{Transaction, Action};
-use ethminer::ExternalMiner;
+use ethminer::{ExternalMiner, MinerService};
 use v1::{Eth, EthClient};
 use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService};
 use rustc_serialize::hex::ToHex;
@@ -153,9 +153,25 @@ fn rpc_eth_sign() {
 }
 
 #[test]
-#[ignore]
 fn rpc_eth_author() {
-	unimplemented!()
+	let make_res = |addr| r#"{"jsonrpc":"2.0","result":""#.to_owned() + &format!("0x{:?}", addr) + r#"","id":1}"#;
+	let tester = EthTester::default();
+
+	let req = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_coinbase",
+		"params": [],
+		"id": 1
+	}"#;
+
+	assert_eq!(tester.io.handle_request(req), Some(make_res(Address::zero())));
+
+	for i in 0..20 {
+		let addr = tester.accounts_provider.new_account(&format!("{}", i)).unwrap();
+		tester.miner.set_author(addr.clone());
+
+		assert_eq!(tester.io.handle_request(req), Some(make_res(addr)));
+	}
 }
 
 #[test]

From ea26deaab142f04940076f5087f857b47c50d441 Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Mon, 30 May 2016 12:33:49 +0200
Subject: [PATCH 7/8] mocked test for eth_syncing

---
 rpc/src/v1/tests/mocked/eth.rs | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs
index 06f1d97b3..aa0955751 100644
--- a/rpc/src/v1/tests/mocked/eth.rs
+++ b/rpc/src/v1/tests/mocked/eth.rs
@@ -26,6 +26,7 @@ use ethcore::log_entry::{LocalizedLogEntry, LogEntry};
 use ethcore::receipt::LocalizedReceipt;
 use ethcore::transaction::{Transaction, Action};
 use ethminer::{ExternalMiner, MinerService};
+use ethsync::SyncState;
 use v1::{Eth, EthClient};
 use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService};
 use rustc_serialize::hex::ToHex;
@@ -93,9 +94,28 @@ fn rpc_eth_protocol_version() {
 }
 
 #[test]
-#[ignore]
 fn rpc_eth_syncing() {
-	unimplemented!()
+	let request = r#"{"jsonrpc": "2.0", "method": "eth_syncing", "params": [], "id": 1}"#;
+
+	let tester = EthTester::default();
+
+	let false_res = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
+	assert_eq!(tester.io.handle_request(request), Some(false_res.to_owned()));
+
+	{
+		let mut status = tester.sync.status.write().unwrap();
+		status.state = SyncState::Blocks;
+		status.highest_block_number = Some(2500);
+
+		// causes TestBlockChainClient to return 1000 for its best block number.
+		let mut blocks = tester.client.blocks.write().unwrap();
+		for i in 0..1000 {
+			blocks.insert(H256::from(i), Vec::new());
+		}
+	}
+
+	let true_res = r#"{"jsonrpc":"2.0","result":{"currentBlock":"0x03e8","highestBlock":"0x09c4","startingBlock":"0x00"},"id":1}"#;
+	assert_eq!(tester.io.handle_request(request), Some(true_res.to_owned()));
 }
 
 #[test]

From 16432129b580635ef6c2380c1f916666d975259c Mon Sep 17 00:00:00 2001
From: Robert Habermeier <rphmeier@gmail.com>
Date: Mon, 30 May 2016 13:13:48 +0200
Subject: [PATCH 8/8] move transaction import error warning into miner
 implementation

---
 miner/src/miner.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/miner/src/miner.rs b/miner/src/miner.rs
index 3860a79e6..fc63aec6c 100644
--- a/miner/src/miner.rs
+++ b/miner/src/miner.rs
@@ -395,6 +395,7 @@ impl MinerService for Miner {
 				Err(ref e) => {
 					trace!(target: "own_tx", "Failed to import transaction {:?} (hash: {:?})", e, hash);
 					trace!(target: "own_tx", "Status: {:?}", transaction_queue.status());
+					warn!(target: "own_tx", "Error importing transaction: {:?}", e);
 				},
 			}
 			import