Basic signing queue

signer/Cargo.toml

@@ -9,13 +9,20 @@ build = "build.rs"
 
 [build-dependencies]
 rustc_version = "0.1"
+serde_codegen = { version = "0.7.0", optional = true }
+syntex = "^0.32.0"
 
 [dependencies]
+serde = "0.7.0"
+serde_json = "0.7.0"
+serde_macros = { version = "0.7.0", optional = true }
+rustc-serialize = "0.3"
 ethcore-util = { path = "../util" }
 log = "0.3"
 env_logger = "0.3"
 clippy = { version = "0.0.69", optional = true}
 
 [features]
-default = []
+default = ["serde_codegen"]
+nightly = ["serde_macros"]
 dev = ["clippy"]

signer/build.rs

@@ -19,7 +19,34 @@ extern crate rustc_version;
 use rustc_version::{version_meta, Channel};
 
 fn main() {
+	serde::main();
 	if let Channel::Nightly = version_meta().channel {
 		println!("cargo:rustc-cfg=nightly");
 	}
 }
+
+#[cfg(not(feature = "serde_macros"))]
+mod serde {
+    extern crate syntex;
+    extern crate serde_codegen;
+
+    use std::env;
+    use std::path::Path;
+
+    pub fn main() {
+        let out_dir = env::var_os("OUT_DIR").unwrap();
+
+        let src = Path::new("src/types/mod.rs.in");
+        let dst = Path::new(&out_dir).join("mod.rs");
+
+        let mut registry = syntex::Registry::new();
+
+        serde_codegen::register(&mut registry);
+        registry.expand("", &src, &dst).unwrap();
+    }
+}
+
+#[cfg(feature = "serde_macros")]
+mod serde {
+    pub fn main() {}
+}

signer/src/lib.rs

@@ -34,6 +34,15 @@
 extern crate log;
 extern crate env_logger;
 
+extern crate serde;
+extern crate serde_json;
+extern crate rustc_serialize;
+
+extern crate ethcore_util as util;
+
+mod signing_queue;
+pub mod types;
+
 #[cfg(test)]
 mod tests {
 	#[test]

signer/src/signing_queue.rs

@@ -0,0 +1,74 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashSet;
+use types::transaction_request::TransactionRequest;
+
+pub trait SigningQueue {
+	fn add_request(&mut self, transaction: TransactionRequest);
+
+	fn remove_request(&mut self, id: TransactionRequest);
+
+	fn requests(&self) -> &HashSet<TransactionRequest>;
+}
+
+impl SigningQueue for HashSet<TransactionRequest> {
+	fn add_request(&mut self, transaction: TransactionRequest) {
+		self.insert(transaction);
+	}
+
+	fn remove_request(&mut self, id: TransactionRequest) {
+		self.remove(&id);
+	}
+
+	fn requests(&self) -> &HashSet<TransactionRequest> {
+		self
+	}
+}
+
+
+#[cfg(test)]
+mod test {
+	use std::collections::HashSet;
+	use util::hash::Address;
+	use util::numbers::U256;
+	use types::transaction_request::TransactionRequest;
+	use super::*;
+
+	#[test]
+	fn should_work_for_hashset() {
+		// given
+		let mut queue = HashSet::new();
+
+		let request = TransactionRequest {
+			from: Address::from(1),
+			to: Some(Address::from(2)),
+			gas_price: None,
+			gas: None,
+			value: Some(U256::from(10_000_000)),
+			data: None,
+			nonce: None,
+		};
+
+		// when
+		queue.add_request(request.clone());
+		let all = queue.requests();
+
+		// then
+		assert_eq!(all.len(), 1);
+		assert!(all.contains(&request));
+	}
+}

signer/src/types/bytes.rs

@@ -0,0 +1,98 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use rustc_serialize::hex::ToHex;
+use serde::{Serialize, Serializer, Deserialize, Deserializer, Error};
+use serde::de::Visitor;
+use util::common::FromHex;
+
+/// Wrapper structure around vector of bytes.
+#[derive(Debug, PartialEq, Eq, Default, Hash, Clone)]
+pub struct Bytes(pub Vec<u8>);
+
+impl Bytes {
+	/// Simple constructor.
+	pub fn new(bytes: Vec<u8>) -> Bytes {
+		Bytes(bytes)
+	}
+	pub fn to_vec(self) -> Vec<u8> { let Bytes(x) = self; x }
+}
+
+impl Serialize for Bytes {
+	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());
+		serializer.serialize_str(serialized.as_ref())
+	}
+}
+
+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::*;
+	use serde_json;
+	use rustc_serialize::hex::FromHex;
+
+	#[test]
+	fn test_bytes_serialize() {
+		let bytes = Bytes("0123456789abcdef".from_hex().unwrap());
+		let serialized = serde_json::to_string(&bytes).unwrap();
+		assert_eq!(serialized, r#""0x0123456789abcdef""#);
+	}
+}
+

