Merge branch 'master' of github.com:ethcore/parity into thread

2016-03-02 01:20:41 +01:00 · 2016-03-02 01:20:41 +01:00 · 15ecba57ec
commit 15ecba57ec
parent d0129ff67b 0082d12ea9
45 changed files with 1045 additions and 187 deletions
--- a/.gitignore
+++ b/.gitignore
@ -27,3 +27,6 @@
 # jetbrains ide stuff
 .idea
 *.iml
+
+# Build artifacts
+out/
--- a/Cargo.lock
+++ b/Cargo.lock
@ -44,6 +44,18 @@ dependencies = [
 "syntex_syntax 0.29.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "bigint"
+version = "0.1.0"
+dependencies = [
+ "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "heapsize 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.14 (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)",
+]
+
 [[package]]
 name = "bitflags"
 version = "0.3.3"
@ -220,6 +232,7 @@ name = "ethcore-util"
 version = "0.9.99"
 dependencies = [
 "arrayvec 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bigint 0.1.0",
 "clippy 0.0.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "elastic-array 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
--- a/README.md
+++ b/README.md
@ -19,7 +19,7 @@ First (if you don't already have it) get multirust:

 - Linux:
 ```bash
-curl -sf https://raw.githubusercontent.com/brson/multirust/master/blastoff.sh | sudo sh -s -- --yes
+curl -sf https://raw.githubusercontent.com/brson/multirust/master/quick-install.sh | sudo sh -s -- --yes
 ```

 - OSX with Homebrew:
--- a/ethcore/src/account.rs
+++ b/ethcore/src/account.rs
@ -92,10 +92,10 @@ impl Account {

 	/// Create a new contract account.
 	/// NOTE: make sure you use `init_code` on this before `commit`ing.
-	pub fn new_contract(balance: U256) -> Account {
+	pub fn new_contract(balance: U256, nonce: U256) -> Account {
 		Account {
 			balance: balance,
-			nonce: U256::from(0u8),
+			nonce: nonce,
 			storage_root: SHA3_NULL_RLP,
 			storage_overlay: RefCell::new(HashMap::new()),
 			code_hash: None,
@ -261,7 +261,7 @@ mod tests {
 		let mut db = MemoryDB::new();
 		let mut db = AccountDBMut::new(&mut db, &Address::new());
 		let rlp = {
-			let mut a = Account::new_contract(U256::from(69u8));
+			let mut a = Account::new_contract(x!(69), x!(0));
 			a.set_storage(H256::from(&U256::from(0x00u64)), H256::from(&U256::from(0x1234u64)));
 			a.commit_storage(&mut db);
 			a.init_code(vec![]);
@ -281,7 +281,7 @@ mod tests {
 		let mut db = AccountDBMut::new(&mut db, &Address::new());

 		let rlp = {
-			let mut a = Account::new_contract(U256::from(69u8));
+			let mut a = Account::new_contract(x!(69), x!(0));
 			a.init_code(vec![0x55, 0x44, 0xffu8]);
 			a.commit_code(&mut db);
 			a.rlp()
@ -296,7 +296,7 @@ mod tests {

 	#[test]
 	fn commit_storage() {
-		let mut a = Account::new_contract(U256::from(69u8));
+		let mut a = Account::new_contract(x!(69), x!(0));
 		let mut db = MemoryDB::new();
 		let mut db = AccountDBMut::new(&mut db, &Address::new());
 		a.set_storage(x!(0), x!(0x1234));
@ -307,7 +307,7 @@ mod tests {

 	#[test]
 	fn commit_remove_commit_storage() {
-		let mut a = Account::new_contract(U256::from(69u8));
+		let mut a = Account::new_contract(x!(69), x!(0));
 		let mut db = MemoryDB::new();
 		let mut db = AccountDBMut::new(&mut db, &Address::new());
 		a.set_storage(x!(0), x!(0x1234));
@ -321,7 +321,7 @@ mod tests {

 	#[test]
 	fn commit_code() {
-		let mut a = Account::new_contract(U256::from(69u8));
+		let mut a = Account::new_contract(x!(69), x!(0));
 		let mut db = MemoryDB::new();
 		let mut db = AccountDBMut::new(&mut db, &Address::new());
 		a.init_code(vec![0x55, 0x44, 0xffu8]);
--- a/ethcore/src/action_params.rs
+++ b/ethcore/src/action_params.rs
@ -15,9 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 //! Evm input params.
-use util::hash::*;
-use util::uint::*;
-use util::bytes::*;
+use common::*;

 /// Transaction value
 #[derive(Clone, Debug)]
--- a/ethcore/src/blockchain/best_block.rs
+++ b/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::hash::H256;
-use util::uint::U256;
+use util::numbers::{U256,H256};
 use header::BlockNumber;

 /// Best block info.
--- a/ethcore/src/blockchain/block_info.rs
+++ b/ethcore/src/blockchain/block_info.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::hash::H256;
-use util::uint::U256;
+use util::numbers::{U256,H256};
 use header::BlockNumber;

 /// Brief info about inserted block.
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@ -791,19 +791,24 @@ mod tests {
 	use std::str::FromStr;
 	use rustc_serialize::hex::FromHex;
 	use util::hash::*;
+	use util::sha3::Hashable;
 	use blockchain::{BlockProvider, BlockChain, BlockChainConfig};
 	use tests::helpers::*;
 	use devtools::*;
+	use blockchain::helpers::generators::{ChainGenerator, ChainIterator};
+	use views::BlockView;

 	#[test]
-	fn valid_tests_extra32() {
-		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0925002c3260b44e44c3edebad1cc442142b03020209df1ab8bb86752edbd2cd7a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808454c98c8142a0363659b251bf8b819179874c8cce7b9b983d7f3704cbb58a3b334431f7032871889032d09c281e1236c0c0".from_hex().unwrap();
+	fn basic_blockchain_insert() {
+		let mut canon_chain = ChainGenerator::default();
+		let genesis = canon_chain.next().unwrap().rlp();
+		let first = canon_chain.next().unwrap().rlp();
+		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
+		let first_hash = BlockView::new(&first).header_view().sha3();

 		let temp = RandomTempPath::new();
 		let bc = BlockChain::new(BlockChainConfig::default(), &genesis, temp.as_path());

-		let genesis_hash = H256::from_str("3caa2203f3d7c136c0295ed128a7d31cea520b1ca5e27afe17d0853331798942").unwrap();
-
 		assert_eq!(bc.genesis_hash(), genesis_hash.clone());
 		assert_eq!(bc.best_block_number(), 0);
 		assert_eq!(bc.best_block_hash(), genesis_hash.clone());
@ -811,12 +816,8 @@ mod tests {
 		assert_eq!(bc.block_hash(1), None);
 		assert_eq!(bc.block_details(&genesis_hash).unwrap().children, vec![]);

-		let first = "f90285f90219a03caa2203f3d7c136c0295ed128a7d31cea520b1ca5e27afe17d0853331798942a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0bac6177a79e910c98d86ec31a09ae37ac2de15b754fd7bed1ba52362c49416bfa0d45893a296c1490a978e0bd321b5f2635d8280365c1fe9f693d65f233e791344a0c7778a7376099ee2e5c455791c1885b5c361b95713fddcbe32d97fd01334d296b90100000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000400000000000000000000000000000000000000000000000000000008302000001832fefd882560b845627cb99a00102030405060708091011121314151617181920212223242526272829303132a08ccb2837fb2923bd97e8f2d08ea32012d6e34be018c73e49a0f98843e8f47d5d88e53be49fec01012ef866f864800a82c35094095e7baea6a6c7c4c2dfeb977efac326af552d8785012a05f200801ba0cb088b8d2ff76a7b2c6616c9d02fb6b7a501afbf8b69d7180b09928a1b80b5e4a06448fe7476c606582039bb72a9f6f4b4fad18507b8dfbd00eebbe151cc573cd2c0".from_hex().unwrap();
-
 		bc.insert_block(&first, vec![]);

-		let first_hash = H256::from_str("a940e5af7d146b3b917c953a82e1966b906dace3a4e355b5b0a4560190357ea1").unwrap();
-
 		assert_eq!(bc.block_hash(0), Some(genesis_hash.clone()));
 		assert_eq!(bc.best_block_number(), 1);
 		assert_eq!(bc.best_block_hash(), first_hash.clone());
@ -829,20 +830,24 @@ mod tests {
 	#[test]
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn test_small_fork() {
-		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a07dba07d6b448a186e9612e5f737d1c909dce473e53199901a302c00646d523c1a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808454c98c8142a059262c330941f3fe2a34d16d6e3c7b30d2ceb37c6a0e9a994c494ee1a61d2410885aa4c8bf8e56e264c0c0".from_hex().unwrap();
-		let b1 = "f90261f901f9a05716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0cb52de543653d86ccd13ba3ddf8b052525b04231c6884a4db3188a184681d878a0e78628dd45a1f8dc495594d83b76c588a3ee67463260f8b7d4a42f574aeab29aa0e9244cf7503b79c03d3a099e07a80d2dbc77bb0b502d8a89d51ac0d68dd31313b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001832fefd882520884562791e580a051b3ecba4e3f2b49c11d42dd0851ec514b1be3138080f72a2b6e83868275d98f8877671f479c414b47f862f86080018304cb2f94095e7baea6a6c7c4c2dfeb977efac326af552d870a801ca09e2709d7ec9bbe6b1bbbf0b2088828d14cd5e8642a1fee22dc74bfa89761a7f9a04bd8813dee4be989accdb708b1c2e325a7e9c695a8024e30e89d6c644e424747c0".from_hex().unwrap();
-		let b2 = "f902ccf901f9a0437e51676ff10756fcfee5edd9159fa41dbcb1b2c592850450371cbecd54ee4fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0c70a5dc56146e5ef025e4e5726a6373c6f12fd2f6784093a19ead0a7d17fb292a040645cbce4fd399e7bb9160b4c30c40d7ee616a030d4e18ef0ed3b02bdb65911a086e608555f63628417032a011d107b36427af37d153f0da02ce3f90fdd5e8c08b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004002832fefd882c0e384562791e880a0e3cc39ff775cc0a32f175995b92e84b729e5c9a3563ff899e3555b908bc21d75887c3cde283f4846a6f8cdf8cb01018304cb2f8080b87e6060604052606e8060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c0406226146037576035565b005b60406004506056565b6040518082815260200191505060405180910390f35b6000600560006000508190555060059050606b565b90561ba05258615c63503c0a600d6994b12ea5750d45b3c69668e2a371b4fbfb9eeff6b8a0a11be762bc90491231274a2945be35a43f23c27775b1ff24dd521702fe15f73ec0".from_hex().unwrap();
-		let b3a = "f90261f901f9a036fde1253128666fcb95a5956da14a73489e988bb72738717ec1d31e1cee781aa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a09dc4b1357c0b7b8108f8a098f4f9a1a274957bc9ebc22a9ae67ae81739e5b19ca007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefd882524d84562791eb80a074861666bd346c025889745c793b91ab9cd1e2ca19b5cf3c50d04d135b0a4d2b8809fe9587ea4cdc04f862f86002018304cb2f94ec0e71ad0a90ffe1909d27dac207f7680abba42d01801ba06fd84874d36d5de9e8e48978c03619b53a96b7ae0a4cd1ac118f103098b44801a00572596974dd7df4f9f69bd7456585618c568d8434ef6453391b89281ce12ae1c0".from_hex().unwrap();
-		let b3b = "f90265f901f9a036fde1253128666fcb95a5956da14a73489e988bb72738717ec1d31e1cee781aa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ab87dc338bfd6f662b1cd90bc0c9e40a1b2146a095312393c9e13ce3a5008b09a0e609b7a7d4b8a2403ec1268627ecd98783627246e8f1b26addb3ff504f76a054a0592fabf92476512952db3a69a2481a42912e668a1ee28c4c322e703bb665f8beb90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefd882a1f084562791ee80a0fe7098fa7e4ac5d637eea81fb23f8f78346826dbab430068dd9a249d0afa99818853e1a6b201ae3545f866f86402018304cb2f94ec0e71ad0a90ffe1909d27dac207f7680abba42d0284c04062261ca06edc9ce8e7da4cc34067beb325dcad59e5655a164a5100a50bc3eb681b12c716a0abf9053d5de65b1be81fe50d327b84de685efbeecea34e7b747180a6c6023e44c0".from_hex().unwrap();
+		let mut canon_chain = ChainGenerator::default();
+		let genesis = canon_chain.next().unwrap().rlp();
+		let blocks = canon_chain.clone().take(3).map(|block| block.rlp()).collect::<Vec<_>>();
+		let fork = canon_chain.skip(2).fork(1).take(1).next().unwrap().rlp();

-		let genesis_hash = H256::from_str("5716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2").unwrap();
-		let b1_hash = H256::from_str("437e51676ff10756fcfee5edd9159fa41dbcb1b2c592850450371cbecd54ee4f").unwrap();
-		let b2_hash = H256::from_str("36fde1253128666fcb95a5956da14a73489e988bb72738717ec1d31e1cee781a").unwrap();
-		let b3a_hash = H256::from_str("c208f88c9f5bf7e00840439742c12e5226d9752981f3ec0521bdcb6dd08af277").unwrap();
-		let b3b_hash = H256::from_str("bf72270ae0d95c9ea39a6adab994793fddb8c10fba7391e26279474124605d54").unwrap();
+		let b1 = blocks[0].clone();
+		let b2 = blocks[1].clone();
+		let b3a = blocks[2].clone();
+		let b3b = fork;
+
+		let genesis_hash = BlockView::new(&genesis).header_view().sha3();
+		let b1_hash= BlockView::new(&b1).header_view().sha3();
+		let b2_hash= BlockView::new(&b2).header_view().sha3();
+		let b3a_hash= BlockView::new(&b3a).header_view().sha3();
+		let b3b_hash= BlockView::new(&b3b).header_view().sha3();

 		// b3a is a part of canon chain, whereas b3b is part of sidechain
-		let best_block_hash = H256::from_str("c208f88c9f5bf7e00840439742c12e5226d9752981f3ec0521bdcb6dd08af277").unwrap();
+		let best_block_hash = b3a_hash.clone();

 		let temp = RandomTempPath::new();
 		let bc = BlockChain::new(BlockChainConfig::default(), &genesis, temp.as_path());
@ -1066,6 +1071,4 @@ mod tests {
 		assert_eq!(blocks_b2, vec![2]);
 		assert_eq!(blocks_ba, vec![3]);
 	}
-
-
 }
--- a/ethcore/src/blockchain/bloom_indexer.rs
+++ b/ethcore/src/blockchain/bloom_indexer.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::hash::H256;
+use util::numbers::H256;
 use chainfilter::BloomIndex;

 /// Represents location of block bloom in extras database.
--- a/ethcore/src/blockchain/helpers/generators.rs
+++ b/ethcore/src/blockchain/helpers/generators.rs
@ -0,0 +1,203 @@
+// 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::rlp::*;
+use util::hash::{H256, H2048};
+use util::uint::{U256};
+use util::bytes::Bytes;
+use header::{BlockNumber, Header};
+use transaction::SignedTransaction;
+
+pub trait Forkable {
+	fn fork(self, fork_number: usize) -> Self where Self: Sized;
+}
+
+pub struct Fork<I> {
+	iter: I,
+	fork_number: usize,
+}
+
+impl<I> Iterator for Fork<I> where I: Iterator, <I as Iterator>::Item: Forkable {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.fork(self.fork_number))
+	}
+}
+
+pub trait WithBloom {
+	fn with_bloom(self, bloom: H2048) -> Self where Self: Sized;
+}
+
+pub struct Bloom<I> {
+	iter: I,
+	bloom: H2048,
+}
+
+impl<I> Iterator for Bloom<I> where I: Iterator, <I as Iterator>::Item: WithBloom {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.with_bloom(self.bloom.clone()))
+	}
+}
+
+/// Chain iterator interface.
+pub trait ChainIterator: Iterator {
+	/// Should be called to create a fork of current iterator.
+	/// Blocks generated by fork will have lower difficulty than current chain.
+	fn fork(&mut self, fork_number: usize) -> Fork<Self> where Self: Sized;
+	/// Should be called to make every consecutive block have given bloom.
+	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self> where Self: Sized;
+}
+
+impl<I> ChainIterator for I where I: Iterator + Sized + Clone {
+	fn fork(&mut self, fork_number: usize) -> Fork<Self> {
+		Fork {
+			iter: self.clone(),
+			fork_number: fork_number
+		}
+	}
+
+	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self> {
+		Bloom {
+			iter: self.clone(),
+			bloom: bloom
+		}
+	}
+}
+
+/// Helper structure, used for encoding blocks.
+#[derive(Default)]
+pub struct Block {
+	header: Header,
+	transactions: Vec<SignedTransaction>,
+	uncles: Vec<Header>
+}
+
+impl Block {
+	pub fn rlp(&self) -> Bytes {
+		encode(self).to_vec()
+	}
+}
+
+impl Encodable for Block {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(3);
+		s.append(&self.header);
+		s.append(&self.transactions);
+		s.append(&self.uncles);
+	}
+}
+
+impl Forkable for Block {
+	fn fork(mut self, fork_number: usize) -> Self where Self: Sized {
+		self.header.difficulty = self.header.difficulty - U256::from(fork_number);
+		self
+	}
+}
+
+impl WithBloom for Block {
+	fn with_bloom(mut self, bloom: H2048) -> Self where Self: Sized {
+		self.header.log_bloom = bloom;
+		self
+	}
+}
+
+/// Blockchain generator.
+#[derive(Clone)]
+pub struct ChainGenerator {
+	/// Next block number.
+	number: BlockNumber,
+	/// Next block parent hash.
+	parent_hash: H256,
+	/// Next block difficulty.
+	difficulty: U256,
+}
+
+impl ChainGenerator {
+	fn prepare_block(&self) -> Block {
+		let mut block = Block::default();
+		block.header.parent_hash = self.parent_hash.clone();
+		block.header.number = self.number;
+		block.header.difficulty = self.difficulty;
+		block
+	}
+}
+
+impl Default for ChainGenerator {
+	fn default() -> Self {
+		ChainGenerator {
+			number: 0,
+			parent_hash: H256::default(),
+			difficulty: U256::from(1000),
+		}
+	}
+}
+
+impl Iterator for ChainGenerator {
+	type Item = Block;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		let block = self.prepare_block();
+		self.number += 1;
+		self.parent_hash = block.header.hash();
+		Some(block)
+	}
+}
+
+
+#[cfg(test)]
+mod tests {
+	use util::hash::H256;
+	use util::sha3::Hashable;
+	use views::BlockView;
+	use super::{ChainIterator, ChainGenerator};
+
+	#[test]
+	fn canon_chain_generator() {
+		let mut canon_chain = ChainGenerator::default();
+
+		let genesis_rlp = canon_chain.next().unwrap().rlp();
+		let genesis = BlockView::new(&genesis_rlp);
+
+		assert_eq!(genesis.header_view().parent_hash(), H256::default());
+		assert_eq!(genesis.header_view().number(), 0);
+
+		let b1_rlp = canon_chain.next().unwrap().rlp();
+		let b1 = BlockView::new(&b1_rlp);
+
+		assert_eq!(b1.header_view().parent_hash(), genesis.header_view().sha3());
+		assert_eq!(b1.header_view().number(), 1);
+
+		let mut fork_chain = canon_chain.fork(1);
+
+		let b2_rlp_fork = fork_chain.next().unwrap().rlp();
+		let b2_fork = BlockView::new(&b2_rlp_fork);
+
+		assert_eq!(b2_fork.header_view().parent_hash(), b1.header_view().sha3());
+		assert_eq!(b2_fork.header_view().number(), 2);
+
+		let b2_rlp = canon_chain.next().unwrap().rlp();
+		let b2 = BlockView::new(&b2_rlp);
+
+		assert_eq!(b2.header_view().parent_hash(), b1.header_view().sha3());
+		assert_eq!(b2.header_view().number(), 2);
+		assert!(b2.header_view().difficulty() > b2_fork.header_view().difficulty());
+	}
+}
--- a/ethcore/src/blockchain/helpers/mod.rs
+++ b/ethcore/src/blockchain/helpers/mod.rs
@ -0,0 +1,17 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+pub mod generators;
--- a/ethcore/src/blockchain/mod.rs
+++ b/ethcore/src/blockchain/mod.rs
@ -23,6 +23,8 @@ mod bloom_indexer;
 mod cache;
 mod tree_route;
 mod update;
+#[cfg(test)]
+mod helpers;

 pub use self::blockchain::{BlockProvider, BlockChain, BlockChainConfig};
 pub use self::cache::CacheSize;
--- a/ethcore/src/blockchain/tree_route.rs
+++ b/ethcore/src/blockchain/tree_route.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::hash::H256;
+use util::numbers::H256;

 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug)]
--- a/ethcore/src/blockchain/update.rs
+++ b/ethcore/src/blockchain/update.rs
@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use util::hash::H256;
+use util::numbers::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use extras::{BlockDetails, BlockReceipts, TransactionAddress, BlocksBlooms};
--- a/ethcore/src/evm/ext.rs
+++ b/ethcore/src/evm/ext.rs
@ -16,9 +16,7 @@

 //! Interface for Evm externalities.

-use common::Bytes;
-use util::hash::*;
-use util::uint::*;
+use util::common::*;
 use evm::{Schedule, Error};
 use env_info::*;

--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@ -138,7 +138,7 @@ impl State {
 	/// Create a new contract at address `contract`. If there is already an account at the address
 	/// it will have its code reset, ready for `init_code()`.
 	pub fn new_contract(&mut self, contract: &Address, balance: U256) {
-		self.insert_cache(&contract, Some(Account::new_contract(balance)));
+		self.insert_cache(&contract, Some(Account::new_contract(balance, self.account_start_nonce)));
 	}

 	/// Remove an existing account.
@ -204,7 +204,7 @@ impl State {
 	/// Initialise the code of account `a` so that it is `value` for `key`.
 	/// NOTE: Account should have been created with `new_contract`.
 	pub fn init_code(&mut self, a: &Address, code: Bytes) {
-		self.require_or_from(a, true, || Account::new_contract(U256::from(0u8)), |_|{}).init_code(code);
+		self.require_or_from(a, true, || Account::new_contract(x!(0), self.account_start_nonce), |_|{}).init_code(code);
 	}

 	/// Execute a given transaction.
@ -335,10 +335,9 @@ impl fmt::Debug for State {
 mod tests {

 use super::*;
-use util::hash::*;
+use util::common::*;
 use util::trie::*;
 use util::rlp::*;
-use util::uint::*;
 use account::*;
 use tests::helpers::*;
 use devtools::*;
@ -349,7 +348,7 @@ fn code_from_database() {
 	let temp = RandomTempPath::new();
 	let (root, db) = {
 		let mut state = get_temp_state_in(temp.as_path());
-		state.require_or_from(&a, false, ||Account::new_contract(U256::from(42u32)), |_|{});
+		state.require_or_from(&a, false, ||Account::new_contract(x!(42), x!(0)), |_|{});
 		state.init_code(&a, vec![1, 2, 3]);
 		assert_eq!(state.code(&a), Some([1u8, 2, 3].to_vec()));
 		state.commit();
--- a/ethcore/src/transaction.rs
+++ b/ethcore/src/transaction.rs
@ -100,10 +100,10 @@ impl FromJson for SignedTransaction {
 				v: match json.find("v") { Some(ref j) => u16::from_json(j) as u8, None => 0 },
 				r: match json.find("r") { Some(j) => xjson!(j), None => x!(0) },
 				s: match json.find("s") { Some(j) => xjson!(j), None => x!(0) },
-				hash: RefCell::new(None),
+				hash: Cell::new(None),
 				sender: match json.find("sender") {
-					Some(&Json::String(ref sender)) => RefCell::new(Some(address_from_hex(clean(sender)))),
-					_ => RefCell::new(None),
+					Some(&Json::String(ref sender)) => Cell::new(Some(address_from_hex(clean(sender)))),
+					_ => Cell::new(None),
 				}
 			}
 		}
@ -127,8 +127,8 @@ impl Transaction {
 			r: r,
 			s: s,
 			v: v + 27,
-			hash: RefCell::new(None),
-			sender: RefCell::new(None)
+			hash: Cell::new(None),
+			sender: Cell::new(None),
 		}
 	}

@ -140,8 +140,8 @@ impl Transaction {
 			r: U256::zero(),
 			s: U256::zero(),
 			v: 0,
-			hash: RefCell::new(None),
-			sender: RefCell::new(None)
+			hash: Cell::new(None),
+			sender: Cell::new(None),
 		}
 	}

@ -171,9 +171,9 @@ pub struct SignedTransaction {
 	/// The S field of the signature; helps describe the point on the curve.
 	s: U256,
 	/// Cached hash.
-	hash: RefCell<Option<H256>>,
+	hash: Cell<Option<H256>>,
 	/// Cached sender.
-	sender: RefCell<Option<Address>>
+	sender: Cell<Option<Address>>,
 }

 impl PartialEq for SignedTransaction {
@ -208,8 +208,8 @@ impl Decodable for SignedTransaction {
 			v: try!(d.val_at(6)),
 			r: try!(d.val_at(7)),
 			s: try!(d.val_at(8)),
-			hash: RefCell::new(None),
-			sender: RefCell::new(None),
+			hash: Cell::new(None),
+			sender: Cell::new(None),
 		})
 	}
 }
@ -238,12 +238,13 @@ impl SignedTransaction {

 	/// Get the hash of this header (sha3 of the RLP).
 	pub fn hash(&self) -> H256 {
- 		let mut hash = self.hash.borrow_mut();
- 		match &mut *hash {
- 			&mut Some(ref h) => h.clone(),
- 			hash @ &mut None => {
- 				*hash = Some(self.rlp_sha3());
- 				hash.as_ref().unwrap().clone()
+		let hash = self.hash.get();
+		match hash {
+			Some(h) => h,
+			None => {
+				let h = self.rlp_sha3();
+				self.hash.set(Some(h));
+				h
 			}
 		}
 	}
@ -265,12 +266,13 @@ impl SignedTransaction {

 	/// Returns transaction sender.
 	pub fn sender(&self) -> Result<Address, Error> {
- 		let mut sender = self.sender.borrow_mut();
- 		match &mut *sender {
- 			&mut Some(ref h) => Ok(h.clone()),
- 			sender @ &mut None => {
- 				*sender = Some(From::from(try!(ec::recover(&self.signature(), &self.unsigned.hash())).sha3()));
- 				Ok(sender.as_ref().unwrap().clone())
+		let sender = self.sender.get();
+		match sender {
+			Some(s) => Ok(s),
+			None => {
+				let s = Address::from(try!(ec::recover(&self.signature(), &self.unsigned.hash())).sha3());
+				self.sender.set(Some(s));
+				Ok(s)
 			}
 		}
 	}
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@ -18,8 +18,7 @@
 use std::sync::{Arc, Weak};
 use ethsync::{EthSync, SyncState};
 use jsonrpc_core::*;
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use util::sha3::*;
 use ethcore::client::*;
 use ethcore::views::*;
--- a/rpc/src/v1/types/block.rs
+++ b/rpc/src/v1/types/block.rs
@ -15,8 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use serde::{Serialize, Serializer};
-use util::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use v1::types::{Bytes, Transaction, OptionalValue};

 #[derive(Debug)]
@ -71,8 +70,7 @@ pub struct Block {
 #[cfg(test)]
 mod tests {
 	use serde_json;
-	use util::hash::*;
-	use util::uint::*;
+	use util::numbers::*;
 	use v1::types::{Transaction, Bytes, OptionalValue};
 	use super::*;

--- a/rpc/src/v1/types/filter.rs
+++ b/rpc/src/v1/types/filter.rs
@ -17,7 +17,7 @@
 use serde::{Deserialize, Deserializer, Error};
 use serde_json::value;
 use jsonrpc_core::Value;
-use util::hash::*;
+use util::numbers::*;
 use v1::types::BlockNumber;
 use ethcore::filter::Filter as EthFilter;
 use ethcore::client::BlockId;
--- a/rpc/src/v1/types/log.rs
+++ b/rpc/src/v1/types/log.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::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use ethcore::log_entry::LocalizedLogEntry;
 use v1::types::Bytes;

@ -55,8 +54,7 @@ impl From<LocalizedLogEntry> for Log {
 mod tests {
 	use serde_json;
 	use std::str::FromStr;
-	use util::hash::*;
-	use util::uint::*;
+	use util::numbers::*;
 	use v1::types::{Bytes, Log};

 	#[test]
--- a/rpc/src/v1/types/sync.rs
+++ b/rpc/src/v1/types/sync.rs
@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use serde::{Serialize, Serializer};
-use util::uint::*;
+use util::numbers::*;

 #[derive(Default, Debug, Serialize, PartialEq)]
 pub struct SyncInfo {
--- a/rpc/src/v1/types/transaction.rs
+++ b/rpc/src/v1/types/transaction.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::hash::*;
-use util::uint::*;
+use util::numbers::*;
 use ethcore::transaction::{LocalizedTransaction, Action};
 use v1::types::{Bytes, OptionalValue};

--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@ -1171,8 +1171,8 @@ impl ChainSync {
 			.collect::<Vec<_>>()
 	}

-	/// propagades latest block to lagging peers
-	fn propagade_blocks(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
+	/// propagates latest block to lagging peers
+	fn propagate_blocks(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
 		let updated_peers = {
 			let lagging_peers = self.get_lagging_peers(io);

@ -1198,8 +1198,8 @@ impl ChainSync {
 		sent
 	}

-	/// propagades new known hashes to all peers
-	fn propagade_new_hashes(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
+	/// propagates new known hashes to all peers
+	fn propagate_new_hashes(&mut self, local_best: &H256, best_number: BlockNumber, io: &mut SyncIo) -> usize {
 		let updated_peers = self.get_lagging_peers(io);
 		let mut sent = 0;
 		let last_parent = HeaderView::new(&io.chain().block_header(BlockId::Hash(local_best.clone())).unwrap()).parent_hash();
@ -1234,8 +1234,8 @@ impl ChainSync {
 	pub fn chain_blocks_verified(&mut self, io: &mut SyncIo) {
 		let chain = io.chain().chain_info();
 		if (((chain.best_block_number as i64) - (self.last_send_block_number as i64)).abs() as BlockNumber) < MAX_PEER_LAG_PROPAGATION {
-			let blocks = self.propagade_blocks(&chain.best_block_hash, chain.best_block_number, io);
-			let hashes = self.propagade_new_hashes(&chain.best_block_hash, chain.best_block_number, io);
+			let blocks = self.propagate_blocks(&chain.best_block_hash, chain.best_block_number, io);
+			let hashes = self.propagate_new_hashes(&chain.best_block_hash, chain.best_block_number, io);
 			if blocks != 0 || hashes != 0 {
 				trace!(target: "sync", "Sent latest {} blocks and {} hashes to peers.", blocks, hashes);
 			}
@ -1419,7 +1419,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);

-		let peer_count = sync.propagade_new_hashes(&best_hash, best_number, &mut io);
+		let peer_count = sync.propagate_new_hashes(&best_hash, best_number, &mut io);

 		// 1 message should be send
 		assert_eq!(1, io.queue.len());
@ -1439,7 +1439,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);

-		let peer_count = sync.propagade_blocks(&best_hash, best_number, &mut io);
+		let peer_count = sync.propagate_blocks(&best_hash, best_number, &mut io);

 		// 1 message should be send
 		assert_eq!(1, io.queue.len());
@ -1545,7 +1545,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);

-		sync.propagade_new_hashes(&best_hash, best_number, &mut io);
+		sync.propagate_new_hashes(&best_hash, best_number, &mut io);

 		let data = &io.queue[0].data.clone();
 		let result = sync.on_peer_new_hashes(&mut io, 0, &UntrustedRlp::new(&data));
@ -1564,7 +1564,7 @@ mod tests {
 		let best_number = client.chain_info().best_block_number;
 		let mut io = TestIo::new(&mut client, &mut queue, None);

-		sync.propagade_blocks(&best_hash, best_number, &mut io);
+		sync.propagate_blocks(&best_hash, best_number, &mut io);

 		let data = &io.queue[0].data.clone();
 		let result = sync.on_peer_new_block(&mut io, 0, &UntrustedRlp::new(&data));
--- a/sync/src/tests/chain.rs
+++ b/sync/src/tests/chain.rs
@ -121,7 +121,7 @@ fn status_packet() {
 }

 #[test]
-fn propagade_hashes() {
+fn propagate_hashes() {
 	let mut net = TestNet::new(6);
 	net.peer_mut(1).chain.add_blocks(10, false);
 	net.sync();
@ -147,7 +147,7 @@ fn propagade_hashes() {
 }

 #[test]
-fn propagade_blocks() {
+fn propagate_blocks() {
 	let mut net = TestNet::new(2);
 	net.peer_mut(1).chain.add_blocks(10, false);
 	net.sync();
--- a/sync/src/tests/helpers.rs
+++ b/sync/src/tests/helpers.rs
@ -117,7 +117,7 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}

-	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry> {
+	fn logs(&self, _filter: Filter) -> Vec<LocalizedLogEntry> {
 		unimplemented!();
 	}

--- a/util/Cargo.toml
+++ b/util/Cargo.toml
@ -35,6 +35,7 @@ ethcore-devtools = { path = "../devtools" }
 libc = "0.2.7"
 vergen = "0.1"
 target_info = "0.1"
+bigint = { path = "bigint" }

 [features]
 default = []
--- a/util/benches/bigint.rs
+++ b/util/benches/bigint.rs
@ -74,6 +74,19 @@ fn u256_mul(b: &mut Bencher) {
 }


+#[bench]
+fn u256_full_mul(b: &mut Bencher) {
+	b.iter(|| {
+		let n = black_box(10000);
+		(0..n).fold(U256([rand::random::<u64>(), rand::random::<u64>(), rand::random::<u64>(), rand::random::<u64>()]),
+			|old, new| {
+				let U512(ref u512words) = old.full_mul(U256([rand::random::<u64>(), rand::random::<u64>(), rand::random::<u64>(), rand::random::<u64>()]));
+				U256([u512words[0], u512words[2], u512words[2], u512words[3]])
+			})
+	});
+}
+
+
 #[bench]
 fn u128_mul(b: &mut Bencher) {
 	b.iter(|| {
--- a/util/bigint/Cargo.toml
+++ b/util/bigint/Cargo.toml
@ -0,0 +1,23 @@
+[package]
+description = "Rust-assembler implementation of big integers arithmetic"
+homepage = "http://ethcore.io"
+license = "GPL-3.0"
+name = "bigint"
+version = "0.1.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+build = "build.rs"
+
+[build-dependencies]
+rustc_version = "0.1"
+
+[dependencies]
+rustc-serialize = "0.3"
+arrayvec = "0.3"
+rand = "0.3.12"
+serde = "0.7.0"
+clippy = { version = "0.0.44", optional = true }
+heapsize = "0.3"
+
+[features]
+x64asm_arithmetic=[]
+rust_arithmetic=[]
--- a/util/bigint/build.rs
+++ b/util/bigint/build.rs
@ -0,0 +1,25 @@
+// 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=asm_available");
+	}
+}
--- a/util/bigint/src/lib.rs
+++ b/util/bigint/src/lib.rs
@ -0,0 +1,23 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(asm_available, feature(asm))]
+
+extern crate rustc_serialize;
+extern crate serde;
+#[macro_use] extern crate heapsize;
+
+pub mod uint;
--- a/util/bigint/src/uint.rs
+++ b/util/bigint/src/uint.rs
@ -36,10 +36,26 @@
 //! The functions here are designed to be fast.
 //!

-use standard::*;
-use from_json::*;
-use rustc_serialize::hex::ToHex;
+use std::fmt;
+use std::cmp;
+
+use std::mem;
+use std::ops;
+use std::slice;
+use std::result;
+use std::option;
+use std::str::{FromStr};
+use std::convert::From;
+use std::hash::{Hash, Hasher};
+use std::ops::*;
+use std::cmp::*;
+use std::collections::*;
+
 use serde;
+use rustc_serialize::json::Json;
+use rustc_serialize::base64::FromBase64;
+use rustc_serialize::hex::{FromHex, FromHexError, ToHex};
+

 macro_rules! impl_map_from {
 	($thing:ident, $from:ty, $to:ty) => {
@ -51,7 +67,7 @@ macro_rules! impl_map_from {
 	}
 }

-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_add {
 	($name:ident, $n_words:expr, $self_expr: expr, $other: expr) => ({
 		uint_overflowing_add_reg!($name, $n_words, $self_expr, $other)
@ -88,8 +104,7 @@ macro_rules! uint_overflowing_add_reg {
 	})
 }

-
-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_add {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@ -165,7 +180,7 @@ macro_rules! uint_overflowing_add {
 	)
 }

-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_sub {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let res = overflowing!((!$other).overflowing_add(From::from(1u64)));
@ -174,7 +189,7 @@ macro_rules! uint_overflowing_sub {
 	})
 }

-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_sub {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@ -250,7 +265,7 @@ macro_rules! uint_overflowing_sub {
 	})
 }

-#[cfg(all(x64asm, target_arch="x86_64"))]
+#[cfg(all(asm_available, target_arch="x86_64"))]
 macro_rules! uint_overflowing_mul {
 	(U256, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut result: [u64; 4] = unsafe { mem::uninitialized() };
@ -370,7 +385,7 @@ macro_rules! uint_overflowing_mul {
 	)
 }

-#[cfg(not(all(x64asm, target_arch="x86_64")))]
+#[cfg(not(all(asm_available, target_arch="x86_64")))]
 macro_rules! uint_overflowing_mul {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		uint_overflowing_mul_reg!($name, $n_words, $self_expr, $other)
@ -381,7 +396,6 @@ macro_rules! uint_overflowing_mul_reg {
 	($name:ident, $n_words: expr, $self_expr: expr, $other: expr) => ({
 		let mut res = $name::from(0u64);
 		let mut overflow = false;
-		// TODO: be more efficient about this
 		for i in 0..(2 * $n_words) {
 			let v = overflowing!($self_expr.overflowing_mul_u32(($other >> (32 * i)).low_u32()), overflow);
 			let res2 = overflowing!(v.overflowing_shl(32 * i as u32), overflow);
@ -416,7 +430,7 @@ macro_rules! panic_on_overflow {
 }

 /// Large, fixed-length unsigned integer type.
-pub trait Uint: Sized + Default + FromStr + From<u64> + FromJson + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {
+pub trait Uint: Sized + Default + FromStr + From<u64> + fmt::Debug + fmt::Display + PartialOrd + Ord + PartialEq + Eq + Hash {

 	/// Returns new instance equalling zero.
 	fn zero() -> Self;
@ -779,22 +793,6 @@ macro_rules! construct_uint {
 			}
 		}

-		impl FromJson for $name {
-			fn from_json(json: &Json) -> Self {
-				match *json {
-					Json::String(ref s) => {
-						if s.len() >= 2 && &s[0..2] == "0x" {
-							FromStr::from_str(&s[2..]).unwrap_or_else(|_| Default::default())
-						} else {
-							Uint::from_dec_str(s).unwrap_or_else(|_| Default::default())
-						}
-					},
-					Json::U64(u) => From::from(u),
-					Json::I64(i) => From::from(i as u64),
-					_ => Uint::zero(),
-				}
-			}
-		}

 		impl_map_from!($name, u8, u64);
 		impl_map_from!($name, u16, u64);
@ -1097,6 +1095,157 @@ construct_uint!(U512, 8);
 construct_uint!(U256, 4);
 construct_uint!(U128, 2);

+impl U256 {
+	/// Multiplies two 256-bit integers to produce full 512-bit integer
+	/// No overflow possible
+	#[cfg(all(asm_available, target_arch="x86_64"))]
+	pub fn full_mul(self, other: U256) -> U512 {
+		let self_t: &[u64; 4] = unsafe { &mem::transmute(self) };
+		let other_t: &[u64; 4] = unsafe { &mem::transmute(other) };
+		let mut result: [u64; 8] = unsafe { mem::uninitialized() };
+		unsafe {
+			asm!("
+				mov $8, %rax
+				mulq $12
+				mov %rax, $0
+				mov %rdx, $1
+
+				mov $8, %rax
+				mulq $13
+				add %rax, $1
+				adc $$0, %rdx
+				mov %rdx, $2
+
+				mov $8, %rax
+				mulq $14
+				add %rax, $2
+				adc $$0, %rdx
+				mov %rdx, $3
+
+				mov $8, %rax
+				mulq $15
+				add %rax, $3
+				adc $$0, %rdx
+				mov %rdx, $4
+
+				mov $9, %rax
+				mulq $12
+				add %rax, $1
+				adc %rdx, $2
+				adc $$0, $3
+				adc $$0, $4
+				xor $5, $5
+				adc $$0, $5
+				xor $6, $6
+				adc $$0, $6
+				xor $7, $7
+				adc $$0, $7
+
+				mov $9, %rax
+				mulq $13
+				add %rax, $2
+				adc %rdx, $3
+				adc $$0, $4
+				adc $$0, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $9, %rax
+				mulq $14
+				add %rax, $3
+				adc %rdx, $4
+				adc $$0, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $9, %rax
+				mulq $15
+				add %rax, $4
+				adc %rdx, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $10, %rax
+				mulq $12
+				add %rax, $2
+				adc %rdx, $3
+				adc $$0, $4
+				adc $$0, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $10, %rax
+				mulq $13
+				add %rax, $3
+				adc %rdx, $4
+				adc $$0, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $10, %rax
+				mulq $14
+				add %rax, $4
+				adc %rdx, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $10, %rax
+				mulq $15
+				add %rax, $5
+				adc %rdx, $6
+				adc $$0, $7
+
+				mov $11, %rax
+				mulq $12
+				add %rax, $3
+				adc %rdx, $4
+				adc $$0, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $11, %rax
+				mulq $13
+				add %rax, $4
+				adc %rdx, $5
+				adc $$0, $6
+				adc $$0, $7
+
+				mov $11, %rax
+				mulq $14
+				add %rax, $5
+				adc %rdx, $6
+				adc $$0, $7
+
+				mov $11, %rax
+				mulq $15
+				add %rax, $6
+				adc %rdx, $7
+				"
+            : /* $0 */ "={r8}"(result[0]), /* $1 */ "={r9}"(result[1]), /* $2 */ "={r10}"(result[2]),
+			  /* $3 */ "={r11}"(result[3]), /* $4 */ "={r12}"(result[4]), /* $5 */ "={r13}"(result[5]),
+			  /* $6 */ "={r14}"(result[6]), /* $7 */ "={r15}"(result[7])
+
+            : /* $8 */ "m"(self_t[0]), /* $9 */ "m"(self_t[1]), /* $10 */  "m"(self_t[2]),
+			  /* $11 */ "m"(self_t[3]), /* $12 */ "m"(other_t[0]), /* $13 */ "m"(other_t[1]),
+			  /* $14 */ "m"(other_t[2]), /* $15 */ "m"(other_t[3])
+			: "rax", "rdx"
+			:
+			);
+		}
+		U512(result)
+	}
+
+	/// Multiplies two 256-bit integers to produce full 512-bit integer
+	/// No overflow possible
+	#[cfg(not(all(asm_available, target_arch="x86_64")))]
+	pub fn full_mul(self, other: U256) -> U512 {
+		let self_512 = U512::from(self);
+		let other_512 = U512::from(other);
+		let (result, _) = self_512.overflowing_mul(other_512);
+		result
+	}
+}
+
 impl From<U256> for U512 {
 	fn from(value: U256) -> U512 {
 		let U256(ref arr) = value;
@ -1187,6 +1336,9 @@ pub const ZERO_U256: U256 = U256([0x00u64; 4]);
 /// Constant value of `U256::one()` that can be used for a reference saving an additional instance creation.
 pub const ONE_U256: U256 = U256([0x01u64, 0x00u64, 0x00u64, 0x00u64]);

+
+known_heap_size!(0, U128, U256);
+
 #[cfg(test)]
 mod tests {
 	use uint::{Uint, U128, U256, U512};
@ -1828,5 +1980,111 @@ mod tests {
 		let (_, overflow) = U256([0, 0, 8, 0]).overflowing_mul(U256([0, 0, 7, 0]));
 		assert!(overflow);
    }
+
+
+	#[test]
+	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);
+
+		let result = U256([1, 0, 0, 0]).full_mul(U256([1, 0, 0, 0]));
+		assert_eq!(U512([1, 0, 0, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([5, 0, 0, 0]).full_mul(U256([5, 0, 0, 0]));
+		assert_eq!(U512([25, 0, 0, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([0, 5, 0, 0]).full_mul(U256([0, 5, 0, 0]));
+		assert_eq!(U512([0, 0, 25, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([0, 0, 0, 4]).full_mul(U256([4, 0, 0, 0]));
+		assert_eq!(U512([0, 0, 0, 16, 0, 0, 0, 0]), result);
+
+		let result = U256([0, 0, 0, 5]).full_mul(U256([2, 0, 0, 0]));
+		assert_eq!(U512([0, 0, 0, 10, 0, 0, 0, 0]), result);
+
+		let result = U256([0, 0, 2, 0]).full_mul(U256([0, 5, 0, 0]));
+		assert_eq!(U512([0, 0, 0, 10, 0, 0, 0, 0]), result);
+
+		let result = U256([0, 3, 0, 0]).full_mul(U256([0, 0, 3, 0]));
+		assert_eq!(U512([0, 0, 0, 9, 0, 0, 0, 0]), result);
+
+		let result = U256([0, 0, 8, 0]).full_mul(U256([0, 0, 6, 0]));
+		assert_eq!(U512([0, 0, 0, 0, 48, 0, 0, 0]), result);
+
+		let result = U256([9, 0, 0, 0]).full_mul(U256([0, 3, 0, 0]));
+		assert_eq!(U512([0, 27, 0, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, 0, 0, 0]).full_mul(U256([::std::u64::MAX, 0, 0, 0]));
+		assert_eq!(U512([1, ::std::u64::MAX-1, 0, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([0, ::std::u64::MAX, 0, 0]).full_mul(U256([::std::u64::MAX, 0, 0, 0]));
+		assert_eq!(U512([0, 1, ::std::u64::MAX-1, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]).full_mul(U256([::std::u64::MAX, 0, 0, 0]));
+		assert_eq!(U512([1, ::std::u64::MAX, ::std::u64::MAX-1, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, 0, 0, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]));
+		assert_eq!(U512([1, ::std::u64::MAX, ::std::u64::MAX-1, 0, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]));
+		assert_eq!(U512([1, 0, ::std::u64::MAX-1, ::std::u64::MAX, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, 0, 0, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]));
+		assert_eq!(U512([1, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX-1, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]).full_mul(U256([::std::u64::MAX, 0, 0, 0]));
+		assert_eq!(U512([1, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX-1, 0, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, 0, 0, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]));
+		assert_eq!(U512([1, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX-1, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]).full_mul(U256([::std::u64::MAX, 0, 0, 0]));
+		assert_eq!(U512([1, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX-1, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]));
+		assert_eq!(U512([1, 0, ::std::u64::MAX, ::std::u64::MAX-1, ::std::u64::MAX, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]));
+		assert_eq!(U512([1, 0, ::std::u64::MAX, ::std::u64::MAX-1, ::std::u64::MAX, 0, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]));
+		assert_eq!(U512([1, 0, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX-1, ::std::u64::MAX, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, 0, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]));
+		assert_eq!(U512([1, 0, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX-1, ::std::u64::MAX, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]));
+		assert_eq!(U512([1, 0, 0, ::std::u64::MAX-1, ::std::u64::MAX, ::std::u64::MAX, 0, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]));
+		assert_eq!(U512([1, 0, 0, ::std::u64::MAX,  ::std::u64::MAX-1, ::std::u64::MAX, ::std::u64::MAX, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, 0]));
+		assert_eq!(U512([1, 0, 0, ::std::u64::MAX,  ::std::u64::MAX-1, ::std::u64::MAX, ::std::u64::MAX, 0]), result);
+
+		let result = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]).full_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]));
+		assert_eq!(U512([1, 0, 0, 0, ::std::u64::MAX-1, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]), result);
+
+		let result = U256([0, 0, 0, ::std::u64::MAX]).full_mul(U256([0, 0, 0, ::std::u64::MAX]));
+		assert_eq!(U512([0, 0, 0, 0, 0, 0, 1, ::std::u64::MAX-1]), result);
+
+		let result = U256([1, 0, 0, 0]).full_mul(U256([0, 0, 0, ::std::u64::MAX]));
+		assert_eq!(U512([0, 0, 0, ::std::u64::MAX, 0, 0, 0, 0]), result);
+
+		let result = U256([1, 2, 3, 4]).full_mul(U256([5, 0, 0, 0]));
+		assert_eq!(U512([5, 10, 15, 20, 0, 0, 0, 0]), result);
+
+		let result = U256([1, 2, 3, 4]).full_mul(U256([0, 6, 0, 0]));
+		assert_eq!(U512([0, 6, 12, 18, 24, 0, 0, 0]), result);
+
+		let result = U256([1, 2, 3, 4]).full_mul(U256([0, 0, 7, 0]));
+		assert_eq!(U512([0, 0, 7, 14, 21, 28, 0, 0]), result);
+
+		let result = U256([1, 2, 3, 4]).full_mul(U256([0, 0, 0, 8]));
+		assert_eq!(U512([0, 0, 0, 8, 16, 24, 32, 0]), result);
+
+		let result = U256([1, 2, 3, 4]).full_mul(U256([5, 6, 7, 8]));
+		assert_eq!(U512([5, 16, 34, 60, 61, 52, 32, 0]), result);
+	}
 }

--- a/util/build.rs
+++ b/util/build.rs
@ -1,13 +1,7 @@
 extern crate vergen;
-extern crate rustc_version;

 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=x64asm");
-	}
 }
--- a/util/src/common.rs
+++ b/util/src/common.rs
@ -19,10 +19,9 @@
 pub use standard::*;
 pub use from_json::*;
 pub use error::*;
-pub use hash::*;
-pub use uint::*;
 pub use bytes::*;
 pub use vector::*;
+pub use numbers::*;
 pub use sha3::*;

 #[macro_export]
--- a/util/src/crypto.rs
+++ b/util/src/crypto.rs
@ -16,9 +16,8 @@

 //! Ethcore crypto.

-use hash::*;
+use numbers::*;
 use bytes::*;
-use uint::*;
 use secp256k1::{key, Secp256k1};
 use rand::os::OsRng;

@ -151,8 +150,7 @@ impl KeyPair {

 /// EC functions
 pub mod ec {
-	use hash::*;
-	use uint::*;
+	use numbers::*;
 	use standard::*;
 	use crypto::*;
 	use crypto::{self};
--- a/util/src/from_json.rs
+++ b/util/src/from_json.rs
@ -17,6 +17,7 @@
 //! Coversion from json.

 use standard::*;
+use bigint::uint::*;

 #[macro_export]
 macro_rules! xjson {
@ -30,3 +31,20 @@ pub trait FromJson {
 	/// Convert a JSON value to an instance of this type.
 	fn from_json(json: &Json) -> Self;
 }
+
+impl FromJson for U256 {
+	fn from_json(json: &Json) -> Self {
+		match *json {
+			Json::String(ref s) => {
+				if s.len() >= 2 && &s[0..2] == "0x" {
+					FromStr::from_str(&s[2..]).unwrap_or_else(|_| Default::default())
+				} else {
+					Uint::from_dec_str(s).unwrap_or_else(|_| Default::default())
+				}
+			},
+			Json::U64(u) => From::from(u),
+			Json::I64(i) => From::from(i as u64),
+			_ => Uint::zero(),
+		}
+	}
+}
--- a/util/src/hash.rs
+++ b/util/src/hash.rs
@ -23,7 +23,7 @@ use rand::Rng;
 use rand::os::OsRng;
 use bytes::{BytesConvertable,Populatable};
 use from_json::*;
-use uint::{Uint, U256};
+use bigint::uint::{Uint, U256};
 use rustc_serialize::hex::ToHex;
 use serde;

@ -304,6 +304,8 @@ macro_rules! impl_hash {
 			}
 		}

+		impl Copy for $from {}
+		#[cfg_attr(feature="dev", allow(expl_impl_clone_on_copy))]
 		impl Clone for $from {
 			fn clone(&self) -> $from {
 				unsafe {
@ -595,7 +597,7 @@ pub fn h256_from_hex(s: &str) -> H256 {

 /// Convert `n` to an `H256`, setting the rightmost 8 bytes.
 pub fn h256_from_u64(n: u64) -> H256 {
-	use uint::U256;
+	use bigint::uint::U256;
 	H256::from(&U256::from(n))
 }

@ -631,7 +633,7 @@ pub static ZERO_H256: H256 = H256([0x00; 32]);
 #[cfg(test)]
 mod tests {
 	use hash::*;
-	use uint::*;
+	use bigint::uint::*;
 	use std::str::FromStr;

 	#[test]
--- a/util/src/heapsizeof.rs
+++ b/util/src/heapsizeof.rs
@ -16,8 +16,7 @@

 //! Calculates heapsize of util types.

-use uint::*;
 use hash::*;

 known_heap_size!(0, H32, H64, H128, Address, H256, H264, H512, H520, H1024, H2048);
-known_heap_size!(0, U128, U256);
+
--- a/util/src/keys/geth_import.rs
+++ b/util/src/keys/geth_import.rs
@ -46,14 +46,14 @@ pub fn enumerate_geth_keys(path: &Path) -> Result<Vec<(Address, String)>, io::Er
 #[derive(Debug)]
 pub enum ImportError {
 	/// Io error reading geth file
-	IoError(io::Error),
+	Io(io::Error),
 	/// format error
-	FormatError,
+	Format,
 }

 impl From<io::Error> for ImportError {
 	fn from (err: io::Error) -> ImportError {
-		ImportError::IoError(err)
+		ImportError::Io(err)
 	}
 }

@ -65,15 +65,15 @@ pub fn import_geth_key(secret_store: &mut SecretStore, geth_keyfile_path: &Path)

 	let mut json_result = Json::from_str(&buf);
 	let mut json = match json_result {
-		Ok(ref mut parsed_json) => try!(parsed_json.as_object_mut().ok_or(ImportError::FormatError)),
-		Err(_) => { return Err(ImportError::FormatError); }
+		Ok(ref mut parsed_json) => try!(parsed_json.as_object_mut().ok_or(ImportError::Format)),
+		Err(_) => { return Err(ImportError::Format); }
 	};
-	let crypto_object = try!(json.get("Crypto").and_then(|crypto| crypto.as_object()).ok_or(ImportError::FormatError)).clone();
+	let crypto_object = try!(json.get("Crypto").and_then(|crypto| crypto.as_object()).ok_or(ImportError::Format)).clone();
 	json.insert("crypto".to_owned(), Json::Object(crypto_object));
 	json.remove("Crypto");
 	match KeyFileContent::load(&Json::Object(json.clone())) {
 		Ok(key_file) => try!(secret_store.import_key(key_file)),
-		Err(_) => { return Err(ImportError::FormatError); }
+		Err(_) => { return Err(ImportError::Format); }
 	};
 	Ok(())
 }
@ -82,7 +82,7 @@ pub fn import_geth_key(secret_store: &mut SecretStore, geth_keyfile_path: &Path)
 pub fn import_geth_keys(secret_store: &mut SecretStore, geth_keyfiles_directory: &Path) -> Result<(), ImportError> {
 	use std::path::PathBuf;
 	let geth_files = try!(enumerate_geth_keys(geth_keyfiles_directory));
-	for &(ref address, ref file_path) in geth_files.iter() {
+	for &(ref address, ref file_path) in &geth_files {
 		let mut path = PathBuf::new();
 		path.push(geth_keyfiles_directory);
 		path.push(file_path);
--- a/util/src/lib.rs
+++ b/util/src/lib.rs
@ -16,7 +16,6 @@

 #![warn(missing_docs)]
 #![cfg_attr(feature="dev", feature(plugin))]
-#![cfg_attr(x64asm, feature(asm))]
 #![cfg_attr(feature="dev", plugin(clippy))]

 // Clippy settings
@ -111,15 +110,16 @@ extern crate libc;
 extern crate rustc_version;
 extern crate target_info;
 extern crate vergen;
+extern crate bigint;

 pub mod standard;
 #[macro_use]
 pub mod from_json;
 #[macro_use]
 pub mod common;
+pub mod numbers;
 pub mod error;
 pub mod hash;
-pub mod uint;
 pub mod bytes;
 pub mod rlp;
 pub mod misc;
@ -144,6 +144,7 @@ pub mod network;
 pub mod log;
 pub mod panics;
 pub mod keys;
+pub mod table;

 pub use common::*;
 pub use misc::*;
--- a/util/src/network/host.rs
+++ b/util/src/network/host.rs
@ -376,7 +376,7 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 				let entry = NodeEntry { endpoint: n.endpoint.clone(), id: n.id.clone() };
 				self.pinned_nodes.push(n.id.clone());
 				self.nodes.write().unwrap().add_node(n);
-				if let &mut Some(ref mut discovery) = self.discovery.lock().unwrap().deref_mut() {
+				if let Some(ref mut discovery) = *self.discovery.lock().unwrap().deref_mut() {
 					discovery.add_node(entry);
 				}
 			}
@ -697,7 +697,7 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 					let entry = NodeEntry { id: session.id().clone(), endpoint: NodeEndpoint { address: address, udp_port: address.port() } };
 					self.nodes.write().unwrap().add_node(Node::new(entry.id.clone(), entry.endpoint.clone()));
 					let mut discovery = self.discovery.lock().unwrap();
-					if let &mut Some(ref mut discovery) = discovery.deref_mut() {
+					if let Some(ref mut discovery) = *discovery.deref_mut() {
 						discovery.add_node(entry);
 					}
 				}
--- a/util/src/numbers.rs
+++ b/util/src/numbers.rs
@ -0,0 +1,20 @@
+// 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/>.
+
+//! Utils number types.
+
+pub use hash::*;
+pub use bigint::uint::*;
--- a/util/src/rlp/bytes.rs
+++ b/util/src/rlp/bytes.rs
@ -21,7 +21,7 @@ use std::mem;
 use std::fmt;
 use std::cmp::Ordering;
 use std::error::Error as StdError;
-use uint::{Uint, U128, U256};
+use bigint::uint::{Uint, U128, U256};
 use hash::FixedHash;
 use elastic_array::*;

--- a/util/src/rlp/tests.rs
+++ b/util/src/rlp/tests.rs
@ -21,7 +21,7 @@ use std::{fmt, cmp};
 use std::str::FromStr;
 use rlp;
 use rlp::{UntrustedRlp, RlpStream, View, Stream, DecoderError};
-use uint::U256;
+use bigint::uint::U256;

 #[test]
 fn rlp_at() {
--- a/util/src/table.rs
+++ b/util/src/table.rs
@ -0,0 +1,254 @@
+// 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/>.
+
+//! A collection associating pair of keys (row and column) with a single value.
+
+use std::hash::Hash;
+use std::collections::HashMap;
+
+/// Structure to hold double-indexed values
+///
+/// You can obviously use `HashMap<(Row,Col), Val>`, but this structure gives
+/// you better access to all `Columns` in Specific `Row`. Namely you can get sub-hashmap
+/// `HashMap<Col, Val>` for specific `Row`
+pub struct Table<Row, Col, Val>
+	where Row: Eq + Hash + Clone,
+		  Col: Eq + Hash {
+	map: HashMap<Row, HashMap<Col, Val>>,
+}
+
+impl<Row, Col, Val> Table<Row, Col, Val>
+	where Row: Eq + Hash + Clone,
+		  Col: Eq + Hash {
+	/// Creates new Table
+	pub fn new() -> Table<Row, Col, Val> {
+		Table {
+			map: HashMap::new(),
+		}
+	}
+
+	/// Removes all elements from this Table
+	pub fn clear(&mut self) {
+		self.map.clear();
+	}
+
+	/// Returns length of the Table (number of (row, col, val) tuples)
+	pub fn len(&self) -> usize {
+		self.map.values().fold(0, |acc, v| acc + v.len())
+	}
+
+	/// Check if there is any element in this Table
+	pub fn is_empty(&self) -> bool {
+		self.map.is_empty() || self.map.values().all(|v| v.is_empty())
+	}
+
+	/// Get mutable reference for single Table row.
+	pub fn row_mut(&mut self, row: &Row) -> Option<&mut HashMap<Col, Val>> {
+		self.map.get_mut(row)
+	}
+
+	/// Checks if row is defined for that table (note that even if defined it might be empty)
+	pub fn has_row(&self, row: &Row) -> bool {
+		self.map.contains_key(row)
+	}
+
+	/// Get immutable reference for single row in this Table
+	pub fn row(&self, row: &Row) -> Option<&HashMap<Col, Val>> {
+		self.map.get(row)
+	}
+
+	/// Get element in cell described by `(row, col)`
+	pub fn get(&self, row: &Row, col: &Col) -> Option<&Val> {
+		self.map.get(row).and_then(|r| r.get(col))
+	}
+
+	/// Remove value from specific cell
+	///
+	/// It will remove the row if it's the last value in it
+	pub fn remove(&mut self, row: &Row, col: &Col) -> Option<Val> {
+		let (val, is_empty) = {
+			let row_map = self.map.get_mut(row);
+			if let None = row_map {
+				return None;
+			}
+			let mut row_map = row_map.unwrap();
+			let val = row_map.remove(col);
+			(val, row_map.is_empty())
+		};
+		// Clean row
+		if is_empty {
+			self.map.remove(row);
+		}
+		val
+	}
+
+	/// Remove given row from Table if there are no values defined in it
+	///
+	/// When using `#row_mut` it may happen that all values from some row are drained.
+	/// Table however will not be aware that row is empty.
+	/// You can use this method to explicitly remove row entry from the Table.
+	pub fn clear_if_empty(&mut self, row: &Row) {
+		let is_empty = self.map.get(row).map_or(false, |m| m.is_empty());
+		if is_empty {
+			self.map.remove(row);
+		}
+	}
+
+	/// Inserts new value to specified cell
+	///
+	/// Returns previous value (if any)
+	pub fn insert(&mut self, row: Row, col: Col, val: Val) -> Option<Val> {
+		self.map.entry(row).or_insert_with(|| HashMap::new()).insert(col, val)
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn should_create_empty_table() {
+		// when
+		let table : Table<usize, usize, bool> = Table::new();
+
+		// then
+		assert!(table.is_empty());
+		assert_eq!(table.len(), 0);
+	}
+
+	#[test]
+	fn should_insert_elements_and_return_previous_if_any() {
+		// given
+		let mut table = Table::new();
+
+		// when
+		let r1 = table.insert(5, 4, true);
+		let r2 = table.insert(10, 4, true);
+		let r3 = table.insert(10, 10, true);
+		let r4 = table.insert(10, 10, false);
+
+		// then
+		assert!(r1.is_none());
+		assert!(r2.is_none());
+		assert!(r3.is_none());
+		assert!(r4.is_some());
+		assert!(!table.is_empty());
+		assert_eq!(r4.unwrap(), true);
+		assert_eq!(table.len(), 3);
+	}
+
+	#[test]
+	fn should_remove_element() {
+		// given
+		let mut table = Table::new();
+		table.insert(5, 4, true);
+		assert!(!table.is_empty());
+		assert_eq!(table.len(), 1);
+
+		// when
+		let r = table.remove(&5, &4);
+
+		// then
+		assert!(table.is_empty());
+		assert_eq!(table.len() ,0);
+		assert_eq!(r.unwrap(), true);
+	}
+
+	#[test]
+	fn should_return_none_if_trying_to_remove_non_existing_element() {
+				// given
+		let mut table : Table<usize, usize, usize> = Table::new();
+		assert!(table.is_empty());
+
+		// when
+		let r = table.remove(&5, &4);
+
+		// then
+		assert!(r.is_none());
+	}
+
+	#[test]
+	fn should_clear_row_if_removing_last_element() {
+		// given
+		let mut table = Table::new();
+		table.insert(5, 4, true);
+		assert!(table.has_row(&5));
+
+		// when
+		let r = table.remove(&5, &4);
+
+		// then
+		assert!(r.is_some());
+		assert!(!table.has_row(&5));
+	}
+
+	#[test]
+	fn should_return_element_given_row_and_col() {
+		// given
+		let mut table = Table::new();
+		table.insert(1551, 1234, 123);
+
+		// when
+		let r1 = table.get(&1551, &1234);
+		let r2 = table.get(&5, &4);
+
+		// then
+		assert!(r1.is_some());
+		assert!(r2.is_none());
+		assert_eq!(r1.unwrap(), &123);
+	}
+
+	#[test]
+	fn should_clear_table() {
+		// given
+		let mut table = Table::new();
+		table.insert(1, 1, true);
+		table.insert(1, 2, false);
+		table.insert(2, 2, false);
+		assert_eq!(table.len(), 3);
+
+		// when
+		table.clear();
+
+		// then
+		assert!(table.is_empty());
+		assert_eq!(table.len(), 0);
+		assert_eq!(table.has_row(&1), false);
+		assert_eq!(table.has_row(&2), false);
+	}
+
+	#[test]
+	fn should_return_mutable_row() {
+		// given
+		let mut table = Table::new();
+		table.insert(1, 1, true);
+		table.insert(1, 2, false);
+		table.insert(2, 2, false);
+
+		// when
+		{
+			let mut row = table.row_mut(&1).unwrap();
+			row.remove(&1);
+			row.remove(&2);
+		}
+		assert!(table.has_row(&1));
+		table.clear_if_empty(&1);
+
+		// then
+		assert!(!table.has_row(&1));
+		assert_eq!(table.len(), 1);
+	}
+}