Merge branch 'master' into reorgjdb

Conflicts:
	parity/main.rs

Cargo.lock

@@ -219,7 +219,6 @@ dependencies = [
  "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "rust-crypto 0.2.34 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -243,7 +242,6 @@ dependencies = [
  "jsonrpc-http-server 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_codegen 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -299,7 +297,6 @@ dependencies = [
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
  "rayon 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.34 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 

Cargo.toml

@@ -27,19 +27,12 @@ ethcore-devtools = { path = "devtools" }
 ethcore-rpc = { path = "rpc", optional = true }
 rpassword = "0.1"
 
-[dev-dependencies]
-ethcore = { path = "ethcore", features = ["dev"] }
-ethcore-util = { path = "util", features = ["dev"] }
-ethsync = { path = "sync", features = ["dev"] }
-ethcore-rpc = { path = "rpc", features = ["dev"] }
-
 [features]
 default = ["rpc"]
 rpc = ["ethcore-rpc"]
-dev = ["ethcore/dev", "ethcore-util/dev", "ethsync/dev", "ethcore-rpc/dev"]
+dev = ["clippy", "ethcore/dev", "ethcore-util/dev", "ethsync/dev", "ethcore-rpc/dev"]
-dev-clippy = ["clippy", "ethcore/clippy", "ethcore-util/clippy", "ethsync/clippy", "ethcore-rpc/clippy"]
 travis-beta = ["ethcore/json-tests"]
-travis-nightly = ["ethcore/json-tests", "dev-clippy", "dev"]
+travis-nightly = ["ethcore/json-tests", "dev"]
 
 [[bin]]
 path = "parity/main.rs"

cargo.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-cargo "$@" --features dev-clippy

ethcore/Cargo.toml

@@ -5,10 +5,6 @@ license = "GPL-3.0"
 name = "ethcore"
 version = "0.9.99"
 authors = ["Ethcore <admin@ethcore.io>"]
-build = "build.rs"
-
-[build-dependencies]
-rustc_version = "0.1"
 
 [dependencies]
 log = "0.3"
@@ -31,5 +27,5 @@ jit = ["evmjit"]
 evm-debug = []
 json-tests = []
 test-heavy = []
-dev = []
+dev = ["clippy"]
 default = []

ethcore/src/basic_types.rs

@@ -24,7 +24,7 @@ pub type LogBloom = H2048;
 /// Constant 2048-bit datum for 0. Often used as a default.
 pub static ZERO_LOGBLOOM: LogBloom = H2048([0x00; 256]);
 
-#[cfg_attr(all(nightly, feature="dev"), allow(enum_variant_names))]
+#[cfg_attr(feature="dev", allow(enum_variant_names))]
 /// Semantic boolean for when a seal/signature is included.
 pub enum Seal {
 	/// The seal/signature is included.

ethcore/src/block.rs

@@ -16,7 +16,7 @@
 
 //! Blockchain block.
 
-#![cfg_attr(all(nightly, feature="dev"), allow(ptr_arg))] // Because of &LastHashes -> &Vec<_>
+#![cfg_attr(feature="dev", allow(ptr_arg))] // Because of &LastHashes -> &Vec<_>
 
 use common::*;
 use engine::*;

ethcore/src/block_queue.rs

@@ -121,7 +121,7 @@ struct QueueSignal {
 }
 
 impl QueueSignal {
-	#[cfg_attr(all(nightly, feature="dev"), allow(bool_comparison))]
+	#[cfg_attr(feature="dev", allow(bool_comparison))]
 	fn set(&self) {
 		if self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) == false {
 			self.message_channel.send(UserMessage(SyncMessage::BlockVerified)).expect("Error sending BlockVerified message");

ethcore/src/blockchain/blockchain.rs

@@ -907,7 +907,7 @@ mod tests {
 	}
 
 	#[test]
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn test_find_uncles() {
 		let mut canon_chain = ChainGenerator::default();
 		let mut finalizer = BlockFinalizer::default();
@@ -945,7 +945,7 @@ mod tests {
 	}
 
 	#[test]
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn test_small_fork() {
 		let mut canon_chain = ChainGenerator::default();
 		let mut finalizer = BlockFinalizer::default();

ethcore/src/ethereum/ethash.rs

@@ -202,7 +202,7 @@ impl Engine for Ethash {
 	}
 }
 
-#[cfg_attr(all(nightly, feature="dev"), allow(wrong_self_convention))] // to_ethash should take self
+#[cfg_attr(feature="dev", allow(wrong_self_convention))] // to_ethash should take self
 impl Ethash {
 	fn calculate_difficuty(&self, header: &Header, parent: &Header) -> U256 {
 		const EXP_DIFF_PERIOD: u64 = 100000;

ethcore/src/evm/interpreter.rs

@@ -243,7 +243,7 @@ struct CodeReader<'a> {
 	code: &'a Bytes
 }
 
-#[cfg_attr(all(nightly, feature="dev"), allow(len_without_is_empty))]
+#[cfg_attr(feature="dev", allow(len_without_is_empty))]
 impl<'a> CodeReader<'a> {
 	/// Get `no_of_bytes` from code and convert to U256. Move PC
 	fn read(&mut self, no_of_bytes: usize) -> U256 {
@@ -258,7 +258,7 @@ impl<'a> CodeReader<'a> {
 	}
 }
 
-#[cfg_attr(all(nightly, feature="dev"), allow(enum_variant_names))]
+#[cfg_attr(feature="dev", allow(enum_variant_names))]
 enum InstructionCost {
 	Gas(U256),
 	GasMem(U256, U256),
@@ -347,7 +347,7 @@ impl evm::Evm for Interpreter {
 }
 
 impl Interpreter {
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn get_gas_cost_mem(&self,
 						ext: &evm::Ext,
 						instruction: Instruction,

ethcore/src/externalities.rs

@@ -188,7 +188,7 @@ impl<'a> Ext for Externalities<'a> {
 		self.state.code(address).unwrap_or_else(|| vec![])
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(match_ref_pats))]
+	#[cfg_attr(feature="dev", allow(match_ref_pats))]
 	fn ret(&mut self, gas: &U256, data: &[u8]) -> Result<U256, evm::Error> {
 		match &mut self.output {
 			&mut OutputPolicy::Return(BytesRef::Fixed(ref mut slice)) => unsafe {

ethcore/src/lib.rs

@@ -15,16 +15,16 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 #![warn(missing_docs)]
-#![cfg_attr(all(nightly, feature="dev"), feature(plugin))]
+#![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(all(nightly, feature="dev"), plugin(clippy))]
+#![cfg_attr(feature="dev", plugin(clippy))]
 
 // Clippy config
 // TODO [todr] not really sure
-#![cfg_attr(all(nightly, feature="dev"), allow(needless_range_loop))]
+#![cfg_attr(feature="dev", allow(needless_range_loop))]
 // Shorter than if-else
-#![cfg_attr(all(nightly, feature="dev"), allow(match_bool))]
+#![cfg_attr(feature="dev", allow(match_bool))]
 // Keeps consistency (all lines with `.clone()`) and helpful when changing ref to non-ref.
-#![cfg_attr(all(nightly, feature="dev"), allow(clone_on_copy))]
+#![cfg_attr(feature="dev", allow(clone_on_copy))]
 
 //! Ethcore library
 //!

ethcore/src/service.rs

@@ -117,7 +117,7 @@ impl IoHandler<NetSyncMessage> for ClientIoHandler {
 		}
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(single_match))]
+	#[cfg_attr(feature="dev", allow(single_match))]
 	fn message(&self, io: &IoContext<NetSyncMessage>, net_message: &NetSyncMessage) {
 		if let UserMessage(ref message) = *net_message {
 			match *message {

ethcore/src/spec.rs

@@ -99,7 +99,7 @@ pub struct Spec {
 	genesis_state: PodState,
 }
 
-#[cfg_attr(all(nightly, feature="dev"), allow(wrong_self_convention))] // because to_engine(self) should be to_engine(&self)
+#[cfg_attr(feature="dev", allow(wrong_self_convention))] // because to_engine(self) should be to_engine(&self)
 impl Spec {
 	/// Convert this object into a boxed Engine of the right underlying type.
 	// TODO avoid this hard-coded nastiness - use dynamic-linked plugin framework instead.

ethcore/src/state.rs

@@ -224,7 +224,7 @@ impl State {
 
 	/// Commit accounts to SecTrieDBMut. This is similar to cpp-ethereum's dev::eth::commit.
 	/// `accounts` is mutable because we may need to commit the code or storage and record that.
-	#[cfg_attr(all(nightly, feature="dev"), allow(match_ref_pats))]
+	#[cfg_attr(feature="dev", allow(match_ref_pats))]
 	pub fn commit_into(db: &mut HashDB, root: &mut H256, accounts: &mut HashMap<Address, Option<Account>>) {
 		// first, commit the sub trees.
 		// TODO: is this necessary or can we dispense with the `ref mut a` for just `a`?

ethcore/src/transaction.rs

@@ -80,7 +80,7 @@ impl Transaction {
 }
 
 impl FromJson for SignedTransaction {
-	#[cfg_attr(all(nightly, feature="dev"), allow(single_char_pattern))]
+	#[cfg_attr(feature="dev", allow(single_char_pattern))]
 	fn from_json(json: &Json) -> SignedTransaction {
 		let t = Transaction {
 			nonce: xjson!(&json["nonce"]),

hook.sh

@@ -1,3 +1,12 @@
 #!/bin/sh
-echo "#!/bin/sh\ncargo test -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity --features dev-clippy" > ./.git/hooks/pre-push
+FILE=./.git/hooks/pre-push
-chmod +x ./.git/hooks/pre-push
+echo "#!/bin/sh\n" > $FILE
+# Exit on any error
+echo "set -e" >> $FILE
+# Run release build
+echo "cargo build --release --features dev" >> $FILE
+# Build tests
+echo "cargo test --no-run --features dev \\" >> $FILE
+echo "	-p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity" >> $FILE
+echo "" >> $FILE
+chmod +x $FILE

parity/main.rs

@@ -17,8 +17,8 @@
 //! Ethcore client application.
 
 #![warn(missing_docs)]
-#![cfg_attr(all(nightly, feature="dev"), feature(plugin))]
+#![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(all(nightly, feature="dev"), plugin(clippy))]
+#![cfg_attr(feature="dev", plugin(clippy))]
 extern crate docopt;
 extern crate rustc_serialize;
 extern crate ethcore_util as util;
@@ -37,7 +37,7 @@ extern crate rpassword;
 #[cfg(feature = "rpc")]
 extern crate ethcore_rpc as rpc;
 
-use std::net::{SocketAddr};
+use std::net::{SocketAddr, IpAddr};
 use std::env;
 use std::process::exit;
 use std::path::PathBuf;
@@ -71,9 +71,9 @@ Parity. Ethereum Client.
   Copyright 2015, 2016 Ethcore (UK) Limited
 
 Usage:
-  parity daemon <pid-file> [options] [ --no-bootstrap | <enode>... ]
+  parity daemon <pid-file> [options]
   parity account (new | list)
-  parity [options] [ --no-bootstrap | <enode>... ]
+  parity [options]
 
 Protocol Options:
   --chain CHAIN            Specify the blockchain type. CHAIN may be either a JSON chain specification file
@@ -81,19 +81,21 @@ Protocol Options:
   --testnet                Equivalent to --chain testnet (geth-compatible).
   --networkid INDEX        Override the network identifier from the chain we are on.
   --pruning METHOD         Configure pruning of the state/storage trie. METHOD may be one of: archive,
-                           light (experimental) [default: archive]. 
+                           light (experimental) [default: archive].
   -d --datadir PATH        Specify the database & configuration directory path [default: $HOME/.parity]
+  --db-path PATH           Specify the database & configuration directory path [default: $HOME/.parity]
+  --pruning                Client should prune the state/storage trie.
   --keys-path PATH         Specify the path for JSON key files to be found [default: $HOME/.web3/keys]
   --identity NAME          Specify your node's name.
 
 Networking Options:
-  --no-bootstrap           Don't bother trying to connect to any nodes initially.
+  --port PORT              Override the port on which the node should listen [default: 30303].
-  --listen-address URL     Specify the IP/port on which to listen for peers [default: 0.0.0.0:30304].
-  --public-address URL     Specify the IP/port on which peers may connect.
-  --address URL            Equivalent to --listen-address URL --public-address URL.
   --peers NUM              Try to maintain that many peers [default: 25].
+  --nat METHOD             Specify method to use for determining public address. Must be one of: any, none,
+                           upnp, extip:(IP) [default: any].
+  --bootnodes NODES        Specify additional comma-separated bootnodes.
+  --no-bootstrap           Don't bother trying to connect to standard bootnodes.
   --no-discovery           Disable new peer discovery.
-  --no-upnp                Disable trying to figure out the correct public adderss over UPnP.
   --node-key KEY           Specify node secret key, either as 64-character hex string or input to SHA3 operation.
 
 API and Console Options:
@@ -112,7 +114,7 @@ API and Console Options:
 Sealing/Mining Options:
   --author ADDRESS         Specify the block author (aka "coinbase") address for sending block rewards
                            from sealed blocks [default: 0037a6b811ffeb6e072da21179d11b1406371c63].
-  --extradata STRING      Specify a custom extra-data for authored blocks, no more than 32 characters.
+  --extra-data STRING      Specify a custom extra-data for authored blocks, no more than 32 characters.
 
 Memory Footprint Options:
   --cache-pref-size BYTES  Specify the prefered size of the blockchain cache in bytes [default: 16384].
@@ -121,6 +123,21 @@ Memory Footprint Options:
   --cache MEGABYTES        Set total amount of cache to use for the entire system, mutually exclusive with
                            other cache options (geth-compatible).
 
+Geth-Compatibility Options
+  --datadir PATH           Equivalent to --db-path PATH.
+  --testnet                Equivalent to --chain testnet.
+  --networkid INDEX        Override the network identifier from the chain we are on.
+  --rpc                    Equivalent to --jsonrpc.
+  --rpcaddr HOST           Equivalent to --jsonrpc-addr HOST.
+  --rpcport PORT           Equivalent to --jsonrpc-port PORT.
+  --rpcapi APIS            Equivalent to --jsonrpc-apis APIS.
+  --rpccorsdomain URL      Equivalent to --jsonrpc-cors URL.
+  --maxpeers COUNT         Equivalent to --peers COUNT.
+  --nodekey KEY            Equivalent to --node-key KEY.
+  --nodiscover             Equivalent to --no-discovery.
+  --etherbase ADDRESS      Equivalent to --author ADDRESS.
+  --extradata STRING       Equivalent to --extra-data STRING.
+
 Miscellaneous Options:
   -l --logging LOGGING     Specify the logging level.
   -v --version             Show information about version.
@@ -134,22 +151,18 @@ struct Args {
 	cmd_new: bool,
 	cmd_list: bool,
 	arg_pid_file: String,
-	arg_enode: Vec<String>,
 	flag_chain: String,
-	flag_testnet: bool,
+	flag_db_path: String,
-	flag_datadir: String,
-	flag_networkid: Option<String>,
 	flag_identity: String,
 	flag_cache: Option<usize>,
 	flag_keys_path: String,
+	flag_bootnodes: Option<String>,
 	flag_pruning: String,
 	flag_no_bootstrap: bool,
-	flag_listen_address: String,
+	flag_port: u16,
-	flag_public_address: Option<String>,
-	flag_address: Option<String>,
 	flag_peers: usize,
 	flag_no_discovery: bool,
-	flag_no_upnp: bool,
+	flag_nat: String,
 	flag_node_key: Option<String>,
 	flag_cache_pref_size: usize,
 	flag_cache_max_size: usize,
@@ -159,15 +172,24 @@ struct Args {
 	flag_jsonrpc_port: u16,
 	flag_jsonrpc_cors: String,
 	flag_jsonrpc_apis: String,
+	flag_logging: Option<String>,
+	flag_version: bool,
+	// geth-compatibility...
+	flag_nodekey: Option<String>,
+	flag_nodiscover: bool,
+	flag_maxpeers: Option<usize>,
+	flag_author: String,
+	flag_extra_data: Option<String>,
+	flag_datadir: Option<String>,
+	flag_extradata: Option<String>,
+	flag_etherbase: Option<String>,
 	flag_rpc: bool,
 	flag_rpcaddr: Option<String>,
 	flag_rpcport: Option<u16>,
 	flag_rpccorsdomain: Option<String>,
 	flag_rpcapi: Option<String>,
-	flag_logging: Option<String>,
+	flag_testnet: bool,
-	flag_version: bool,
+	flag_networkid: Option<String>,
-	flag_author: String,
-	flag_extra_data: Option<String>,
 }
 
 fn setup_log(init: &Option<String>) {
@@ -247,15 +269,17 @@ impl Configuration {
 	}
 
 	fn path(&self) -> String {
-		self.args.flag_datadir.replace("$HOME", env::home_dir().unwrap().to_str().unwrap())
+		let d = self.args.flag_datadir.as_ref().unwrap_or(&self.args.flag_db_path);
+		d.replace("$HOME", env::home_dir().unwrap().to_str().unwrap())
 	}
 
 	fn author(&self) -> Address {
-		Address::from_str(&self.args.flag_author).unwrap_or_else(|_| die!("{}: Invalid address for --author. Must be 40 hex characters, without the 0x at the beginning.", self.args.flag_author))
+		let d = self.args.flag_etherbase.as_ref().unwrap_or(&self.args.flag_author);
+		Address::from_str(d).unwrap_or_else(|_| die!("{}: Invalid address for --author. Must be 40 hex characters, without the 0x at the beginning.", self.args.flag_author))
 	}
 
 	fn extra_data(&self) -> Bytes {
-		match self.args.flag_extra_data {
+		match self.args.flag_extradata.as_ref().or(self.args.flag_extra_data.as_ref()) {
 			Some(ref x) if x.len() <= 32 => x.as_bytes().to_owned(),
 			None => version_data(),
 			Some(ref x) => { die!("{}: Extra data must be at most 32 characters.", x); }
@@ -287,45 +311,36 @@ impl Configuration {
 	}
 
 	fn init_nodes(&self, spec: &Spec) -> Vec<String> {
-		if self.args.flag_no_bootstrap { Vec::new() } else {
+		let mut r = if self.args.flag_no_bootstrap { Vec::new() } else { spec.nodes().clone() };
-			match self.args.arg_enode.len() {
+		if let Some(ref x) = self.args.flag_bootnodes {
-				0 => spec.nodes().clone(),
+			r.extend(x.split(",").map(|s| Self::normalize_enode(s).unwrap_or_else(|| die!("{}: Invalid node address format given for a boot node.", s))));
-				_ => self.args.arg_enode.iter().map(|s| Self::normalize_enode(s).unwrap_or_else(||die!("{}: Invalid node address format given for a boot node.", s))).collect(),
-			}
 		}
+		r
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(useless_format))]
+	#[cfg_attr(feature="dev", allow(useless_format))]
 	fn net_addresses(&self) -> (Option<SocketAddr>, Option<SocketAddr>) {
-		let mut listen_address = None;
+		let listen_address = Some(SocketAddr::new(IpAddr::from_str("0.0.0.0").unwrap(), self.args.flag_port));
-		let mut public_address = None;
+		let public_address = if self.args.flag_nat.starts_with("extip:") {
-
+			let host = &self.args.flag_nat[6..];
-		if let Some(ref a) = self.args.flag_address {
+			let host = IpAddr::from_str(host).unwrap_or_else(|_| die!("Invalid host given with `--nat extip:{}`", host));
-			public_address = Some(SocketAddr::from_str(a.as_ref()).unwrap_or_else(|_| die!("{}: Invalid listen/public address given with --address", a)));
+			Some(SocketAddr::new(host, self.args.flag_port))
-			listen_address = public_address;
+		} else {
-		}
+			listen_address.clone()
-		if listen_address.is_none() {
+		};
-			listen_address = Some(SocketAddr::from_str(self.args.flag_listen_address.as_ref()).unwrap_or_else(|_| die!("{}: Invalid listen/public address given with --listen-address", self.args.flag_listen_address)));
-		}
-		if let Some(ref a) = self.args.flag_public_address {
-			if public_address.is_some() {
-				die!("Conflicting flags provided: --address and --public-address");
-			}
-			public_address = Some(SocketAddr::from_str(a.as_ref()).unwrap_or_else(|_| die!("{}: Invalid listen/public address given with --public-address", a)));
-		}
 		(listen_address, public_address)
 	}
 
 	fn net_settings(&self, spec: &Spec) -> NetworkConfiguration {
 		let mut ret = NetworkConfiguration::new();
-		ret.nat_enabled = !self.args.flag_no_upnp;
+		ret.nat_enabled = self.args.flag_nat == "any" || self.args.flag_nat == "upnp";
 		ret.boot_nodes = self.init_nodes(spec);
 		let (listen, public) = self.net_addresses();
 		ret.listen_address = listen;
 		ret.public_address = public;
 		ret.use_secret = self.args.flag_node_key.as_ref().map(|s| Secret::from_str(&s).unwrap_or_else(|_| s.sha3()));
-		ret.discovery_enabled = !self.args.flag_no_discovery;
+		ret.discovery_enabled = !self.args.flag_no_discovery && !self.args.flag_nodiscover;
-		ret.ideal_peers = self.args.flag_peers as u32;
+		ret.ideal_peers = self.args.flag_maxpeers.unwrap_or(self.args.flag_peers) as u32;
 		let mut net_path = PathBuf::from(&self.path());
 		net_path.push("network");
 		ret.config_path = Some(net_path.to_str().unwrap().to_owned());
@@ -405,11 +420,12 @@ impl Configuration {
 			}
 		}
 		client_config.pruning = match self.args.flag_pruning.as_str() {
+			"" => journaldb::Algorithm::Archive,
 			"archive" => journaldb::Algorithm::Archive,
 			"pruned" => journaldb::Algorithm::EarlyMerge,
 //			"fast" => journaldb::Algorithm::OverlayRecent,	// TODO: @arkpar uncomment this once option 2 is merged.
 //			"slow" => journaldb::Algorithm::RefCounted,		// TODO: @gavofyork uncomment this once ref-count algo is merged.
-			_ => { die!("{}: Invalid pruning method given.", self.args.flag_pruning); }
+			_ => { die!("Invalid pruning method given."); }
 		};
 		client_config.name = self.args.flag_identity.clone();
 		client_config.queue.max_mem_use = self.args.flag_queue_max_size;

rpc/Cargo.toml

@@ -26,9 +26,8 @@ serde_macros = { version = "0.7.0", optional = true }
 [build-dependencies]
 serde_codegen = { version = "0.7.0", optional = true }
 syntex = "0.29.0"
-rustc_version = "0.1"
 
 [features]
 default = ["serde_codegen"]
 nightly = ["serde_macros"]
-dev = ["ethcore/dev", "ethcore-util/dev", "ethsync/dev"]
+dev = ["clippy", "ethcore/dev", "ethcore-util/dev", "ethsync/dev"]

rpc/build.rs

@@ -14,10 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-extern crate rustc_version;
-
-use rustc_version::{version_meta, Channel};
-
 #[cfg(not(feature = "serde_macros"))]
 mod inner {
     extern crate syntex;
@@ -46,7 +42,4 @@ mod inner {
 
 fn main() {
     inner::main();
-	if let Channel::Nightly = version_meta().channel {
-		println!("cargo:rustc-cfg=nightly");
-	}
 }

rpc/src/v1/impls/eth.rs

@@ -27,6 +27,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};
@@ -274,7 +275,7 @@ impl<C, S, A> Eth for EthClient<C, S, A> where C: BlockChainClient + 'static, S:
 				match accounts.account_secret(&transaction_request.from) {
 					Ok(secret) => {
 						let sync = take_weak!(self.sync);
-						let (transaction, _) = transaction_request.to_eth();
+						let transaction: EthTransaction = transaction_request.into();
 						let signed_transaction = transaction.sign(&secret);
 						let hash = signed_transaction.hash();
 						sync.insert_transaction(signed_transaction);

rpc/src/v1/impls/net.rs

@@ -36,10 +36,15 @@ impl<S> NetClient<S> where S: SyncProvider {
 
 impl<S> Net for NetClient<S> where S: SyncProvider + 'static {
 	fn version(&self, _: Params) -> Result<Value, Error> {
-		Ok(Value::U64(take_weak!(self.sync).status().protocol_version as u64))
+		Ok(Value::String(format!("{}", take_weak!(self.sync).status().protocol_version).to_owned()))
 	}
 
 	fn peer_count(&self, _params: Params) -> Result<Value, Error> {
-		Ok(Value::U64(take_weak!(self.sync).status().num_peers as u64))
+		Ok(Value::String(format!("0x{:x}", take_weak!(self.sync).status().num_peers as u64).to_owned()))
+	}
+
+	fn is_listening(&self, _: Params) -> Result<Value, Error> {
+		// right now (11 march 2016), we are always listening for incoming connections
+		Ok(Value::Bool(true))
 	}
 }

rpc/src/v1/mod.rs

@@ -21,9 +21,10 @@
 pub mod traits;
 mod impls;
 mod types;
+mod helpers;
+
 #[cfg(test)]
 mod tests;
-mod helpers;
 
 pub use self::traits::{Web3, Eth, EthFilter, Personal, Net};
 pub use self::impls::*;

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

@@ -14,12 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-extern crate rustc_version;
+mod sync_provider;
 
-use rustc_version::{version_meta, Channel};
+pub use self::sync_provider::{Config, TestSyncProvider};
-
-fn main() {
-	if let Channel::Nightly = version_meta().channel {
-		println!("cargo:rustc-cfg=nightly");
-	}
-}

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

@@ -0,0 +1,58 @@
+// 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 ethcore::transaction::SignedTransaction;
+use ethsync::{SyncProvider, SyncStatus, SyncState};
+
+pub struct Config {
+	pub protocol_version: u8,
+	pub num_peers: usize,
+}
+
+pub struct TestSyncProvider {
+	status: SyncStatus,
+}
+
+impl TestSyncProvider {
+	pub fn new(config: Config) -> Self {
+		TestSyncProvider {
+			status: SyncStatus {
+				state: SyncState::NotSynced,
+				protocol_version: config.protocol_version,
+				start_block_number: 0,
+				last_imported_block_number: None,
+				highest_block_number: None,
+				blocks_total: 0,
+				blocks_received: 0,
+				num_peers: config.num_peers,
+				num_active_peers: 0,
+				mem_used: 0,
+				transaction_queue_pending: 0,
+			},
+		}
+	}
+}
+
+impl SyncProvider for TestSyncProvider {
+	fn status(&self) -> SyncStatus {
+		self.status.clone()
+	}
+
+	fn insert_transaction(&self, _transaction: SignedTransaction) {
+		unimplemented!()
+	}
+}
+

rpc/src/v1/tests/mod.rs

@@ -1 +1,20 @@
-//TODO: load custom blockchain state and test
+// 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/>.
+
+//!TODO: load custom blockchain state and test
+
+mod net;
+mod helpers;

rpc/src/v1/tests/net.rs

@@ -0,0 +1,66 @@
+// 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::sync::Arc;
+use jsonrpc_core::IoHandler;
+use v1::{Net, NetClient};
+use v1::tests::helpers::{Config, TestSyncProvider};
+
+fn sync_provider() -> Arc<TestSyncProvider> {
+	Arc::new(TestSyncProvider::new(Config {
+		protocol_version: 65,
+		num_peers: 120,
+	}))
+}
+
+#[test]
+fn rpc_net_version() {
+	let sync = sync_provider();
+	let net = NetClient::new(&sync).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(net);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "net_version", "params": [], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"65","id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_string()));
+}
+
+#[test]
+fn rpc_net_peer_count() {
+	let sync = sync_provider();
+	let net = NetClient::new(&sync).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(net);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "net_peerCount", "params": [], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x78","id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_string()));
+}
+
+#[test]
+fn rpc_net_listening() {
+	let sync = sync_provider();
+	let net = NetClient::new(&sync).to_delegate();
+	let io = IoHandler::new();
+	io.add_delegate(net);
+
+	let request = r#"{"jsonrpc": "2.0", "method": "net_listening", "params": [], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_string()));
+}

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 serde::Error;
-use ethcore;
 
 #[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,
+		});
+	}
+}

sync/Cargo.toml

@@ -4,13 +4,9 @@ name = "ethsync"
 version = "0.9.99"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io"]
-build = "build.rs"
 
 [lib]
 
-[build-dependencies]
-rustc_version = "0.1"
-
 [dependencies]
 ethcore-util = { path = "../util" }
 ethcore = { path = "../ethcore" }
@@ -25,4 +21,4 @@ rayon = "0.3.1"
 
 [features]
 default = []
-dev = ["ethcore/dev", "ethcore-util/dev"]
+dev = ["clippy", "ethcore/dev", "ethcore-util/dev"]

sync/build.rs

@@ -1,25 +0,0 @@
-// 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/>.
-
-extern crate rustc_version;
-
-use rustc_version::{version_meta, Channel};
-
-fn main() {
-	if let Channel::Nightly = version_meta().channel {
-		println!("cargo:rustc-cfg=nightly");
-	}
-}

sync/src/chain.rs

@@ -120,6 +120,7 @@ pub enum SyncState {
 }
 
 /// Syncing status and statistics
+#[derive(Clone)]
 pub struct SyncStatus {
 	/// State
 	pub state: SyncState,
@@ -278,7 +279,7 @@ impl ChainSync {
 	}
 
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(for_kv_map))] // Because it's not possible to get `values_mut()`
+	#[cfg_attr(feature="dev", allow(for_kv_map))] // Because it's not possible to get `values_mut()`
 	/// Rest sync. Clear all downloaded data but keep the queue
 	fn reset(&mut self) {
 		self.downloading_headers.clear();
@@ -346,7 +347,7 @@ impl ChainSync {
 		Ok(())
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	/// Called by peer once it has new block headers during sync
 	fn on_peer_block_headers(&mut self, io: &mut SyncIo, peer_id: PeerId, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
 		self.reset_peer_asking(peer_id, PeerAsking::BlockHeaders);
@@ -473,7 +474,7 @@ impl ChainSync {
 	}
 
 	/// Called by peer once it has new block bodies
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn on_peer_new_block(&mut self, io: &mut SyncIo, peer_id: PeerId, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
 		let block_rlp = try!(r.at(0));
 		let header_rlp = try!(block_rlp.at(0));

sync/src/lib.rs

@@ -15,11 +15,11 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 #![warn(missing_docs)]
-#![cfg_attr(all(nightly, feature="dev"), feature(plugin))]
+#![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(all(nightly, feature="dev"), plugin(clippy))]
+#![cfg_attr(feature="dev", plugin(clippy))]
 
 // Keeps consistency (all lines with `.clone()`) and helpful when changing ref to non-ref.
-#![cfg_attr(all(nightly, feature="dev"), allow(clone_on_copy))]
+#![cfg_attr(feature="dev", allow(clone_on_copy))]
 
 //! Blockchain sync module
 //! Implements ethereum protocol version 63 as specified here:

sync/src/range_collection.rs

@@ -42,7 +42,7 @@ pub trait RangeCollection<K, V> {
 	fn remove_head(&mut self, start: &K);
 	/// Remove all elements >= `start` in the range that contains `start`
 	fn remove_tail(&mut self, start: &K);
-	/// Remove all elements >= `start` 
+	/// Remove all elements >= `start`
 	fn remove_from(&mut self, start: &K);
 	/// Remove all elements >= `tail`
 	fn insert_item(&mut self, key: K, value: V);
@@ -231,7 +231,7 @@ impl<K, V> RangeCollection<K, V> for Vec<(K, Vec<V>)> where K: Ord + PartialEq +
 }
 
 #[test]
-#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 fn test_range() {
 	use std::cmp::{Ordering};
 

util/Cargo.toml

@@ -40,8 +40,7 @@ chrono = "0.2"
 
 [features]
 default = []
-dev = []
+dev = ["clippy"]
 
 [build-dependencies]
 vergen = "*"
-rustc_version = "0.1"

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..]) {
+						$name::from_str(&value[2..]).map_err(|_| serde::Error::custom("Invalid hex value."))
-							Ok(val) => Ok(val),
-							Err(_) => { return Err(serde::Error::custom("Invalid length.")); }
-						}
 					}
 
 					fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: serde::Error {
@@ -1103,7 +1099,7 @@ macro_rules! construct_uint {
 			}
 		}
 
-		#[cfg_attr(all(nightly, feature="dev"), allow(derive_hash_xor_eq))] // We are pretty sure it's ok.
+		#[cfg_attr(feature="dev", allow(derive_hash_xor_eq))] // We are pretty sure it's ok.
 		impl Hash for $name {
 			fn hash<H>(&self, state: &mut H) where H: Hasher {
 				unsafe { state.write(::std::slice::from_raw_parts(self.0.as_ptr() as *mut u8, self.0.len() * 8)); }
@@ -1485,7 +1481,7 @@ mod tests {
 	}
 
 	#[test]
-	#[cfg_attr(all(nightly, feature="dev"), allow(eq_op))]
+	#[cfg_attr(feature="dev", allow(eq_op))]
 	pub fn uint256_comp_test() {
 		let small = U256([10u64, 0, 0, 0]);
 		let big = U256([0x8C8C3EE70C644118u64, 0x0209E7378231E632, 0, 0]);
@@ -2032,7 +2028,7 @@ mod tests {
 
 
 	#[test]
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn u256_multi_full_mul() {
 		let result = U256([0, 0, 0, 0]).full_mul(U256([0, 0, 0, 0]));
 		assert_eq!(U512([0, 0, 0, 0, 0, 0, 0, 0]), result);

util/build.rs

@@ -14,15 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-extern crate rustc_version;
 extern crate vergen;
 
 use vergen::*;
-use rustc_version::{version_meta, Channel};
 
 fn main() {
 	vergen(OutputFns::all()).unwrap();
-	if let Channel::Nightly = version_meta().channel {
-		println!("cargo:rustc-cfg=nightly");
-	}
 }

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 {
@@ -305,7 +305,7 @@ macro_rules! impl_hash {
 		}
 
 		impl Copy for $from {}
-		#[cfg_attr(all(nightly, feature="dev"), allow(expl_impl_clone_on_copy))]
+		#[cfg_attr(feature="dev", allow(expl_impl_clone_on_copy))]
 		impl Clone for $from {
 			fn clone(&self) -> $from {
 				unsafe {
@@ -637,7 +637,7 @@ mod tests {
 	use std::str::FromStr;
 
 	#[test]
-	#[cfg_attr(all(nightly, feature="dev"), allow(eq_op))]
+	#[cfg_attr(feature="dev", allow(eq_op))]
 	fn hash() {
 		let h = H64([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
 		assert_eq!(H64::from_str("0123456789abcdef").unwrap(), h);

util/src/lib.rs

@@ -15,18 +15,18 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 #![warn(missing_docs)]
-#![cfg_attr(all(nightly, feature="dev"), feature(plugin))]
+#![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(all(nightly, feature="dev"), plugin(clippy))]
+#![cfg_attr(feature="dev", plugin(clippy))]
 
 // Clippy settings
 // TODO [todr] not really sure
-#![cfg_attr(all(nightly, feature="dev"), allow(needless_range_loop))]
+#![cfg_attr(feature="dev", allow(needless_range_loop))]
 // Shorter than if-else
-#![cfg_attr(all(nightly, feature="dev"), allow(match_bool))]
+#![cfg_attr(feature="dev", allow(match_bool))]
 // We use that to be more explicit about handled cases
-#![cfg_attr(all(nightly, feature="dev"), allow(match_same_arms))]
+#![cfg_attr(feature="dev", allow(match_same_arms))]
 // Keeps consistency (all lines with `.clone()`) and helpful when changing ref to non-ref.
-#![cfg_attr(all(nightly, feature="dev"), allow(clone_on_copy))]
+#![cfg_attr(feature="dev", allow(clone_on_copy))]
 
 //! Ethcore-util library
 //!

util/src/network/discovery.rs

@@ -243,7 +243,7 @@ impl Discovery {
 		self.send_to(packet, address.clone());
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(map_clone))]
+	#[cfg_attr(feature="dev", allow(map_clone))]
 	fn nearest_node_entries(target: &NodeId, buckets: &[NodeBucket]) -> Vec<NodeEntry> {
 		let mut found: BTreeMap<u32, Vec<&NodeEntry>> = BTreeMap::new();
 		let mut count = 0;

util/src/network/host.rs

@@ -507,7 +507,7 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 		debug!(target: "network", "Connecting peers: {} sessions, {} pending", self.session_count(), self.handshake_count());
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(single_match))]
+	#[cfg_attr(feature="dev", allow(single_match))]
 	fn connect_peer(&self, id: &NodeId, io: &IoContext<NetworkIoMessage<Message>>) {
 		if self.have_session(id)
 		{
@@ -542,7 +542,7 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 		self.create_connection(socket, Some(id), io);
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(block_in_if_condition_stmt))]
+	#[cfg_attr(feature="dev", allow(block_in_if_condition_stmt))]
 	fn create_connection(&self, socket: TcpStream, id: Option<&NodeId>, io: &IoContext<NetworkIoMessage<Message>>) {
 		let nonce = self.info.write().unwrap().next_nonce();
 		let mut handshakes = self.handshakes.write().unwrap();

util/src/panics.rs

@@ -71,7 +71,7 @@ impl PanicHandler {
 
 	/// Invoke closure and catch any possible panics.
 	/// In case of panic notifies all listeners about it.
-	#[cfg_attr(all(nightly, feature="dev"), allow(deprecated))]
+	#[cfg_attr(feature="dev", allow(deprecated))]
 	pub fn catch_panic<G, R>(&self, g: G) -> thread::Result<R> where G: FnOnce() -> R + Send + 'static {
 		let _guard = PanicGuard { handler: self };
 		let result = g();

util/src/trie/triedb.rs

@@ -54,7 +54,7 @@ pub struct TrieDB<'db> {
 	pub hash_count: usize,
 }
 
-#[cfg_attr(all(nightly, feature="dev"), allow(wrong_self_convention))]
+#[cfg_attr(feature="dev", allow(wrong_self_convention))]
 impl<'db> TrieDB<'db> {
 	/// Create a new trie with the backing database `db` and `root`
 	/// Panics, if `root` does not exist

util/src/trie/triedbmut.rs

@@ -66,7 +66,7 @@ enum MaybeChanged<'a> {
 	Changed(Bytes),
 }
 
-#[cfg_attr(all(nightly, feature="dev"), allow(wrong_self_convention))]
+#[cfg_attr(feature="dev", allow(wrong_self_convention))]
 impl<'db> TrieDBMut<'db> {
 	/// Create a new trie with the backing database `db` and empty `root`
 	/// Initialise to the state entailed by the genesis block.
@@ -350,7 +350,7 @@ impl<'db> TrieDBMut<'db> {
 		}
 	}
 
-	#[cfg_attr(all(nightly, feature="dev"), allow(cyclomatic_complexity))]
+	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	/// Determine the RLP of the node, assuming we're inserting `partial` into the
 	/// node currently of data `old`. This will *not* delete any hash of `old` from the database;
 	/// it will just return the new RLP that includes the new node.