signer/src/types/mod.rs

@@ -0,0 +1,21 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#[cfg(feature = "serde_macros")]
+include!("mod.rs.in");
+
+#[cfg(not(feature = "serde_macros"))]
+include!(concat!(env!("OUT_DIR"), "/mod.rs"));

signer/src/types/mod.rs.in

@@ -0,0 +1,19 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+
+pub mod transaction_request;
+pub mod bytes;

signer/src/types/transaction_request.rs

@@ -0,0 +1,129 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// 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::hash::Address;
+use util::numbers::U256;
+use types::bytes::Bytes;
+
+#[derive(Debug, Clone, Default, Eq, PartialEq, Hash, 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: Option<Bytes>,
+	pub nonce: Option<U256>,
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use rustc_serialize::hex::FromHex;
+	use serde_json;
+	use util::numbers::{U256};
+	use util::hash::Address;
+	use types::bytes::Bytes;
+	use super::*;
+
+	#[test]
+	fn transaction_request_deserialize() {
+		let s = r#"{
+			"from":"0x0000000000000000000000000000000000000001",
+			"to":"0x0000000000000000000000000000000000000002",
+			"gasPrice":"0x1",
+			"gas":"0x2",
+			"value":"0x3",
+			"data":"0x123456",
+			"nonce":"0x4"
+		}"#;
+		let deserialized: TransactionRequest = serde_json::from_str(s).unwrap();
+
+		assert_eq!(deserialized, TransactionRequest {
+			from: Address::from(1),
+			to: Some(Address::from(2)),
+			gas_price: Some(U256::from(1)),
+			gas: Some(U256::from(2)),
+			value: Some(U256::from(3)),
+			data: Some(Bytes::new(vec![0x12, 0x34, 0x56])),
+			nonce: Some(U256::from(4)),
+		});
+	}
+
+	#[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"}"#;
+		let deserialized: TransactionRequest = serde_json::from_str(s).unwrap();
+
+		assert_eq!(deserialized, TransactionRequest {
+			from: Address::from(1),
+			to: None,
+			gas_price: None,
+			gas: None,
+			value: None,
+			data: None,
+			nonce: None,
+		});
+	}
+
+	#[test]
+	fn transaction_request_deserialize_test() {
+		let s = r#"{
+			"from":"0xb5f7502a2807cb23615c7456055e1d65b2508625",
+			"to":"0x895d32f2db7d01ebb50053f9e48aacf26584fe40",
+			"data":"0x8595bab1",
+			"gas":"0x2fd618",
+			"gasPrice":"0x0ba43b7400"
+		}"#;
+
+		let deserialized: TransactionRequest = serde_json::from_str(s).unwrap();
+
+		assert_eq!(deserialized, TransactionRequest {
+			from: Address::from_str("b5f7502a2807cb23615c7456055e1d65b2508625").unwrap(),
+			to: Some(Address::from_str("895d32f2db7d01ebb50053f9e48aacf26584fe40").unwrap()),
+			gas_price: Some(U256::from_str("0ba43b7400").unwrap()),
+			gas: Some(U256::from_str("2fd618").unwrap()),
+			value: None,
+			data: Some(Bytes::new(vec![0x85, 0x95, 0xba, 0xb1])),
+			nonce: None,
+		});
+	}
+}
+