Merge branch 'master' into ethminer_crate

Conflicts:
	rpc/src/v1/impls/eth.rs

rpc/src/v1/impls/eth.rs

@@ -29,6 +29,7 @@ use ethcore::block::{IsBlock};
 use ethcore::views::*;
 use ethcore::ethereum::Ethash;
 use ethcore::ethereum::denominations::shannon;
+use ethcore::transaction::Transaction as EthTransaction;
 use v1::traits::{Eth, EthFilter};
 use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, TransactionRequest, OptionalValue, Index, Filter, Log};
 use v1::helpers::{PollFilter, PollManager};
@@ -294,7 +295,8 @@ impl<C, S, A, M> Eth for EthClient<C, S, A, M>
 					Ok(secret) => {
 						let miner = take_weak!(self.miner);
 						let client = take_weak!(self.client);
-						let (transaction, _) = transaction_request.to_eth();
+
+						let transaction: EthTransaction = transaction_request.into();
 						let signed_transaction = transaction.sign(&secret);
 						let hash = signed_transaction.hash();
 

rpc/src/v1/types/bytes.rs

@@ -20,7 +20,7 @@ use serde::de::Visitor;
 use util::common::FromHex;
 
 /// Wrapper structure around vector of bytes.
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct Bytes(Vec<u8>);
 
 impl Bytes {

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

@@ -23,6 +23,7 @@ mod log;
 mod optionals;
 mod sync;
 mod transaction;
+mod transaction_request;
 
 pub use self::block::{Block, BlockTransactions};
 pub use self::block_number::BlockNumber;
@@ -33,5 +34,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;
+pub use self::transaction_request::TransactionRequest;
 

rpc/src/v1/types/transaction.rs

@@ -17,8 +17,7 @@
 use util::numbers::*;
 use ethcore::transaction::{LocalizedTransaction, Action};
 use v1::types::{Bytes, OptionalValue};
-use serde::{Deserializer, Error};
-use ethcore;
+use serde::Error;
 
 #[derive(Debug, Default, Serialize)]
 pub struct Transaction {
@@ -39,35 +38,6 @@ 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 TransactionRequest {
-	/// maps transaction request to the transaction that can be signed and inserted
-	pub fn to_eth(self) -> (ethcore::transaction::Transaction, Address) {
-		(ethcore::transaction::Transaction {
-			nonce: self.nonce.unwrap_or(U256::zero()),
-			action: match self.to {
-				None => ethcore::transaction::Action::Create,
-				Some(addr) => ethcore::transaction::Action::Call(addr)
-			},
-			gas: self.gas.unwrap_or(U256::zero()),
-			gas_price: self.gas_price.unwrap_or(U256::zero()),
-			value: self.value.unwrap_or(U256::zero()),
-			data: self.data.to_vec()
-		}, self.from)
-	}
-}
-
 impl From<LocalizedTransaction> for Transaction {
 	fn from(t: LocalizedTransaction) -> Transaction {
 		Transaction {

rpc/src/v1/types/transaction_request.rs

@@ -0,0 +1,139 @@
+// 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::{Uint, U256};
+use ethcore::transaction::{Action, Transaction};
+use v1::types::Bytes;
+
+#[derive(Debug, Default, PartialEq, 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>,
+}
+
+impl Into<Transaction> for TransactionRequest {
+	fn into(self) -> Transaction {
+		Transaction {
+			nonce: self.nonce.unwrap_or_else(U256::zero),
+			action: self.to.map_or(Action::Create, Action::Call),
+			gas: self.gas.unwrap_or_else(U256::zero),
+			gas_price: self.gas_price.unwrap_or_else(U256::zero),
+			value: self.value.unwrap_or_else(U256::zero),
+			data: self.data.map_or_else(Vec::new, |d| d.to_vec()),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use serde_json;
+	use util::numbers::{Uint, U256};
+	use util::hash::Address;
+	use ethcore::transaction::{Transaction, Action};
+	use v1::types::Bytes;
+	use super::*;
+
+	#[test]
+	fn transaction_request_into_transaction() {
+		let tr = TransactionRequest {
+			from: Address::default(),
+			to: Some(Address::from(10)),
+			gas_price: Some(U256::from(20)),
+			gas: Some(U256::from(10_000)),
+			value: Some(U256::from(1)),
+			data: Some(Bytes::new(vec![10, 20])),
+			nonce: Some(U256::from(12)),
+		};
+
+		assert_eq!(Transaction {
+			nonce: U256::from(12),
+			action: Action::Call(Address::from(10)),
+			gas: U256::from(10_000),
+			gas_price: U256::from(20),
+			value: U256::from(1),
+			data: vec![10, 20],
+		}, tr.into());
+	}
+
+	#[test]
+	fn empty_transaction_request_into_transaction() {
+		let tr = TransactionRequest {
+			from: Address::default(),
+			to: None,
+			gas_price: None,
+			gas: None,
+			value: None,
+			data: None,
+			nonce: None,
+		};
+
+		assert_eq!(Transaction {
+			nonce: U256::zero(),
+			action: Action::Create,
+			gas: U256::zero(),
+			gas_price: U256::zero(),
+			value: U256::zero(),
+			data: vec![],
+		}, tr.into());
+	}
+
+	#[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_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,
+		});
+	}
+}

util/bigint/src/uint.rs

@@ -39,7 +39,6 @@
 use std::fmt;
 use std::cmp;
 
-use std::mem;
 use std::str::{FromStr};
 use std::convert::From;
 use std::hash::{Hash, Hasher};
@@ -788,14 +787,11 @@ macro_rules! construct_uint {
 
 					fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: serde::Error {
 						// 0x + len
-						if value.len() != 2 + $n_words / 8 {
+						if value.len() > 2 + $n_words * 16 {
 							return Err(serde::Error::custom("Invalid length."));
 						}
 
-						match $name::from_str(&value[2..]) {
-							Ok(val) => Ok(val),
-							Err(_) => { return Err(serde::Error::custom("Invalid length.")); }
-						}
+						$name::from_str(&value[2..]).map_err(|_| serde::Error::custom("Invalid hex value."))
 					}
 
 					fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: serde::Error {

util/src/hash.rs

@@ -257,7 +257,7 @@ macro_rules! impl_hash {
 							return Err(serde::Error::custom("Invalid length."));
 						}
 
-						value[2..].from_hex().map(|ref v| $from::from_slice(v)).map_err(|_| serde::Error::custom("Invalid valid hex."))
+						value[2..].from_hex().map(|ref v| $from::from_slice(v)).map_err(|_| serde::Error::custom("Invalid hex value."))
 					}
 
 					fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: serde::Error {