Merge pull request #1827 from ethcore/move_hash

moved hash.rs to bigint library

ethcore/src/blockchain/best_block.rs

@@ -14,8 +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 util::bytes::Bytes;
-use util::numbers::{U256,H256};
+use util::{Bytes, U256, H256};
 use header::BlockNumber;
 
 /// Best block info.

ethcore/src/blockchain/block_info.rs

@@ -14,7 +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 util::numbers::{U256,H256};
+use util::{U256,H256};
 use header::BlockNumber;
 
 /// Brief info about inserted block.

ethcore/src/blockchain/generator/generator.rs

@@ -14,9 +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 util::hash::H2048;
-use util::numbers::U256;
-use util::bytes::Bytes;
+use util::{U256, H2048, Bytes};
 use header::BlockNumber;
 use super::fork::Fork;
 use super::bloom::Bloom;

ethcore/src/blockchain/import_route.rs

@@ -16,7 +16,7 @@
 
 //! Import route.
 
-use util::hash::H256;
+use util::H256;
 use blockchain::block_info::{BlockInfo, BlockLocation};
 
 /// Import route for newly inserted block.
@@ -67,8 +67,7 @@ impl From<BlockInfo> for ImportRoute {
 
 #[cfg(test)]
 mod tests {
-	use util::hash::H256;
-	use util::numbers::U256;
+	use util::{U256, H256};
 	use blockchain::block_info::{BlockInfo, BlockLocation, BranchBecomingCanonChainData};
 	use blockchain::ImportRoute;
 

ethcore/src/blockchain/update.rs

@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use util::numbers::H256;
+use util::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use blooms::BloomGroup;

ethcore/src/builtin.rs

@@ -102,7 +102,7 @@ pub fn new_builtin_exec(name: &str) -> Box<Fn(&[u8], &mut [u8])> {
 			let mut it: InType = InType { hash: H256::new(), v: H256::new(), r: H256::new(), s: H256::new() };
 			it.copy_raw(input);
 			if it.v == H256::from(&U256::from(27)) || it.v == H256::from(&U256::from(28)) {
-				let s = Signature::from_rsv(&it.r, &it.s, it.v[31] - 27);
+				let s = signature_from_rsv(&it.r, &it.s, it.v[31] - 27);
 				if ec::is_valid(&s) {
 					if let Ok(p) = ec::recover(&s, &it.hash) {
 						let r = p.as_slice().sha3();

ethcore/src/client/chain_notify.rs

@@ -14,10 +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/>.
 
-use util::numbers::*;
-use ipc::{IpcConfig, BinaryConvertError};
 use std::collections::VecDeque;
 use std::mem;
+use ipc::{IpcConfig, BinaryConvertError};
+use util::H256;
 
 /// Represents what has to be handled by actor listening to chain events
 #[derive(Ipc)]

ethcore/src/client/client.rs

@@ -25,7 +25,7 @@ use time::precise_time_ns;
 use util::{journaldb, rlp, Bytes, View, PerfTimer, Itertools, Mutex, RwLock};
 use util::journaldb::JournalDB;
 use util::rlp::{UntrustedRlp};
-use util::numbers::*;
+use util::{U256, H256, Address, H2048, Uint};
 use util::sha3::*;
 use util::kvdb::*;
 
@@ -255,7 +255,7 @@ impl Client {
 			}
 		}
 		let mut last_hashes = LastHashes::new();
-		last_hashes.resize(256, H256::new());
+		last_hashes.resize(256, H256::default());
 		last_hashes[0] = parent_hash;
 		for i in 0..255 {
 			match self.chain.block_details(&last_hashes[i]) {
@@ -727,7 +727,7 @@ impl BlockChainClient for Client {
 			timestamp: view.timestamp(),
 			difficulty: view.difficulty(),
 			last_hashes: last_hashes,
-			gas_used: U256::zero(),
+			gas_used: U256::default(),
 			gas_limit: view.gas_limit(),
 		};
 		for t in txs.iter().take(address.index) {
@@ -953,7 +953,7 @@ impl BlockChainClient for Client {
 								entry: log,
 								block_hash: hash.clone(),
 								block_number: number,
-								transaction_hash: hashes.get(index).cloned().unwrap_or_else(H256::new),
+								transaction_hash: hashes.get(index).cloned().unwrap_or_else(H256::default),
 								transaction_index: index,
 								log_index: log_index + i
 							})

ethcore/src/client/traits.rs

@@ -14,10 +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 util::bytes::Bytes;
-use util::hash::{Address, H256, H2048};
-use util::numbers::U256;
-use util::Itertools;
+use util::{U256, Address, H256, H2048, Bytes, Itertools};
 use blockchain::TreeRoute;
 use block_queue::BlockQueueInfo;
 use block::{OpenBlock, SealedBlock};

ethcore/src/env_info.rs

@@ -14,7 +14,9 @@
 // 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::*;
+use std::cmp;
+use std::sync::Arc;
+use util::{U256, Address, H256, Hashable};
 use header::BlockNumber;
 use ethjson;
 
@@ -45,7 +47,7 @@ impl Default for EnvInfo {
 	fn default() -> Self {
 		EnvInfo {
 			number: 0,
-			author: Address::new(),
+			author: Address::default(),
 			timestamp: 0,
 			difficulty: 0.into(),
 			gas_limit: 0.into(),
@@ -65,7 +67,7 @@ impl From<ethjson::vm::Env> for EnvInfo {
 			gas_limit: e.gas_limit.into(),
 			timestamp: e.timestamp.into(),
 			last_hashes: Arc::new((1..cmp::min(number + 1, 257)).map(|i| format!("{}", number - i).as_bytes().sha3()).collect()),
-			gas_used: U256::zero(),
+			gas_used: U256::default(),
 		}
 	}
 }
@@ -74,10 +76,9 @@ impl From<ethjson::vm::Env> for EnvInfo {
 mod tests {
 	extern crate rustc_serialize;
 
-	use super::*;
-	use util::hash::*;
-	use util::numbers::U256;
 	use std::str::FromStr;
+	use super::*;
+	use util::{U256, Address};
 	use ethjson;
 
 	#[test]

ethcore/src/ethereum/ethash.rs

@@ -374,13 +374,13 @@ mod tests {
 		let vm_factory = Default::default();
 		let mut b = OpenBlock::new(engine.deref(), &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let mut uncle = Header::new();
-		let uncle_author = address_from_hex("ef2d6d194084c2de36e0dabfce45d046b37d1106");
+		let uncle_author: Address = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
 		uncle.author = uncle_author.clone();
 		b.push_uncle(uncle).unwrap();
 
 		let b = b.close();
-		assert_eq!(b.state().balance(&Address::zero()), U256::from_str("478eae0e571ba000").unwrap());
-		assert_eq!(b.state().balance(&uncle_author), U256::from_str("3cb71f51fc558000").unwrap());
+		assert_eq!(b.state().balance(&Address::zero()), "478eae0e571ba000".into());
+		assert_eq!(b.state().balance(&uncle_author), "3cb71f51fc558000".into());
 	}
 
 	#[test]

ethcore/src/ethereum/mod.rs

@@ -69,21 +69,21 @@ mod tests {
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
 		let s = State::from_existing(db, genesis_header.state_root.clone(), engine.account_start_nonce(), Default::default()).unwrap();
-		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000001")), U256::from(1u64));
-		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000002")), U256::from(1u64));
-		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000003")), U256::from(1u64));
-		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000004")), U256::from(1u64));
-		assert_eq!(s.balance(&address_from_hex("102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c")), U256::from(1u64) << 200);
-		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000000")), U256::from(0u64));
+		assert_eq!(s.balance(&"0000000000000000000000000000000000000001".into()), 1u64.into());
+		assert_eq!(s.balance(&"0000000000000000000000000000000000000002".into()), 1u64.into());
+		assert_eq!(s.balance(&"0000000000000000000000000000000000000003".into()), 1u64.into());
+		assert_eq!(s.balance(&"0000000000000000000000000000000000000004".into()), 1u64.into());
+		assert_eq!(s.balance(&"102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c".into()), U256::from(1u64) << 200);
+		assert_eq!(s.balance(&"0000000000000000000000000000000000000000".into()), 0u64.into());
 	}
 
 	#[test]
 	fn morden() {
 		let morden = new_morden();
 
-		assert_eq!(morden.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap());
+		assert_eq!(morden.state_root(), "f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9".into());
 		let genesis = morden.genesis_block();
-		assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap());
+		assert_eq!(BlockView::new(&genesis).header_view().sha3(), "0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303".into());
 
 		let _ = morden.engine;
 	}
@@ -92,9 +92,9 @@ mod tests {
 	fn frontier() {
 		let frontier = new_frontier();
 
-		assert_eq!(frontier.state_root(), H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap());
+		assert_eq!(frontier.state_root(), "d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544".into());
 		let genesis = frontier.genesis_block();
-		assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3").unwrap());
+		assert_eq!(BlockView::new(&genesis).header_view().sha3(), "d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3".into());
 
 		let _ = frontier.engine;
 	}

ethcore/src/miner/transaction_queue.rs

@@ -29,8 +29,7 @@
 //! extern crate rustc_serialize;
 //!
 //!	use util::crypto::KeyPair;
-//! use util::hash::Address;
-//! use util::numbers::{Uint, U256};
+//! use util::{Uint, U256, Address};
 //!	use ethcore::miner::{TransactionQueue, AccountDetails, TransactionOrigin};
 //!	use ethcore::transaction::*;
 //!	use rustc_serialize::hex::FromHex;
@@ -81,12 +80,10 @@
 //!      - It removes all transactions (either from `current` or `future`) with nonce < client nonce
 //!      - It moves matching `future` transactions to `current`
 
-use std::default::Default;
-use std::cmp::{Ordering};
+use std::cmp::Ordering;
 use std::cmp;
 use std::collections::{HashMap, BTreeSet};
-use util::numbers::{Uint, U256};
-use util::hash::{Address, H256};
+use util::{Address, H256, Uint, U256};
 use util::table::Table;
 use transaction::*;
 use error::{Error, TransactionError};

ethcore/src/snapshot/account.rs

@@ -17,12 +17,9 @@
 //! Account state encoding and decoding
 
 use account_db::{AccountDB, AccountDBMut};
-use snapshot::Error;
-
-use util::{Bytes, HashDB, SHA3_EMPTY, TrieDB};
-use util::hash::{FixedHash, H256};
-use util::numbers::U256;
+use util::{U256, FixedHash, H256, Bytes, HashDB, SHA3_EMPTY, TrieDB};
 use util::rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View};
+use snapshot::Error;
 
 // An alternate account structure from ::account::Account.
 #[derive(PartialEq, Clone, Debug)]
@@ -198,4 +195,4 @@ mod tests {
 		let fat_rlp = UntrustedRlp::new(&fat_rlp);
 		assert_eq!(Account::from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp).unwrap(), account);
 	}
-}
+}

ethcore/src/snapshot/block.rs

@@ -133,9 +133,7 @@ mod tests {
 	use super::AbridgedBlock;
 	use types::transaction::{Action, Transaction};
 
-	use util::numbers::U256;
-	use util::hash::{Address, H256, FixedHash};
-	use util::Bytes;
+	use util::{Address, H256, FixedHash, U256, Bytes};
 
 	fn encode_block(b: &Block) -> Bytes {
 		b.rlp_bytes(::basic_types::Seal::With)
@@ -190,4 +188,4 @@ mod tests {
 		let abridged = AbridgedBlock::from_block_view(&BlockView::new(&encoded[..]));
 		assert_eq!(abridged.to_block(H256::new(), 0).unwrap(), b);
 	}
-}
+}

ethcore/src/spec/genesis.rs

@@ -15,8 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::rlp::*;
-use util::numbers::{Uint, U256};
-use util::hash::{Address, H256};
+use util::{Address, H256, Uint, U256};
 use ethjson;
 use super::seal::Seal;
 

ethcore/src/state.rs

@@ -1393,7 +1393,7 @@ fn alter_balance() {
 	let mut state_result = get_temp_state();
 	let mut state = state_result.reference_mut();
 	let a = Address::zero();
-	let b = address_from_u64(1u64);
+	let b = 1u64.into();
 	state.add_balance(&a, &U256::from(69u64));
 	assert_eq!(state.balance(&a), U256::from(69u64));
 	state.commit().unwrap();

ethcore/src/types/account_diff.rs

@@ -16,13 +16,11 @@
 
 //! Diff between two accounts.
 
-use util::numbers::*;
 use std::cmp::*;
-use std::fmt;
-use ipc::binary::{BinaryConvertError, BinaryConvertable};
-use util::Bytes;
+use std::{fmt, mem};
 use std::collections::{VecDeque, BTreeMap};
-use std::mem;
+use util::{U256, H256, Uint, Bytes};
+use ipc::binary::{BinaryConvertError, BinaryConvertable};
 
 #[derive(Debug, PartialEq, Eq, Clone, Binary)]
 /// Diff type for specifying a change (or not).

ethcore/src/types/blockchain_info.rs

@@ -16,11 +16,11 @@
 
 //! Blockhain info type definition
 
-use util::numbers::*;
-use header::BlockNumber;
-use ipc::binary::BinaryConvertError;
 use std::mem;
 use std::collections::VecDeque;
+use util::{U256, H256};
+use ipc::binary::BinaryConvertError;
+use header::BlockNumber;
 
 /// Information about the blockchain gathered together.
 #[derive(Clone, Debug, Binary)]

ethcore/src/types/executed.rs

@@ -16,8 +16,7 @@
 
 //! Transaction execution format module.
 
-use util::numbers::*;
-use util::Bytes;
+use util::{Bytes, U256, Address, U512};
 use util::rlp::*;
 use trace::{VMTrace, FlatTrace};
 use types::log_entry::LogEntry;

ethcore/src/types/filter.rs

@@ -18,6 +18,7 @@
 
 use util::hash::*;
 use util::sha3::*;
+use util::bloom::Bloomable;
 use client::BlockID;
 use log_entry::LogEntry;
 use ipc::binary::BinaryConvertError;

ethcore/src/types/log_entry.rs

@@ -16,18 +16,16 @@
 
 //! Log entry type definition.
 
-use util::numbers::*;
+use std::mem;
 use std::ops::Deref;
+use std::collections::VecDeque;
+use util::{H256, Address, Bytes, HeapSizeOf, Hashable};
 use util::rlp::*;
-use util::Bytes;
-use util::HeapSizeOf;
-use util::sha3::*;
+use util::bloom::Bloomable;
+use ipc::binary::BinaryConvertError;
 use basic_types::LogBloom;
 use header::BlockNumber;
 use ethjson;
-use ipc::binary::BinaryConvertError;
-use std::mem;
-use std::collections::VecDeque;
 
 /// A record of execution for a `LOG` operation.
 #[derive(Default, Debug, Clone, PartialEq, Eq, Binary)]

ethcore/src/types/receipt.rs

@@ -16,15 +16,15 @@
 
 //! Receipt
 
-use util::numbers::*;
+use std::mem;
+use std::collections::VecDeque;
+use util::{H256, U256, Address};
 use util::rlp::*;
 use util::HeapSizeOf;
 use basic_types::LogBloom;
 use header::BlockNumber;
 use log_entry::{LogEntry, LocalizedLogEntry};
 use ipc::binary::BinaryConvertError;
-use std::mem;
-use std::collections::VecDeque;
 
 /// Information describing execution of a transaction.
 #[derive(Default, Debug, Clone, Binary)]
@@ -45,7 +45,7 @@ impl Receipt {
 		Receipt {
 			state_root: state_root,
 			gas_used: gas_used,
-			log_bloom: logs.iter().fold(LogBloom::new(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator
+			log_bloom: logs.iter().fold(LogBloom::default(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator
 			logs: logs,
 		}
 	}

ethcore/src/types/state_diff.rs

@@ -16,13 +16,12 @@
 
 //! State diff module.
 
-use util::numbers::*;
-use account_diff::*;
-use ipc::binary::BinaryConvertError;
-use std::mem;
-use std::fmt;
+use std::{mem, fmt};
 use std::ops::*;
 use std::collections::{VecDeque, BTreeMap};
+use util::Address;
+use account_diff::*;
+use ipc::binary::BinaryConvertError;
 
 #[derive(Debug, PartialEq, Eq, Clone, Binary)]
 /// Expression for the delta between two system states. Encoded the

ethcore/src/types/trace_types/filter.rs

@@ -17,15 +17,16 @@
 //! Trace filters type definitions
 
 use std::ops::Range;
+use std::mem;
+use std::collections::VecDeque;
 use bloomchain::{Filter as BloomFilter, Bloom, Number};
-use util::{Address, FixedHash};
+use util::Address;
 use util::sha3::Hashable;
+use util::bloom::Bloomable;
 use basic_types::LogBloom;
 use trace::flat::FlatTrace;
 use types::trace_types::trace::{Action, Res};
 use ipc::binary::BinaryConvertError;
-use std::mem;
-use std::collections::VecDeque;
 
 /// Addresses filter.
 ///
@@ -55,7 +56,7 @@ impl AddressesFilter {
 	/// Returns blooms of this addresses filter.
 	pub fn blooms(&self) -> Vec<LogBloom> {
 		match self.list.is_empty() {
-			true => vec![LogBloom::new()],
+			true => vec![LogBloom::default()],
 			false => self.list.iter()
 				.map(|address| LogBloom::from_bloomed(&address.sha3()))
 				.collect(),
@@ -137,12 +138,12 @@ impl Filter {
 
 #[cfg(test)]
 mod tests {
-	use util::{FixedHash, Address};
+	use util::Address;
 	use util::sha3::Hashable;
+	use util::bloom::Bloomable;
 	use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide};
 	use trace::flat::FlatTrace;
 	use trace::{Filter, AddressesFilter};
-	use basic_types::LogBloom;
 	use types::executed::CallType;
 
 	#[test]
@@ -154,7 +155,7 @@ mod tests {
 		};
 
 		let blooms = filter.bloom_possibilities();
-		assert_eq!(blooms, vec![LogBloom::new()]);
+		assert_eq!(blooms, vec![Default::default()]);
 	}
 
 	#[test]

ethcore/src/types/trace_types/trace.rs

@@ -16,9 +16,10 @@
 
 //! Tracing datatypes.
 
-use util::{U256, Bytes, Address, FixedHash};
+use util::{U256, Bytes, Address};
 use util::rlp::*;
 use util::sha3::Hashable;
+use util::bloom::Bloomable;
 use action_params::ActionParams;
 use basic_types::LogBloom;
 use types::executed::CallType;

ethcore/src/types/transaction.rs

@@ -16,19 +16,20 @@
 
 //! Transaction data structure.
 
-use util::numbers::*;
+use std::mem;
+use std::collections::VecDeque;
+use util::{H256, Address, U256, H520};
 use std::ops::Deref;
 use util::rlp::*;
 use util::sha3::*;
 use util::{UtilError, CryptoError, Bytes, Signature, Secret, ec};
+use util::crypto::{signature_from_rsv, signature_to_rsv};
 use std::cell::*;
 use error::*;
 use evm::Schedule;
 use header::BlockNumber;
 use ethjson;
 use ipc::binary::BinaryConvertError;
-use std::mem;
-use std::collections::VecDeque;
 
 #[derive(Debug, Clone, PartialEq, Eq, Binary)]
 /// Transaction action type.
@@ -146,7 +147,7 @@ impl Transaction {
 
 	/// Signs the transaction with signature.
 	pub fn with_signature(self, sig: H520) -> SignedTransaction {
-		let (r, s, v) = sig.to_rsv();
+		let (r, s, v) = signature_to_rsv(&sig);
 		SignedTransaction {
 			unsigned: self,
 			r: r,
@@ -162,8 +163,8 @@ impl Transaction {
 	pub fn invalid_sign(self) -> SignedTransaction {
 		SignedTransaction {
 			unsigned: self,
-			r: U256::zero(),
-			s: U256::zero(),
+			r: U256::default(),
+			s: U256::default(),
 			v: 0,
 			hash: Cell::new(None),
 			sender: Cell::new(None),
@@ -174,8 +175,8 @@ impl Transaction {
 	pub fn fake_sign(self, from: Address) -> SignedTransaction {
 		SignedTransaction {
 			unsigned: self,
-			r: U256::zero(),
-			s: U256::zero(),
+			r: U256::default(),
+			s: U256::default(),
 			v: 0,
 			hash: Cell::new(None),
 			sender: Cell::new(Some(from)),
@@ -290,7 +291,7 @@ impl SignedTransaction {
 	pub fn standard_v(&self) -> u8 { match self.v { 27 => 0, 28 => 1, _ => 4 } }
 
 	/// Construct a signature object from the sig.
-	pub fn signature(&self) -> Signature { Signature::from_rsv(&From::from(&self.r), &From::from(&self.s), self.standard_v()) }
+	pub fn signature(&self) -> Signature { signature_from_rsv(&From::from(&self.r), &From::from(&self.s), self.standard_v()) }
 
 	/// Checks whether the signature has a low 's' value.
 	pub fn check_low_s(&self) -> Result<(), Error> {
@@ -360,10 +361,10 @@ fn sender_test() {
 	assert_eq!(t.gas_price, U256::from(0x01u64));
 	assert_eq!(t.nonce, U256::from(0x00u64));
 	if let Action::Call(ref to) = t.action {
-		assert_eq!(*to, address_from_hex("095e7baea6a6c7c4c2dfeb977efac326af552d87"));
+		assert_eq!(*to, "095e7baea6a6c7c4c2dfeb977efac326af552d87".into());
 	} else { panic!(); }
 	assert_eq!(t.value, U256::from(0x0au64));
-	assert_eq!(t.sender().unwrap(), address_from_hex("0f65fe9276bc9a24ae7083ae28e2660ef72df99e"));
+	assert_eq!(t.sender().unwrap(), "0f65fe9276bc9a24ae7083ae28e2660ef72df99e".into());
 }
 
 #[test]

ethcore/src/types/tree_route.rs

@@ -16,10 +16,10 @@
 
 //! Tree route info type definition
 
-use util::numbers::H256;
-use ipc::BinaryConvertError;
 use std::collections::VecDeque;
 use std::mem;
+use ipc::BinaryConvertError;
+use util::H256;
 
 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug, Binary)]