rpc-signing-extend

parity/main.rs

@@ -157,6 +157,7 @@ fn setup_rpc_server(client: Arc<Client>, sync: Arc<EthSync>, url: &str, cors_dom
 	server.add_delegate(EthClient::new(&client, &sync).to_delegate());
 	server.add_delegate(EthFilterClient::new(&client).to_delegate());
 	server.add_delegate(NetClient::new(&sync).to_delegate());
+	server.add_delegate(PersonalClient::new(&client).to_delegate());
 	server.start_async(url, cors_domain);
 }
 

rpc/src/v1/impls/eth.rs

@@ -29,7 +29,7 @@ use ethcore::views::*;
 use ethcore::ethereum::Ethash;
 use ethcore::ethereum::denominations::shannon;
 use v1::traits::{Eth, EthFilter};
-use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, OptionalValue, Index, Filter, Log};
+use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, TransactionRequest, OptionalValue, Index, Filter, Log};
 use v1::helpers::{PollFilter, PollManager};
 
 /// Eth rpc implementation.
@@ -253,6 +253,21 @@ impl Eth for EthClient {
 			to_value(&true)
 		})
 	}
+
+	fn send_transaction(&self, params: Params) -> Result<Value, Error> {
+		from_params::<(TransactionRequest, )>(params)
+			.and_then(|(transaction_request, )| {
+				let client = take_weak!(self.client);
+				let store = client.secret_store().read().unwrap();
+				match store.account_secret(&transaction_request.from) {
+					Ok(_) => {
+						// todo: actually sign and push to queue transaction here
+						Ok(Value::Bool(true))
+					},
+					Err(_) => { Ok(Value::Bool(false ))}
+				}
+		})
+	}
 }
 
 /// Eth filter rpc implementation.

rpc/src/v1/impls/personal.rs

@@ -18,28 +18,27 @@
 use std::sync::{Arc, Weak};
 use jsonrpc_core::*;
 use v1::traits::Personal;
-use util::keys::store::*;
 use util::Address;
-use std::sync::RwLock;
+use ethcore::client::Client;
 
 /// Account management (personal) rpc implementation.
 pub struct PersonalClient {
-	secret_store: Weak<RwLock<SecretStore>>,
+	client: Weak<Client>,
 }
 
 impl PersonalClient {
 	/// Creates new PersonalClient
-	pub fn new(store: &Arc<RwLock<SecretStore>>) -> Self {
+	pub fn new(client: &Arc<Client>) -> Self {
 		PersonalClient {
-			secret_store: Arc::downgrade(store),
+			client: Arc::downgrade(client),
 		}
 	}
 }
 
 impl Personal for PersonalClient {
 	fn accounts(&self, _: Params) -> Result<Value, Error> {
-		let store_wk = take_weak!(self.secret_store);
-		let store = store_wk.read().unwrap();
+		let client = take_weak!(self.client);
+		let store = client.secret_store().read().unwrap();
 		match store.accounts() {
 			Ok(account_list) => {
 				Ok(Value::Array(account_list.iter()
@@ -54,8 +53,8 @@ impl Personal for PersonalClient {
 	fn new_account(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(String, )>(params).and_then(
 			|(pass, )| {
-				let store_wk = take_weak!(self.secret_store);
-				let mut store = store_wk.write().unwrap();
+				let client = take_weak!(self.client);
+				let mut store = client.secret_store().write().unwrap();
 				match store.new_account(&pass) {
 					Ok(address) => Ok(Value::String(format!("{:?}", address))),
 					Err(_) => Err(Error::internal_error())
@@ -67,8 +66,8 @@ impl Personal for PersonalClient {
 	fn unlock_account(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(Address, String, u64)>(params).and_then(
 			|(account, account_pass, _)|{
-				let store_wk = take_weak!(self.secret_store);
-				let store = store_wk.read().unwrap();
+				let client = take_weak!(self.client);
+				let store = client.secret_store().read().unwrap();
 				match store.unlock_account(&account, &account_pass) {
 					Ok(_) => Ok(Value::Bool(true)),
 					Err(_) => Ok(Value::Bool(false)),

rpc/src/v1/types/bytes.rs

@@ -15,7 +15,9 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use rustc_serialize::hex::ToHex;
-use serde::{Serialize, Serializer};
+use serde::{Serialize, Serializer, Deserialize, Deserializer, Error};
+use serde::de::Visitor;
+use util::common::FromHex;
 
 /// Wrapper structure around vector of bytes.
 #[derive(Debug)]
@@ -36,7 +38,7 @@ impl Default for Bytes {
 }
 
 impl Serialize for Bytes {
-	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> 
+	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
 	where S: Serializer {
 		let mut serialized = "0x".to_owned();
 		serialized.push_str(self.0.to_hex().as_ref());
@@ -44,6 +46,32 @@ impl Serialize for Bytes {
 	}
 }
 
+impl Deserialize for Bytes {
+	fn deserialize<D>(deserializer: &mut D) -> Result<Bytes, D::Error>
+	where D: Deserializer {
+		deserializer.deserialize(BytesVisitor)
+	}
+}
+
+struct BytesVisitor;
+
+impl Visitor for BytesVisitor {
+	type Value = Bytes;
+
+	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: Error {
+		if value.len() >= 2 && &value[0..2] == "0x" {
+			Ok(Bytes::new(FromHex::from_hex(&value[2..]).unwrap_or_else(|_| vec![])))
+		} else {
+			Err(Error::custom("invalid hex"))
+		}
+	}
+
+	fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: Error {
+		self.visit_str(value.as_ref())
+	}
+}
+
+
 #[cfg(test)]
 mod tests {
 	use super::*;

rpc/src/v1/types/mod.rs.in

@@ -33,3 +33,5 @@ pub use self::log::Log;
 pub use self::optionals::OptionalValue;
 pub use self::sync::{SyncStatus, SyncInfo};
 pub use self::transaction::Transaction;
+pub use self::transaction::TransactionRequest;
+

rpc/src/v1/types/transaction.rs

@@ -17,6 +17,7 @@
 use util::numbers::*;
 use ethcore::transaction::{LocalizedTransaction, Action};
 use v1::types::{Bytes, OptionalValue};
+use serde::{Deserializer, Error};
 
 #[derive(Debug, Default, Serialize)]
 pub struct Transaction {
@@ -37,6 +38,18 @@ pub struct Transaction {
 	pub input: Bytes
 }
 
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct TransactionRequest {
+	pub from: Address,
+	pub to: Option<Address>,
+	#[serde(rename="gasPrice")]
+	pub gas_price: Option<U256>,
+	pub gas: Option<U256>,
+	pub value: Option<U256>,
+	pub data: Bytes,
+	pub nonce: Option<U256>,
+}
+
 impl From<LocalizedTransaction> for Transaction {
 	fn from(t: LocalizedTransaction) -> Transaction {
 		Transaction {