util reexports less std

Cargo.lock

@@ -181,6 +181,14 @@ name = "blastfig"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "bloomable"
+version = "0.1.0"
+dependencies = [
+ "ethcore-bigint 0.1.3",
+ "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "bloomchain"
 version = "0.1.0"
@@ -271,6 +279,7 @@ dependencies = [
 name = "common-types"
 version = "0.1.0"
 dependencies = [
+ "bloomable 0.1.0",
  "ethcore-util 1.8.0",
  "ethjson 0.1.0",
  "rlp 0.2.0",
@@ -462,6 +471,7 @@ name = "ethcore"
 version = "1.8.0"
 dependencies = [
  "bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bloomable 0.1.0",
  "bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bn 0.4.4 (git+https://github.com/paritytech/bn)",
  "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -502,8 +512,10 @@ dependencies = [
  "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "stats 0.1.0",
+ "table 0.1.0",
  "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
  "transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "using_queue 0.1.0",
 ]
 
 [[package]]
@@ -751,11 +763,9 @@ dependencies = [
  "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "sha3 0.1.0",
- "table 0.1.0",
  "target_info 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
  "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "using_queue 0.1.0",
  "vergen 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 

ethcore/Cargo.toml

@@ -53,6 +53,9 @@ semver = "0.6"
 stats = { path = "../util/stats" }
 time = "0.1"
 transient-hashmap = "0.4"
+using_queue = { path = "../util/using_queue" }
+table = { path = "../util/table" }
+bloomable = { path = "../util/bloomable" }
 
 [dev-dependencies]
 native-contracts = { path = "native_contracts", features = ["test_contracts"] }

ethcore/evm/src/interpreter/gasometer.rs

@@ -14,6 +14,7 @@
 // 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::cmp;
 use util::*;
 use super::u256_to_address;
 
@@ -82,7 +83,7 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 				};
 
 				if let Some(Ok(r)) = requested {
-					Ok(min(r, max_gas_provided))
+					Ok(cmp::min(r, max_gas_provided))
 				} else {
 					Ok(max_gas_provided)
 				}

ethcore/evm/src/interpreter/mod.rs

@@ -23,12 +23,13 @@ mod stack;
 mod memory;
 mod shared_cache;
 
+use std::marker::PhantomData;
+use std::{cmp, mem};
 use self::gasometer::Gasometer;
 use self::stack::{Stack, VecStack};
 use self::memory::Memory;
 pub use self::shared_cache::SharedCache;
 
-use std::marker::PhantomData;
 use action_params::{ActionParams, ActionValue};
 use call_type::CallType;
 use instructions::{self, Instruction, InstructionInfo};

ethcore/evm/src/tests.rs

@@ -15,6 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::fmt::Debug;
+use std::str::FromStr;
+use std::collections::{HashMap, HashSet};
 use rustc_hex::FromHex;
 use util::*;
 use action_params::{ActionParams, ActionValue};

ethcore/src/account_db.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! DB backend wrapper for Account trie
+use std::collections::HashMap;
 use util::*;
 use rlp::NULL_RLP;
 

ethcore/src/blockchain/blockchain.rs

@@ -16,6 +16,8 @@
 
 //! Blockchain database.
 
+use std::collections::{HashMap, HashSet};
+use std::mem;
 use bloomchain as bc;
 use util::*;
 use rlp::*;

ethcore/src/blockchain/extras.rs

@@ -16,6 +16,8 @@
 
 //! Blockchain DB extras.
 
+use std::ops;
+use std::io::Write;
 use bloomchain;
 use blooms::{GroupPosition, BloomGroup};
 use db::Key;
@@ -56,7 +58,7 @@ fn with_index(hash: &H256, i: ExtrasIndex) -> H264 {
 
 pub struct BlockNumberKey([u8; 5]);
 
-impl Deref for BlockNumberKey {
+impl ops::Deref for BlockNumberKey {
 	type Target = [u8];
 
 	fn deref(&self) -> &Self::Target {
@@ -88,7 +90,7 @@ impl Key<BlockDetails> for H256 {
 
 pub struct LogGroupKey([u8; 6]);
 
-impl Deref for LogGroupKey {
+impl ops::Deref for LogGroupKey {
 	type Target = [u8];
 
 	fn deref(&self) -> &Self::Target {
@@ -160,7 +162,8 @@ pub const EPOCH_KEY_PREFIX: &'static [u8; DB_PREFIX_LEN] = &[
 ];
 
 pub struct EpochTransitionsKey([u8; EPOCH_KEY_LEN]);
-impl Deref for EpochTransitionsKey {
+
+impl ops::Deref for EpochTransitionsKey {
 	type Target = [u8];
 
 	fn deref(&self) -> &[u8] { &self.0[..] }

ethcore/src/client/test_client.rs

@@ -17,6 +17,8 @@
 //! Test client.
 
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
+use std::collections::{HashMap, BTreeMap};
+use std::mem;
 use rustc_hex::FromHex;
 use util::*;
 use rlp::*;

ethcore/src/engines/authority_round/mod.rs

@@ -19,6 +19,8 @@
 use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
 use std::sync::Weak;
 use std::time::{UNIX_EPOCH, Duration};
+use std::collections::{BTreeMap, HashSet, HashMap};
+use std::cmp;
 
 use account_provider::AccountProvider;
 use block::*;
@@ -463,9 +465,9 @@ impl Engine for AuthorityRound {
 			let gas_limit = parent.gas_limit().clone();
 			let bound_divisor = self.gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
-				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+				cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
+				cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			}
 		});
 	}
@@ -815,7 +817,7 @@ impl Engine for AuthorityRound {
 		}
 	}
 
-	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
+	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> Result<(), Error> {
 		t.check_low_s()?;
 
 		if let Some(n) = t.network_id() {
@@ -852,6 +854,7 @@ impl Engine for AuthorityRound {
 #[cfg(test)]
 mod tests {
 	use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+	use std::str::FromStr;
 	use util::*;
 	use header::Header;
 	use error::{Error, BlockError};

ethcore/src/engines/basic_authority.rs

@@ -17,6 +17,8 @@
 //! A blockchain engine that supports a basic, non-BFT proof-of-authority.
 
 use std::sync::Weak;
+use std::collections::BTreeMap;
+use std::cmp;
 use util::*;
 use ethkey::{recover, public_to_address, Signature};
 use account_provider::AccountProvider;
@@ -121,9 +123,9 @@ impl Engine for BasicAuthority {
 			let gas_limit = parent.gas_limit().clone();
 			let bound_divisor = self.gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
-				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+				cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
+				cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			}
 		});
 	}
@@ -147,7 +149,7 @@ impl Engine for BasicAuthority {
 		Seal::None
 	}
 
-	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// check the seal fields.
 		// TODO: pull this out into common code.
 		if header.seal().len() != self.seal_fields() {
@@ -158,11 +160,11 @@ impl Engine for BasicAuthority {
 		Ok(())
 	}
 
-	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		Ok(())
 	}
 
-	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// Do not calculate difficulty for genesis blocks.
 		if header.number() == 0 {
 			return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));

ethcore/src/engines/instant_seal.rs

@@ -14,8 +14,8 @@
 // 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::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
-use util::{Address, HashMap};
+use util::Address;
 use builtin::Builtin;
 use engines::{Engine, Seal};
 use spec::CommonParams;

ethcore/src/engines/mod.rs

@@ -36,6 +36,8 @@ pub use self::null_engine::NullEngine;
 pub use self::tendermint::Tendermint;
 
 use std::sync::Weak;
+use std::collections::{BTreeMap, HashMap};
+use std::fmt;
 
 use self::epoch::PendingTransition;
 

ethcore/src/engines/tendermint/message.rs

@@ -16,6 +16,7 @@
 
 //! Tendermint message handling.
 
+use std::cmp;
 use util::*;
 use super::{Height, View, BlockHash, Step};
 use error::Error;
@@ -110,13 +111,13 @@ impl Default for VoteStep {
 }
 
 impl PartialOrd for VoteStep {
-	fn partial_cmp(&self, m: &VoteStep) -> Option<Ordering> {
+	fn partial_cmp(&self, m: &VoteStep) -> Option<cmp::Ordering> {
 		Some(self.cmp(m))
 	}
 }
 
 impl Ord for VoteStep {
-	fn cmp(&self, m: &VoteStep) -> Ordering {
+	fn cmp(&self, m: &VoteStep) -> cmp::Ordering {
 		if self.height != m.height {
 			self.height.cmp(&m.height)
 		} else if self.view != m.view {

ethcore/src/engines/tendermint/mod.rs

@@ -27,6 +27,8 @@ mod params;
 
 use std::sync::Weak;
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+use std::collections::{HashSet, BTreeMap, HashMap};
+use std::cmp;
 use util::*;
 use client::{Client, EngineClient};
 use error::{Error, BlockError};
@@ -473,9 +475,9 @@ impl Engine for Tendermint {
 			let gas_limit = parent.gas_limit().clone();
 			let bound_divisor = self.gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
-				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+				cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
+				cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			}
 		});
 	}
@@ -771,6 +773,7 @@ impl Engine for Tendermint {
 
 #[cfg(test)]
 mod tests {
+	use std::str::FromStr;
 	use rustc_hex::FromHex;
 	use util::*;
 	use block::*;

ethcore/src/engines/validator_set/contract.rs

@@ -142,11 +142,11 @@ mod tests {
 	#[test]
 	fn fetches_validators() {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, None);
-		let vc = Arc::new(ValidatorContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
+		let vc = Arc::new(ValidatorContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
 		vc.register_contract(Arc::downgrade(&client));
 		let last_hash = client.best_block_header().hash();
-		assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
+		assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
-		assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
+		assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
 	}
 
 	#[test]
@@ -155,7 +155,7 @@ mod tests {
 		let v1 = tap.insert_account("1".sha3().into(), "").unwrap();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, Some(tap.clone()));
 		client.engine().register_client(Arc::downgrade(&client));
-		let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
+		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 
 		// Make sure reporting can be done.
 		client.miner().set_gas_floor_target(1_000_000.into());

ethcore/src/engines/validator_set/multi.rs

@@ -142,6 +142,7 @@ impl ValidatorSet for Multi {
 
 #[cfg(test)]
 mod tests {
+	use std::collections::BTreeMap;
 	use account_provider::AccountProvider;
 	use client::{BlockChainClient, EngineClient};
 	use engines::EpochChange;

ethcore/src/engines/validator_set/safe_contract.rs

@@ -438,11 +438,11 @@ mod tests {
 	#[test]
 	fn fetches_validators() {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
-		let vc = Arc::new(ValidatorSafeContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
+		let vc = Arc::new(ValidatorSafeContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
 		vc.register_contract(Arc::downgrade(&client));
 		let last_hash = client.best_block_header().hash();
-		assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
+		assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
-		assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
+		assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
 	}
 
 	#[test]
@@ -454,7 +454,7 @@ mod tests {
 		let network_id = Spec::new_validator_safe_contract().network_id();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, Some(tap));
 		client.engine().register_client(Arc::downgrade(&client));
-		let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
+		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 
 		client.miner().set_engine_signer(v1, "".into()).unwrap();
 		// Remove "1" validator.
@@ -520,7 +520,7 @@ mod tests {
 
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
 		let engine = client.engine().clone();
-		let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
+		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 
 		let last_hash = client.best_block_header().hash();
 		let mut new_header = Header::default();

ethcore/src/engines/vote_collector.rs

@@ -17,6 +17,7 @@
 //! Collects votes on hashes at each Message::Round.
 
 use std::fmt::Debug;
+use std::collections::{BTreeMap, HashSet, HashMap};
 use util::*;
 use rlp::{Encodable, RlpStream};
 

ethcore/src/error.rs

@@ -16,6 +16,7 @@
 
 //! General error types for use in ethcore.
 
+use std::fmt;
 use util::*;
 use io::*;
 use header::BlockNumber;

ethcore/src/ethereum/ethash.rs

@@ -15,6 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::path::Path;
+use std::cmp;
+use std::collections::{BTreeMap, HashMap};
 use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager};
 use util::*;
 use block::*;
@@ -235,15 +237,15 @@ impl Engine for Arc<Ethash> {
 			let lower_limit = gas_limit - gas_limit / bound_divisor + 1.into();
 			let upper_limit = gas_limit + gas_limit / bound_divisor - 1.into();
 			let gas_limit = if gas_limit < gas_floor_target {
-				let gas_limit = min(gas_floor_target, upper_limit);
+				let gas_limit = cmp::min(gas_floor_target, upper_limit);
 				round_block_gas_limit(gas_limit, lower_limit, upper_limit)
 			} else if gas_limit > gas_ceil_target {
-				let gas_limit = max(gas_ceil_target, lower_limit);
+				let gas_limit = cmp::max(gas_ceil_target, lower_limit);
 				round_block_gas_limit(gas_limit, lower_limit, upper_limit)
 			} else {
-				let total_lower_limit = max(lower_limit, gas_floor_target);
+				let total_lower_limit = cmp::max(lower_limit, gas_floor_target);
-				let total_upper_limit = min(upper_limit, gas_ceil_target);
+				let total_upper_limit = cmp::min(upper_limit, gas_ceil_target);
-				let gas_limit = max(gas_floor_target, min(total_upper_limit,
+				let gas_limit = cmp::max(gas_floor_target, cmp::min(total_upper_limit,
 					lower_limit + (header.gas_used().clone() * 6.into() / 5.into()) / bound_divisor));
 				round_block_gas_limit(gas_limit, total_lower_limit, total_upper_limit)
 			};
@@ -319,7 +321,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
 
-	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// check the seal fields.
 		if header.seal().len() != self.seal_fields() {
 			return Err(From::from(BlockError::InvalidSealArity(
@@ -357,7 +359,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
 
-	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		if header.seal().len() != self.seal_fields() {
 			return Err(From::from(BlockError::InvalidSealArity(
 				Mismatch { expected: self.seal_fields(), found: header.seal().len() }
@@ -376,7 +378,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
 
-	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// we should not calculate difficulty for genesis blocks
 		if header.number() == 0 {
 			return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
@@ -400,7 +402,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
 
-	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
+	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> Result<(), Error> {
 		if header.number() >= self.ethash_params.min_gas_price_transition && t.gas_price < self.ethash_params.min_gas_price {
 			return Err(TransactionError::InsufficientGasPrice { minimal: self.ethash_params.min_gas_price, got: t.gas_price }.into());
 		}
@@ -493,28 +495,28 @@ impl Ethash {
 			if diff_inc <= threshold {
 				*parent.difficulty() + *parent.difficulty() / difficulty_bound_divisor * (threshold - diff_inc).into()
 			} else {
-				let multiplier = min(diff_inc - threshold, 99).into();
+				let multiplier = cmp::min(diff_inc - threshold, 99).into();
 				parent.difficulty().saturating_sub(
 					*parent.difficulty() / difficulty_bound_divisor * multiplier
 				)
 			}
 		};
-		target = max(min_difficulty, target);
+		target = cmp::max(min_difficulty, target);
 		if header.number() < self.ethash_params.bomb_defuse_transition {
 			if header.number() < self.ethash_params.ecip1010_pause_transition {
 				let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
 				if period > 1 {
-					target = max(min_difficulty, target + (U256::from(1) << (period - 2)));
+					target = cmp::max(min_difficulty, target + (U256::from(1) << (period - 2)));
 				}
 			}
 			else if header.number() < self.ethash_params.ecip1010_continue_transition {
 				let fixed_difficulty = ((self.ethash_params.ecip1010_pause_transition / EXP_DIFF_PERIOD) - 2) as usize;
-				target = max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
+				target = cmp::max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
 			}
 			else {
 				let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
 				let delay = ((self.ethash_params.ecip1010_continue_transition - self.ethash_params.ecip1010_pause_transition) / EXP_DIFF_PERIOD) as usize;
-				target = max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
+				target = cmp::max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
 			}
 		}
 		target
@@ -559,6 +561,8 @@ impl Header {
 
 #[cfg(test)]
 mod tests {
+	use std::str::FromStr;
+	use std::collections::BTreeMap;
 	use util::*;
 	use block::*;
 	use tests::helpers::*;

ethcore/src/executive.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Transaction Execution environment.
+use std::cmp;
 use util::*;
 use evm::action_params::{ActionParams, ActionValue};
 use state::{Backend as StateBackend, State, Substate, CleanupMode};
@@ -597,10 +598,11 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 #[allow(dead_code)]
 mod tests {
 	use std::sync::Arc;
+	use std::str::FromStr;
 	use rustc_hex::FromHex;
 	use ethkey::{Generator, Random};
 	use super::*;
-	use util::{H256, U256, U512, Address, FromStr};
+	use util::{H256, U256, U512, Address};
 	use util::bytes::BytesRef;
 	use evm::action_params::{ActionParams, ActionValue};
 	use evm::env_info::EnvInfo;

ethcore/src/externalities.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Transaction Execution environment.
+use std::cmp;
 use util::*;
 use evm::action_params::{ActionParams, ActionValue};
 use state::{Backend as StateBackend, State, Substate, CleanupMode};
@@ -470,7 +471,7 @@ mod tests {
 
 		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer, &mut vm_tracer, false);
 
-		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+		let hash = ext.blockhash(&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap());
 
 		assert_eq!(hash, H256::zero());
 	}
@@ -494,7 +495,7 @@ mod tests {
 
 		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer, &mut vm_tracer, false);
 
-		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+		let hash = ext.blockhash(&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap());
 
 		assert_eq!(test_hash, hash);
 	}
@@ -513,10 +514,10 @@ mod tests {
 
 		// this should panic because we have no balance on any account
 		ext.call(
-			&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap(),
+			&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap(),
 			&Address::new(),
 			&Address::new(),
-			Some(U256::from_str("0000000000000000000000000000000000000000000000000000000000150000").unwrap()),
+			Some("0000000000000000000000000000000000000000000000000000000000150000".parse::<U256>().unwrap()),
 			&[],
 			&Address::new(),
 			&mut output,

ethcore/src/header.rs

@@ -16,13 +16,13 @@
 
 //! Block header.
 
+use std::cmp;
+use std::cell::RefCell;
 use util::*;
 use basic_types::{LogBloom, ZERO_LOGBLOOM};
 use time::get_time;
 use rlp::*;
 
-use std::cell::RefCell;
-
 pub use basic_types::Seal;
 
 pub use types::BlockNumber;
@@ -175,7 +175,7 @@ impl Header {
 	/// Set the timestamp field of the header.
 	pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
 	/// Set the timestamp field of the header to the current time.
-	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
+	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = cmp::max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
 	/// Set the number field of the header.
 	pub fn set_number(&mut self, a: BlockNumber) { self.number = a; self.note_dirty(); }
 	/// Set the author field of the header.
@@ -275,7 +275,7 @@ impl Decodable for Header {
 			number: r.val_at(8)?,
 			gas_limit: r.val_at(9)?,
 			gas_used: r.val_at(10)?,
-			timestamp: min(r.val_at::<U256>(11)?, u64::max_value().into()).as_u64(),
+			timestamp: cmp::min(r.val_at::<U256>(11)?, u64::max_value().into()).as_u64(),
 			extra_data: r.val_at(12)?,
 			seal: vec![],
 			hash: RefCell::new(Some(r.as_raw().sha3())),

ethcore/src/lib.rs

@@ -106,6 +106,9 @@ extern crate semver;
 extern crate stats;
 extern crate time;
 extern crate transient_hashmap;
+extern crate using_queue;
+extern crate table;
+extern crate bloomable;
 
 #[macro_use]
 extern crate log;

ethcore/src/miner/miner.rs

@@ -15,9 +15,10 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::time::{Instant, Duration};
+use std::collections::{BTreeMap, HashSet};
 
 use util::*;
-use util::using_queue::{UsingQueue, GetAction};
+use using_queue::{UsingQueue, GetAction};
 use account_provider::{AccountProvider, SignError as AccountError};
 use state::{State, CleanupMode};
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockId, CallAnalytics, TransactionId};

ethcore/src/miner/transaction_queue.rs

@@ -106,7 +106,7 @@ use std::cmp;
 use std::collections::{HashSet, HashMap, BTreeSet, BTreeMap};
 use linked_hash_map::LinkedHashMap;
 use util::{Address, H256, U256, HeapSizeOf};
-use util::table::Table;
+use table::Table;
 use transaction::*;
 use error::{Error, TransactionError};
 use client::TransactionImportResult;
@@ -1447,7 +1447,7 @@ fn check_if_removed(sender: &Address, nonce: &U256, dropped: Option<HashMap<Addr
 #[cfg(test)]
 pub mod test {
 	use rustc_hex::FromHex;
-	use util::table::*;
+	use table::Table;
 	use util::*;
 	use ethkey::{Random, Generator};
 	use error::{Error, TransactionError};

ethcore/src/miner/work_notify.rs

@@ -16,6 +16,7 @@
 
 extern crate hyper;
 
+use std::io::Write;
 use hyper::header::ContentType;
 use hyper::method::Method;
 use hyper::client::{Request, Response, Client};

ethcore/src/pod_account.rs

@@ -14,6 +14,8 @@
 // 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::fmt;
+use std::collections::BTreeMap;
 use util::*;
 use state::Account;
 use ethjson;
@@ -166,7 +168,7 @@ pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<A
 
 #[cfg(test)]
 mod test {
-	use util::*;
+	use std::collections::BTreeMap;
 	use types::account_diff::*;
 	use super::{PodAccount, diff_pod};
 

ethcore/src/pod_state.rs

@@ -16,6 +16,8 @@
 
 //! State of all accounts in the system expressed in Plain Old Data.
 
+use std::fmt;
+use std::collections::BTreeMap;
 use util::*;
 use pod_account::{self, PodAccount};
 use types::state_diff::StateDiff;
@@ -77,7 +79,7 @@ pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff {
 
 #[cfg(test)]
 mod test {
-	use util::*;
+	use std::collections::BTreeMap;
 	use types::state_diff::*;
 	use types::account_diff::*;
 	use pod_account::PodAccount;

ethcore/src/spec/spec.rs

@@ -16,6 +16,8 @@
 
 //! Parameters for a block chain.
 
+use std::io::Read;
+use std::collections::BTreeMap;
 use rustc_hex::FromHex;
 use super::genesis::Genesis;
 use super::seal::Generic as GenericSeal;
@@ -484,6 +486,7 @@ impl Spec {
 
 #[cfg(test)]
 mod tests {
+	use std::str::FromStr;
 	use util::*;
 	use views::*;
 	use tests::helpers::get_temp_state_db;

ethcore/src/state/account.rs

@@ -16,6 +16,8 @@
 
 //! Single account in the system.
 
+use std::fmt;
+use std::collections::HashMap;
 use util::*;
 use pod_account::*;
 use rlp::*;

ethcore/src/state/mod.rs

@@ -21,6 +21,8 @@
 
 use std::cell::{RefCell, RefMut};
 use std::collections::hash_map::Entry;
+use std::collections::{HashMap, BTreeMap, HashSet};
+use std::fmt;
 
 use receipt::Receipt;
 use engines::Engine;

ethcore/src/tests/client.rs

@@ -14,6 +14,7 @@
 // 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::str::FromStr;
 use io::IoChannel;
 use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockId};
 use state::{self, State, CleanupMode};

ethcore/src/tests/helpers.rs

@@ -14,6 +14,7 @@
 // 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::BTreeMap;
 use ethkey::KeyPair;
 use io::*;
 use client::{BlockChainClient, Client, ClientConfig};
@@ -347,7 +348,7 @@ pub fn get_good_dummy_block_fork_seq(start_number: usize, count: usize, parent_h
 	for i in start_number .. start_number + count + 1 {
 		let mut block_header = Header::new();
 		block_header.set_gas_limit(test_engine.params().min_gas_limit);
-		block_header.set_difficulty(U256::from(i).mul(U256([0, 1, 0, 0])));
+		block_header.set_difficulty(U256::from(i) * U256([0, 1, 0, 0]));
 		block_header.set_timestamp(rolling_timestamp);
 		block_header.set_number(i as u64);
 		block_header.set_parent_hash(parent);

ethcore/src/trace/types/filter.rs

@@ -20,7 +20,7 @@ use std::ops::Range;
 use bloomchain::{Filter as BloomFilter, Bloom, Number};
 use util::Address;
 use util::sha3::Hashable;
-use util::bloom::Bloomable;
+use bloomable::Bloomable;
 use basic_types::LogBloom;
 use trace::flat::FlatTrace;
 use super::trace::{Action, Res};
@@ -137,7 +137,7 @@ impl Filter {
 mod tests {
 	use util::Address;
 	use util::sha3::Hashable;
-	use util::bloom::Bloomable;
+	use bloomable::Bloomable;
 	use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide};
 	use trace::flat::FlatTrace;
 	use trace::{Filter, AddressesFilter, TraceError};

ethcore/src/trace/types/trace.rs

@@ -18,7 +18,7 @@
 
 use util::{U256, Bytes, Address};
 use util::sha3::Hashable;
-use util::bloom::Bloomable;
+use bloomable::Bloomable;
 use rlp::*;
 
 use evm::action_params::ActionParams;

ethcore/src/verification/queue/mod.rs

@@ -20,6 +20,8 @@
 use std::thread::{self, JoinHandle};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering};
 use std::sync::{Condvar as SCondvar, Mutex as SMutex};
+use std::cmp;
+use std::collections::{VecDeque, HashSet, HashMap};
 use util::*;
 use io::*;
 use error::*;
@@ -234,8 +236,8 @@ impl<K: Kind> VerificationQueue<K> {
 		let scale_verifiers = config.verifier_settings.scale_verifiers;
 
 		let num_cpus = ::num_cpus::get();
-		let max_verifiers = min(num_cpus, MAX_VERIFIERS);
+		let max_verifiers = cmp::min(num_cpus, MAX_VERIFIERS);
-		let default_amount = max(1, min(max_verifiers, config.verifier_settings.num_verifiers));
+		let default_amount = cmp::max(1, cmp::min(max_verifiers, config.verifier_settings.num_verifiers));
 		let state = Arc::new((Mutex::new(State::Work(default_amount)), Condvar::new()));
 		let mut verifier_handles = Vec::with_capacity(max_verifiers);
 
@@ -278,8 +280,8 @@ impl<K: Kind> VerificationQueue<K> {
 			processing: RwLock::new(HashMap::new()),
 			empty: empty,
 			ticks_since_adjustment: AtomicUsize::new(0),
-			max_queue_size: max(config.max_queue_size, MIN_QUEUE_LIMIT),
+			max_queue_size: cmp::max(config.max_queue_size, MIN_QUEUE_LIMIT),
-			max_mem_use: max(config.max_mem_use, MIN_MEM_LIMIT),
+			max_mem_use: cmp::max(config.max_mem_use, MIN_MEM_LIMIT),
 			scale_verifiers: scale_verifiers,
 			verifier_handles: verifier_handles,
 			state: state,
@@ -567,7 +569,7 @@ impl<K: Kind> VerificationQueue<K> {
 	/// Removes up to `max` verified items from the queue
 	pub fn drain(&self, max: usize) -> Vec<K::Verified> {
 		let mut verified = self.verification.verified.lock();
-		let count = min(max, verified.len());
+		let count = cmp::min(max, verified.len());
 		let result = verified.drain(..count).collect::<Vec<_>>();
 
 		let drained_size = result.iter().map(HeapSizeOf::heap_size_of_children).fold(0, |a, c| a + c);
@@ -687,8 +689,8 @@ impl<K: Kind> VerificationQueue<K> {
 	// or below 1.
 	fn scale_verifiers(&self, target: usize) {
 		let current = self.num_verifiers();
-		let target = min(self.verifier_handles.len(), target);
+		let target = cmp::min(self.verifier_handles.len(), target);
-		let target = max(1, target);
+		let target = cmp::max(1, target);
 
 		debug!(target: "verification", "Scaling from {} to {} verifiers", current, target);
 
@@ -725,7 +727,6 @@ impl<K: Kind> Drop for VerificationQueue<K> {
 
 #[cfg(test)]
 mod tests {
-	use util::*;
 	use io::*;
 	use spec::*;
 	use super::{BlockQueue, Config, State};

ethcore/src/verification/verification.rs

@@ -21,6 +21,7 @@
 //! 2. Signatures verification done in the queue.
 //! 3. Final verification against the blockchain done before enactment.
 
+use std::collections::HashSet;
 use util::*;
 use engines::Engine;
 use error::{BlockError, Error};
@@ -264,6 +265,7 @@ fn verify_block_integrity(block: &[u8], transactions_root: &H256, uncles_hash: &
 
 #[cfg(test)]
 mod tests {
+	use std::collections::{BTreeMap, HashMap};
 	use util::*;
 	use ethkey::{Random, Generator};
 	use header::*;

ethcore/types/Cargo.toml

@@ -8,6 +8,7 @@ authors = ["Parity Technologies <admin@parity.io>"]
 rlp = { path = "../../util/rlp" }
 ethcore-util = { path = "../../util" }
 ethjson = { path = "../../json" }
+bloomable = { path = "../../util/bloomable" }
 
 [dev-dependencies]
 rustc-hex= "1.0"

ethcore/types/src/filter.rs

@@ -17,7 +17,7 @@
 //! Blockchain filter
 
 use util::{Address, H256, Hashable, H2048};
-use util::bloom::Bloomable;
+use bloomable::Bloomable;
 use ids::BlockId;
 use log_entry::LogEntry;
 

ethcore/types/src/lib.rs

@@ -19,6 +19,7 @@
 extern crate ethcore_util as util;
 extern crate ethjson;
 extern crate rlp;
+extern crate bloomable;
 
 #[cfg(test)]
 extern crate rustc_hex;

ethcore/types/src/log_entry.rs

@@ -18,7 +18,7 @@
 
 use std::ops::Deref;
 use util::{H256, Address, Bytes, HeapSizeOf, Hashable};
-use util::bloom::Bloomable;
+use bloomable::Bloomable;
 use rlp::*;
 
 use {BlockNumber};
@@ -114,8 +114,8 @@ mod tests {
 
 	#[test]
 	fn test_empty_log_bloom() {
-		let bloom = H2048::from_str("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
+		let bloom = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".parse::<H2048>().unwrap();
-		let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
+		let address = "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6".parse::<Address>().unwrap();
 		let log = LogEntry {
 			address: address,
 			topics: vec![],

ethkey/cli/src/main.rs

@@ -25,7 +25,7 @@ extern crate panic_hook;
 use std::{env, fmt, process};
 use std::num::ParseIntError;
 use docopt::Docopt;
-use rustc_hex::{FromHex, FromHexError};
+use rustc_hex::{ToHex, FromHex, FromHexError};
 use ethkey::{KeyPair, Random, Brain, Prefix, Error as EthkeyError, Generator, sign, verify_public, verify_address};
 use std::io;
 
@@ -170,7 +170,7 @@ fn main() {
 fn display(keypair: KeyPair, mode: DisplayMode) -> String {
 	match mode {
 		DisplayMode::KeyPair => format!("{}", keypair),
-		DisplayMode::Secret => format!("{:?}", keypair.secret()),
+		DisplayMode::Secret => format!("{}", keypair.secret().to_hex()),
 		DisplayMode::Public => format!("{:?}", keypair.public()),
 		DisplayMode::Address => format!("{:?}", keypair.address()),
 	}
@@ -248,9 +248,9 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
 			.collect::<Vec<String>>();
 
 		let expected =
-"secret:  17d08f5fe8c77af811caa0c9a187e668ce3b74a99acc3f6d976f075fa8e0be55
+"secret:  aa22b54c0cb43ee30a014afe5ef3664b1cde299feabca46cd3167a85a57c39f2
-public:  689268c0ff57a20cd299fa60d3fb374862aff565b20b5f1767906a99e6e09f3ff04ca2b2a5cd22f62941db103c0356df1a8ed20ce322cab2483db67685afd124
+public:  c4c5398da6843632c123f543d714d2d2277716c11ff612b2a2f23c6bda4d6f0327c31cd58c55a9572c3cc141dade0c32747a13b7ef34c241b26c84adbb28fcf4
-address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
+address: 006e27b6a72e1f34c626762f3c4761547aff1421".to_owned();
 		assert_eq!(execute(command).unwrap(), expected);
 	}
 
@@ -261,7 +261,7 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
 			.map(Into::into)
 			.collect::<Vec<String>>();
 
-		let expected = "17d08f5fe8c77af811caa0c9a187e668ce3b74a99acc3f6d976f075fa8e0be55".to_owned();
+		let expected = "aa22b54c0cb43ee30a014afe5ef3664b1cde299feabca46cd3167a85a57c39f2".to_owned();
 		assert_eq!(execute(command).unwrap(), expected);
 	}
 
@@ -272,7 +272,7 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
 			.map(Into::into)
 			.collect::<Vec<String>>();
 
-		let expected = "689268c0ff57a20cd299fa60d3fb374862aff565b20b5f1767906a99e6e09f3ff04ca2b2a5cd22f62941db103c0356df1a8ed20ce322cab2483db67685afd124".to_owned();
+		let expected = "c4c5398da6843632c123f543d714d2d2277716c11ff612b2a2f23c6bda4d6f0327c31cd58c55a9572c3cc141dade0c32747a13b7ef34c241b26c84adbb28fcf4".to_owned();
 		assert_eq!(execute(command).unwrap(), expected);
 	}
 
@@ -283,7 +283,7 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
 			.map(Into::into)
 			.collect::<Vec<String>>();
 
-		let expected = "26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
+		let expected = "006e27b6a72e1f34c626762f3c4761547aff1421".to_owned();
 		assert_eq!(execute(command).unwrap(), expected);
 	}
 

ethkey/src/secret.rs

@@ -17,6 +17,7 @@
 use std::fmt;
 use std::ops::Deref;
 use std::str::FromStr;
+use rustc_hex::ToHex;
 use secp256k1::key;
 use bigint::hash::H256;
 use {Error, SECP256K1};
@@ -26,6 +27,12 @@ pub struct Secret {
 	inner: H256,
 }
 
+impl ToHex for Secret {
+	fn to_hex(&self) -> String {
+		self.inner.to_hex()
+	}
+}
+
 impl fmt::Debug for Secret {
 	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 		write!(fmt, "Secret: 0x{:x}{:x}..{:x}{:x}", self.inner[0], self.inner[1], self.inner[30], self.inner[31])

hash-fetch/src/client.rs

@@ -188,8 +188,9 @@ fn random_temp_path() -> PathBuf {
 
 #[cfg(test)]
 mod tests {
+	use rustc_hex::FromHex;
 	use std::sync::{Arc, mpsc};
-	use util::{Mutex, FromHex};
+	use util::Mutex;
 	use futures::future;
 	use fetch::{self, Fetch};
 	use parity_reactor::Remote;

ipc/hypervisor/src/lib.rs

@@ -260,7 +260,7 @@ mod tests {
 
 			let client = nanoipc::fast_client::<HypervisorServiceClient<_>>(url).unwrap();
 			client.handshake().unwrap();
-			client.module_ready(test_module_id);
+			client.module_ready(test_module_id, url.to_owned());
 		});
 
 		let hypervisor = Hypervisor::with_url(url).local_module(test_module_id);

ipfs/src/lib.rs

@@ -233,7 +233,7 @@ mod tests {
 
 		let _ = write_chunk(&mut transport, &mut progress, b"foobar");
 
-		assert_eq!(b"foobar".into_vec(), transport);
+		assert_eq!(b"foobar".to_vec(), transport);
 		assert_eq!(6, progress);
 	}
 
@@ -244,7 +244,7 @@ mod tests {
 
 		let _ = write_chunk(&mut transport, &mut progress, b"foobar");
 
-		assert_eq!(b"bar".into_vec(), transport);
+		assert_eq!(b"bar".to_vec(), transport);
 		assert_eq!(6, progress);
 	}
 

ipfs/src/route.rs

@@ -119,7 +119,8 @@ mod tests {
 	use ethcore::client::TestBlockChainClient;
 
 	fn get_mocked_handler() -> IpfsHandler {
-		IpfsHandler::new(None, None, Arc::new(TestBlockChainClient::new()))
+		//IpfsHandler::new(None, None, Arc::new(TestBlockChainClient::new()))
+		unimplemented!();
 	}
 
 	#[test]

js/src/lib.rs.in

@@ -51,5 +51,5 @@ impl WebApp for App {
 
 #[test]
 fn test_js() {
-	parity_dapps_glue::js::build(env!("CARGO_MANIFEST_DIR"));
+	parity_dapps_glue::js::build(env!("CARGO_MANIFEST_DIR"), "build");
 }

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

@@ -16,6 +16,7 @@
 
 //! Test implementation of miner service.
 
+use std::collections::{BTreeMap, HashMap};
 use std::collections::hash_map::Entry;
 use util::{Address, H256, Bytes, U256};
 use util::standard::*;

stratum/src/lib.rs

@@ -342,7 +342,7 @@ mod tests {
 		let mut core = Core::new().expect("Tokio Core should be created with no errors");
 		let mut buffer = vec![0u8; 2048];
 
-		let mut data_vec = data.as_bytes().into_vec();
+		let mut data_vec = data.as_bytes().to_vec();
 		data_vec.extend(b"\n");
 
 		let stream = TcpStream::connect(addr, &core.handle())
@@ -353,7 +353,7 @@ mod tests {
 				io::read(stream, &mut buffer)
 			})
 			.and_then(|(_, read_buf, len)| {
-				future::ok(read_buf[0..len].into_vec())
+				future::ok(read_buf[0..len].to_vec())
 			});
 			let result = core.run(stream).expect("Core should run with no errors");
 
@@ -454,7 +454,7 @@ mod tests {
 		let mut auth_request =
 			r#"{"jsonrpc": "2.0", "method": "mining.authorize", "params": ["miner1", ""], "id": 1}"#
 			.as_bytes()
-			.into_vec();
+			.to_vec();
 		auth_request.extend(b"\n");
 
 		let mut core = Core::new().expect("Tokio Core should be created with no errors");
@@ -487,7 +487,7 @@ mod tests {
 			})
 			.and_then(|(_, read_buf, len)| {
 				trace!(target: "stratum", "Received work from server");
-				future::ok(read_buf[0..len].into_vec())
+				future::ok(read_buf[0..len].to_vec())
 			});
 		let response = String::from_utf8(
 			core.run(stream).expect("Core should run with no errors")

sync/src/block_sync.rs

@@ -18,6 +18,8 @@
 /// Blockchain downloader
 ///
 
+use std::collections::{HashSet, VecDeque};
+use std::cmp;
 use util::*;
 use rlp::*;
 use ethcore::views::{BlockView};
@@ -386,7 +388,7 @@ impl BlockDownloader {
 						debug!(target: "sync", "Could not revert to previous ancient block, last: {} ({})", start, start_hash);
 						self.reset();
 					} else {
-						let n = start - min(self.retract_step, start);
+						let n = start - cmp::min(self.retract_step, start);
 						self.retract_step *= 2;
 						match io.chain().block_hash(BlockId::Number(n)) {
 							Some(h) => {

sync/src/blocks.rs

@@ -14,6 +14,7 @@
 // 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, HashMap};
 use std::collections::hash_map::Entry;
 use smallvec::SmallVec;
 use util::*;

sync/src/chain.rs

@@ -89,6 +89,8 @@
 /// All other messages are ignored.
 ///
 
+use std::collections::{HashSet, HashMap};
+use std::cmp;
 use util::*;
 use rlp::*;
 use network::*;
@@ -421,7 +423,7 @@ impl ChainSync {
 			start_block_number: self.starting_block,
 			last_imported_block_number: Some(last_imported_number),
 			last_imported_old_block_number: self.old_blocks.as_ref().map(|d| d.last_imported_block_number()),
-			highest_block_number: self.highest_block.map(|n| max(n, last_imported_number)),
+			highest_block_number: self.highest_block.map(|n| cmp::max(n, last_imported_number)),
 			blocks_received: if last_imported_number > self.starting_block { last_imported_number - self.starting_block } else { 0 },
 			blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
 			num_peers: self.peers.values().filter(|p| p.is_allowed()).count(),
@@ -961,7 +963,7 @@ impl ChainSync {
 		}
 		if self.state != SyncState::Idle {
 			trace!(target: "sync", "Ignoring new hashes since we're already downloading.");
-			let max = r.iter().take(MAX_NEW_HASHES).map(|item| item.val_at::<BlockNumber>(1).unwrap_or(0)).fold(0u64, max);
+			let max = r.iter().take(MAX_NEW_HASHES).map(|item| item.val_at::<BlockNumber>(1).unwrap_or(0)).fold(0u64, cmp::max);
 			if max > self.highest_block.unwrap_or(0) {
 				self.highest_block = Some(max);
 			}
@@ -1473,7 +1475,7 @@ impl ChainSync {
 
 		let mut item_count = r.item_count()?;
 		trace!(target: "sync", "{:02} -> Transactions ({} entries)", peer_id, item_count);
-		item_count = min(item_count, MAX_TX_TO_IMPORT);
+		item_count = cmp::min(item_count, MAX_TX_TO_IMPORT);
 		let mut transactions = Vec::with_capacity(item_count);
 		for i in 0 .. item_count {
 			let rlp = r.at(i)?;
@@ -1549,11 +1551,11 @@ impl ChainSync {
 		};
 
 		let mut number = if reverse {
-			min(last, number)
+			cmp::min(last, number)
 		} else {
-			max(0, number)
+			cmp::max(0, number)
 		};
-		let max_count = min(MAX_HEADERS_TO_SEND, max_headers);
+		let max_count = cmp::min(MAX_HEADERS_TO_SEND, max_headers);
 		let mut count = 0;
 		let mut data = Bytes::new();
 		let inc = (skip + 1) as BlockNumber;
@@ -1594,7 +1596,7 @@ impl ChainSync {
 			debug!(target: "sync", "Empty GetBlockBodies request, ignoring.");
 			return Ok(None);
 		}
-		count = min(count, MAX_BODIES_TO_SEND);
+		count = cmp::min(count, MAX_BODIES_TO_SEND);
 		let mut added = 0usize;
 		let mut data = Bytes::new();
 		for i in 0..count {
@@ -1617,7 +1619,7 @@ impl ChainSync {
 			debug!(target: "sync", "Empty GetNodeData request, ignoring.");
 			return Ok(None);
 		}
-		count = min(count, MAX_NODE_DATA_TO_SEND);
+		count = cmp::min(count, MAX_NODE_DATA_TO_SEND);
 		let mut added = 0usize;
 		let mut data = Vec::new();
 		for i in 0..count {
@@ -1641,7 +1643,7 @@ impl ChainSync {
 			debug!(target: "sync", "Empty GetReceipts request, ignoring.");
 			return Ok(None);
 		}
-		count = min(count, MAX_RECEIPTS_HEADERS_TO_SEND);
+		count = cmp::min(count, MAX_RECEIPTS_HEADERS_TO_SEND);
 		let mut added_headers = 0usize;
 		let mut added_receipts = 0usize;
 		let mut data = Bytes::new();
@@ -1915,8 +1917,8 @@ impl ChainSync {
 		// take sqrt(x) peers
 		let mut peers = peers.to_vec();
 		let mut count = (peers.len() as f64).powf(0.5).round() as usize;
-		count = min(count, MAX_PEERS_PROPAGATION);
+		count = cmp::min(count, MAX_PEERS_PROPAGATION);
-		count = max(count, MIN_PEERS_PROPAGATION);
+		count = cmp::max(count, MIN_PEERS_PROPAGATION);
 		random::new().shuffle(&mut peers);
 		peers.truncate(count);
 		peers
@@ -2006,7 +2008,7 @@ impl ChainSync {
 	fn select_peers_for_transactions<F>(&self, filter: F) -> Vec<PeerId>
 		where F: Fn(&PeerId) -> bool {
 		// sqrt(x)/x scaled to max u32
-		let fraction = (self.peers.len() as f64).powf(-0.5).mul(u32::max_value() as f64).round() as u32;
+		let fraction = ((self.peers.len() as f64).powf(-0.5) * (u32::max_value() as f64).round()) as u32;
 		let small = self.peers.len() < MIN_PEERS_PROPAGATION;
 
 		let mut random = random::new();
@@ -2112,7 +2114,7 @@ impl ChainSync {
 				peers.insert(peer_id);
 				self.send_packet(io, peer_id, TRANSACTIONS_PACKET, rlp);
 				trace!(target: "sync", "{:02} <- Transactions ({} entries)", peer_id, sent);
-				max_sent = max(max_sent, sent);
+				max_sent = cmp::max(max_sent, sent);
 			}
 			debug!(target: "sync", "Sent up to {} transactions to {} peers.", max_sent, lucky_peers_len);
 		}

sync/src/tests/helpers.rs

@@ -14,6 +14,7 @@
 // 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::{VecDeque, HashSet, HashMap};
 use util::*;
 use network::*;
 use tests::snapshot::*;

sync/src/tests/snapshot.rs

@@ -14,6 +14,7 @@
 // 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::HashMap;
 use util::*;
 use ethcore::snapshot::{SnapshotService, ManifestData, RestorationStatus};
 use ethcore::header::BlockNumber;

util/Cargo.toml

@@ -28,8 +28,6 @@ vergen = "0.1"
 target_info = "0.1"
 ethcore-bigint = { path = "bigint", features = ["heapsizeof"] }
 parking_lot = "0.4"
-using_queue = { path = "using_queue" }
-table = { path = "table" }
 ansi_term = "0.9"
 tiny-keccak= "1.0"
 ethcore-bloom-journal = { path = "bloom" }

util/bloomable/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "bloomable"
+version = "0.1.0"
+authors = ["debris <marek.kotewicz@gmail.com>"]
+
+[dependencies]
+ethcore-bigint = { path = "../bigint" }
+
+[dev-dependencies]
+tiny-keccak = "1.2.1"

util/bloomable/src/lib.rs

@@ -16,9 +16,11 @@
 
 //! Bloom operations.
 
+extern crate ethcore_bigint;
+
 use std::mem;
 use std::ops::DerefMut;
-use {H64, H160, H256, H512, H520, H2048};
+use ethcore_bigint::hash::{H64, H160, H256, H512, H520, H2048};
 
 /// Returns log2.
 pub fn log2(x: usize) -> u32 {
@@ -115,31 +117,3 @@ impl_bloomable_for_hash!(H256, 32);
 impl_bloomable_for_hash!(H512, 64);
 impl_bloomable_for_hash!(H520, 65);
 impl_bloomable_for_hash!(H2048, 256);
-
-#[cfg(test)]
-mod tests {
-	use {H160, H256, H2048};
-	use sha3::Hashable;
-	use super::Bloomable;
-
-	#[test]
-	fn shift_bloomed() {
-		let bloom: H2048 = "00000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020000000000000000000000000000000000000000000008000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();
-		let address: H160 = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
-		let topic: H256 = "02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc".into();
-
-		let mut my_bloom = H2048::default();
-		assert!(!my_bloom.contains_bloomed(&address.sha3()));
-		assert!(!my_bloom.contains_bloomed(&topic.sha3()));
-
-		my_bloom.shift_bloomed(&address.sha3());
-		assert!(my_bloom.contains_bloomed(&address.sha3()));
-		assert!(!my_bloom.contains_bloomed(&topic.sha3()));
-
-		my_bloom.shift_bloomed(&topic.sha3());
-		assert_eq!(my_bloom, bloom);
-		assert!(my_bloom.contains_bloomed(&address.sha3()));
-		assert!(my_bloom.contains_bloomed(&topic.sha3()));
-	}
-}
-

util/bloomable/tests/test.rs

@@ -0,0 +1,31 @@
+extern crate tiny_keccak;
+extern crate ethcore_bigint;
+extern crate bloomable;
+
+use ethcore_bigint::hash::{H160, H256, H2048};
+use bloomable::Bloomable;
+use tiny_keccak::keccak256;
+
+fn sha3(input: &[u8]) -> H256 {
+	keccak256(input).into()
+}
+
+#[test]
+fn shift_bloomed() {
+	let bloom: H2048 = "00000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020000000000000000000000000000000000000000000008000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();
+	let address: H160 = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
+	let topic: H256 = "02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc".into();
+
+	let mut my_bloom = H2048::default();
+	assert!(!my_bloom.contains_bloomed(&sha3(&address)));
+	assert!(!my_bloom.contains_bloomed(&sha3(&topic)));
+
+	my_bloom.shift_bloomed(&sha3(&address));
+	assert!(my_bloom.contains_bloomed(&sha3(&address)));
+	assert!(!my_bloom.contains_bloomed(&sha3(&topic)));
+
+	my_bloom.shift_bloomed(&sha3(&topic));
+	assert_eq!(my_bloom, bloom);
+	assert!(my_bloom.contains_bloomed(&sha3(&address)));
+	assert!(my_bloom.contains_bloomed(&sha3(&topic)));
+}

util/src/common.rs

@@ -16,6 +16,7 @@
 
 //! Utils common types and macros global reexport.
 
+use std::io;
 pub use standard::*;
 pub use error::*;
 pub use bytes::*;
@@ -100,8 +101,8 @@ macro_rules! flushln {
 
 #[doc(hidden)]
 pub fn flush(s: String) {
-	let _ = ::std::io::stdout().write(s.as_bytes());
+	let _ = io::Write::write(&mut io::stdout(), s.as_bytes());
-	let _ = ::std::io::stdout().flush();
+	let _ = io::Write::flush(&mut io::stdout());
 }
 
 #[test]

util/src/journaldb/archivedb.rs

@@ -16,6 +16,7 @@
 
 //! Disk-backed `HashDB` implementation.
 
+use std::collections::HashMap;
 use common::*;
 use rlp::*;
 use hashdb::*;

util/src/journaldb/earlymergedb.rs

@@ -16,6 +16,8 @@
 
 //! Disk-backed `HashDB` implementation.
 
+use std::fmt;
+use std::collections::HashMap;
 use common::*;
 use rlp::*;
 use hashdb::*;

util/src/journaldb/mod.rs

@@ -16,6 +16,7 @@
 
 //! `JournalDB` interface and implementation.
 
+use std::{fmt, str};
 use common::*;
 
 /// Export the journaldb module.
@@ -59,7 +60,7 @@ impl Default for Algorithm {
 	fn default() -> Algorithm { Algorithm::OverlayRecent }
 }
 
-impl FromStr for Algorithm {
+impl str::FromStr for Algorithm {
 	type Err = String;
 
 	fn from_str(s: &str) -> Result<Self, Self::Err> {

util/src/journaldb/overlayrecentdb.rs

@@ -16,6 +16,7 @@
 
 //! `JournalDB` over in-memory overlay
 
+use std::collections::HashMap;
 use common::*;
 use rlp::*;
 use hashdb::*;

util/src/journaldb/refcounteddb.rs

@@ -16,6 +16,7 @@
 
 //! Disk-backed, ref-counted `JournalDB` implementation.
 
+use std::collections::HashMap;
 use common::*;
 use rlp::*;
 use hashdb::*;

util/src/kvdb.rs

@@ -16,6 +16,8 @@
 
 //! Key-Value store abstraction with `RocksDB` backend.
 
+use std::{mem, fs};
+use std::collections::{HashMap, BTreeMap};
 use std::io::ErrorKind;
 use std::marker::PhantomData;
 use std::path::PathBuf;

util/src/lib.rs

@@ -112,10 +112,6 @@ extern crate ethcore_logger;
 #[macro_use]
 extern crate log as rlog;
 
-pub extern crate using_queue;
-pub extern crate table;
-
-pub mod bloom;
 pub mod standard;
 #[macro_use]
 pub mod common;
@@ -147,7 +143,6 @@ pub use overlaydb::*;
 pub use journaldb::JournalDB;
 pub use triehash::*;
 pub use trie::{Trie, TrieMut, TrieDB, TrieDBMut, TrieFactory, TrieError, SecTrieDB, SecTrieDBMut};
-pub use nibbleslice::*;
 pub use semantic_version::*;
 pub use kvdb::*;
 pub use timer::*;

util/src/migration/tests.rs

@@ -18,6 +18,7 @@
 //! A random temp directory is created. A database is created within it, and migrations
 //! are performed in temp sub-directories.
 
+use std::collections::BTreeMap;
 use common::*;
 use migration::{Batch, Config, Error, SimpleMigration, Migration, Manager};
 use kvdb::Database;

util/src/misc.rs

@@ -60,9 +60,9 @@ pub fn version() -> String {
 pub fn version_data() -> Bytes {
 	let mut s = RlpStream::new_list(4);
 	let v =
-		(u32::from_str(env!("CARGO_PKG_VERSION_MAJOR")).expect("Environment variables are known to be valid; qed") << 16) +
+		(env!("CARGO_PKG_VERSION_MAJOR").parse::<u32>().expect("Environment variables are known to be valid; qed") << 16) +
-		(u32::from_str(env!("CARGO_PKG_VERSION_MINOR")).expect("Environment variables are known to be valid; qed") << 8) +
+		(env!("CARGO_PKG_VERSION_MINOR").parse::<u32>().expect("Environment variables are known to be valid; qed") << 8) +
-		u32::from_str(env!("CARGO_PKG_VERSION_PATCH")).expect("Environment variables are known to be valid; qed");
+		env!("CARGO_PKG_VERSION_PATCH").parse::<u32>().expect("Environment variables are known to be valid; qed");
 	s.append(&v);
 	s.append(&"Parity");
 	s.append(&rustc_version());

util/src/nibblevec.rs

@@ -17,7 +17,7 @@
 
 //! An owning, nibble-oriented byte vector.
 
-use ::NibbleSlice;
+use nibbleslice::NibbleSlice;
 use elastic_array::ElasticArray36;
 
 /// Owning, nibble-oriented byte vector. Counterpart to `NibbleSlice`.

util/src/standard.rs

@@ -16,28 +16,10 @@
 
 //! Std lib global reexports.
 
-pub use std::io;
-pub use std::fs;
-pub use std::str;
-pub use std::fmt;
-pub use std::cmp;
-pub use std::ptr;
-pub use std::mem;
-pub use std::ops;
-pub use std::slice;
-pub use std::result;
-pub use std::option;
-
 pub use std::path::Path;
-pub use std::str::{FromStr};
-pub use std::io::{Read,Write};
 pub use std::hash::{Hash, Hasher};
-pub use std::error::Error as StdError;
 
-pub use std::ops::*;
-pub use std::cmp::*;
 pub use std::sync::Arc;
-pub use std::collections::*;
 
 pub use heapsize::HeapSizeOf;
 pub use itertools::Itertools;

util/src/trie/triedb.rs

@@ -14,6 +14,7 @@
 // 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::fmt;
 use common::*;
 use hashdb::*;
 use nibbleslice::*;