From d0125f3ff5ad964644080eea646f769766e952f7 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 00:21:15 +0300
Subject: [PATCH 1/7] uint to separated crate

---
 Cargo.lock                              | 13 ++++++
 ethcore/src/action_params.rs            |  4 +-
 ethcore/src/blockchain/best_block.rs    |  3 +-
 ethcore/src/blockchain/block_info.rs    |  3 +-
 ethcore/src/blockchain/bloom_indexer.rs |  4 +-
 ethcore/src/blockchain/tree_route.rs    |  2 +-
 ethcore/src/blockchain/update.rs        |  2 +-
 ethcore/src/evm/ext.rs                  | 24 +++++-----
 ethcore/src/state.rs                    |  3 +-
 rpc/src/v1/impls/eth.rs                 |  3 +-
 rpc/src/v1/types/block.rs               |  6 +--
 rpc/src/v1/types/filter.rs              |  2 +-
 rpc/src/v1/types/log.rs                 |  8 ++--
 rpc/src/v1/types/sync.rs                |  2 +-
 rpc/src/v1/types/transaction.rs         |  3 +-
 util/Cargo.toml                         |  1 +
 util/bigint/Cargo.toml                  | 23 ++++++++++
 util/bigint/build.rs                    | 25 ++++++++++
 util/bigint/src/lib.rs                  | 23 ++++++++++
 util/{ => bigint}/src/uint.rs           | 61 +++++++++++++------------
 util/build.rs                           |  6 ---
 util/src/common.rs                      |  4 +-
 util/src/crypto.rs                      |  5 +-
 util/src/from_json.rs                   | 18 ++++++++
 util/src/hash.rs                        |  6 +--
 util/src/heapsizeof.rs                  |  3 +-
 util/src/lib.rs                         |  4 +-
 util/src/numbers.rs                     | 20 ++++++++
 util/src/rlp/bytes.rs                   |  2 +-
 util/src/rlp/tests.rs                   |  2 +-
 30 files changed, 194 insertions(+), 91 deletions(-)
 create mode 100644 util/bigint/Cargo.toml
 create mode 100644 util/bigint/build.rs
 create mode 100644 util/bigint/src/lib.rs
 rename util/{ => bigint}/src/uint.rs (98%)
 create mode 100644 util/src/numbers.rs

diff --git a/Cargo.lock b/Cargo.lock
index bca236813..9ce1c4372 100644
--- 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)",
diff --git a/ethcore/src/action_params.rs b/ethcore/src/action_params.rs
index 9e2d72c73..fa40d30a0 100644
--- 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)]
diff --git a/ethcore/src/blockchain/best_block.rs b/ethcore/src/blockchain/best_block.rs
index cbb219617..8dc67ed09 100644
--- 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::common::{U256,H256};
 use header::BlockNumber;
 
 /// Best block info.
diff --git a/ethcore/src/blockchain/block_info.rs b/ethcore/src/blockchain/block_info.rs
index 98dac648d..fbfc0fd96 100644
--- 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::common::{U256,H256};
 use header::BlockNumber;
 
 /// Brief info about inserted block.
diff --git a/ethcore/src/blockchain/bloom_indexer.rs b/ethcore/src/blockchain/bloom_indexer.rs
index 74c679ba8..51a4f61bf 100644
--- 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::common::H256;
 use chainfilter::BloomIndex;
 
 /// Represents location of block bloom in extras database.
@@ -44,7 +44,7 @@ impl BloomIndexer {
 	/// Calculates bloom's position in database.
 	pub fn location(&self, bloom_index: &BloomIndex) -> BlocksBloomLocation {
 		use std::{mem, ptr};
-		
+
 		let hash = unsafe {
 			let mut hash: H256 = mem::zeroed();
 			ptr::copy(&[bloom_index.index / self.index_size] as *const usize as *const u8, hash.as_mut_ptr(), 8);
diff --git a/ethcore/src/blockchain/tree_route.rs b/ethcore/src/blockchain/tree_route.rs
index 1bd0e6f75..4532236aa 100644
--- 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::common::H256;
 
 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug)]
diff --git a/ethcore/src/blockchain/update.rs b/ethcore/src/blockchain/update.rs
index f8ca06e66..526efac73 100644
--- 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::common::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use extras::{BlockDetails, BlockReceipts, TransactionAddress, BlocksBlooms};
diff --git a/ethcore/src/evm/ext.rs b/ethcore/src/evm/ext.rs
index ae4cff3be..f4172f10a 100644
--- 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::*;
 
@@ -60,22 +58,22 @@ pub trait Ext {
 	fn blockhash(&self, number: &U256) -> H256;
 
 	/// Creates new contract.
-	/// 
+	///
 	/// Returns gas_left and contract address if contract creation was succesfull.
 	fn create(&mut self, gas: &U256, value: &U256, code: &[u8]) -> ContractCreateResult;
 
 	/// Message call.
-	/// 
+	///
 	/// Returns Err, if we run out of gas.
-	/// Otherwise returns call_result which contains gas left 
+	/// Otherwise returns call_result which contains gas left
 	/// and true if subcall was successfull.
-	fn call(&mut self, 
-			gas: &U256, 
-			sender_address: &Address, 
-			receive_address: &Address, 
+	fn call(&mut self,
+			gas: &U256,
+			sender_address: &Address,
+			receive_address: &Address,
 			value: Option<U256>,
-			data: &[u8], 
-			code_address: &Address, 
+			data: &[u8],
+			code_address: &Address,
 			output: &mut [u8]) -> MessageCallResult;
 
 	/// Returns code at given address
@@ -99,7 +97,7 @@ pub trait Ext {
 	fn env_info(&self) -> &EnvInfo;
 
 	/// Returns current depth of execution.
-	/// 
+	///
 	/// If contract A calls contract B, and contract B calls C,
 	/// then A depth is 0, B is 1, C is 2 and so on.
 	fn depth(&self) -> usize;
diff --git a/ethcore/src/state.rs b/ethcore/src/state.rs
index 8bbf317c1..83b77ece0 100644
--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@@ -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::*;
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index 00bce5437..0dd5714d2 100644
--- 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::*;
diff --git a/rpc/src/v1/types/block.rs b/rpc/src/v1/types/block.rs
index b92111bcb..2457efcf8 100644
--- 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::*;
 
diff --git a/rpc/src/v1/types/filter.rs b/rpc/src/v1/types/filter.rs
index 01d322cce..16a08764b 100644
--- 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;
diff --git a/rpc/src/v1/types/log.rs b/rpc/src/v1/types/log.rs
index 0629c5534..0f5fdee15 100644
--- 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]
@@ -66,7 +64,7 @@ mod tests {
 		let log = Log {
 			address: Address::from_str("33990122638b9132ca29c723bdf037f1a891a70c").unwrap(),
 			topics: vec![
-				H256::from_str("a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc").unwrap(), 
+				H256::from_str("a6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc").unwrap(),
 				H256::from_str("4861736852656700000000000000000000000000000000000000000000000000").unwrap()
 			],
 			data: Bytes::new(vec![]),
diff --git a/rpc/src/v1/types/sync.rs b/rpc/src/v1/types/sync.rs
index b5568acda..c0e480140 100644
--- 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 {
diff --git a/rpc/src/v1/types/transaction.rs b/rpc/src/v1/types/transaction.rs
index 0e9256ada..232cf0bf3 100644
--- 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};
 
diff --git a/util/Cargo.toml b/util/Cargo.toml
index b7eafd905..0c7df3f40 100644
--- 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 = []
diff --git a/util/bigint/Cargo.toml b/util/bigint/Cargo.toml
new file mode 100644
index 000000000..377391eeb
--- /dev/null
+++ 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=[]
diff --git a/util/bigint/build.rs b/util/bigint/build.rs
new file mode 100644
index 000000000..248823229
--- /dev/null
+++ 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");
+	}
+}
diff --git a/util/bigint/src/lib.rs b/util/bigint/src/lib.rs
new file mode 100644
index 000000000..149878538
--- /dev/null
+++ 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;
diff --git a/util/src/uint.rs b/util/bigint/src/uint.rs
similarity index 98%
rename from util/src/uint.rs
rename to util/bigint/src/uint.rs
index 88256d5f2..4cc0dfc0e 100644
--- a/util/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);
@@ -1100,7 +1098,7 @@ construct_uint!(U128, 2);
 impl U256 {
 	/// Multiplies two 256-bit integers to produce full 512-bit integer
 	/// No overflow possible
-	#[cfg(all(x64asm, target_arch="x86_64"))]
+	#[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) };
@@ -1239,7 +1237,7 @@ impl U256 {
 
 	/// Multiplies two 256-bit integers to produce full 512-bit integer
 	/// No overflow possible
-	#[cfg(not(all(x64asm, target_arch="x86_64")))]
+	#[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);
@@ -1338,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};
diff --git a/util/build.rs b/util/build.rs
index 2b581642b..eed080e29 100644
--- 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");
-	}
 }
diff --git a/util/src/common.rs b/util/src/common.rs
index 0816b72e4..a96bf5444 100644
--- a/util/src/common.rs
+++ b/util/src/common.rs
@@ -19,12 +19,12 @@
 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]
 macro_rules! map {
 	( $( $x:expr => $y:expr ),* ) => {
diff --git a/util/src/crypto.rs b/util/src/crypto.rs
index 2d5516b6f..48d98708b 100644
--- 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;
 
@@ -152,7 +151,7 @@ impl KeyPair {
 /// EC functions
 pub mod ec {
 	use hash::*;
-	use uint::*;
+	use bigint::uint::*;
 	use standard::*;
 	use crypto::*;
 	use crypto::{self};
diff --git a/util/src/from_json.rs b/util/src/from_json.rs
index 7d977afc9..a598ed961 100644
--- 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(),
+		}
+	}
+}
diff --git a/util/src/hash.rs b/util/src/hash.rs
index 88c57371e..42fdff663 100644
--- 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;
 
@@ -595,7 +595,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 +631,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]
diff --git a/util/src/heapsizeof.rs b/util/src/heapsizeof.rs
index d7c8124cd..feb679a0b 100644
--- 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);
+
diff --git a/util/src/lib.rs b/util/src/lib.rs
index 2a47eb438..dd3ef102b 100644
--- 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;
diff --git a/util/src/numbers.rs b/util/src/numbers.rs
new file mode 100644
index 000000000..b79338fc1
--- /dev/null
+++ 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::*;
diff --git a/util/src/rlp/bytes.rs b/util/src/rlp/bytes.rs
index 2ff6281cc..e8bfa57b0 100644
--- 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::*;
 
diff --git a/util/src/rlp/tests.rs b/util/src/rlp/tests.rs
index eb2039103..a92dd5c4a 100644
--- 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() {

From 16038d9555ee8b48b691e26a0be968df26bcac60 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 00:23:49 +0300
Subject: [PATCH 2/7] hash&uint -> numbers

---
 util/src/crypto.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/util/src/crypto.rs b/util/src/crypto.rs
index 48d98708b..66e9f2edb 100644
--- a/util/src/crypto.rs
+++ b/util/src/crypto.rs
@@ -150,8 +150,7 @@ impl KeyPair {
 
 /// EC functions
 pub mod ec {
-	use hash::*;
-	use bigint::uint::*;
+	use numbers::*;
 	use standard::*;
 	use crypto::*;
 	use crypto::{self};

From f528d8c50a37a04d3b1b7fa24dda9c051db3d0d1 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 00:44:45 +0300
Subject: [PATCH 3/7] common -> numbers (as most narrow)

---
 ethcore/src/blockchain/best_block.rs    | 2 +-
 ethcore/src/blockchain/block_info.rs    | 2 +-
 ethcore/src/blockchain/bloom_indexer.rs | 2 +-
 ethcore/src/blockchain/tree_route.rs    | 2 +-
 ethcore/src/blockchain/update.rs        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/ethcore/src/blockchain/best_block.rs b/ethcore/src/blockchain/best_block.rs
index 8dc67ed09..00c092713 100644
--- a/ethcore/src/blockchain/best_block.rs
+++ b/ethcore/src/blockchain/best_block.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::common::{U256,H256};
+use util::numbers::{U256,H256};
 use header::BlockNumber;
 
 /// Best block info.
diff --git a/ethcore/src/blockchain/block_info.rs b/ethcore/src/blockchain/block_info.rs
index fbfc0fd96..ce639bfed 100644
--- a/ethcore/src/blockchain/block_info.rs
+++ b/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::common::{U256,H256};
+use util::numbers::{U256,H256};
 use header::BlockNumber;
 
 /// Brief info about inserted block.
diff --git a/ethcore/src/blockchain/bloom_indexer.rs b/ethcore/src/blockchain/bloom_indexer.rs
index 51a4f61bf..a672a5445 100644
--- 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::common::H256;
+use util::numbers::H256;
 use chainfilter::BloomIndex;
 
 /// Represents location of block bloom in extras database.
diff --git a/ethcore/src/blockchain/tree_route.rs b/ethcore/src/blockchain/tree_route.rs
index 4532236aa..3c4906449 100644
--- 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::common::H256;
+use util::numbers::H256;
 
 /// Represents a tree route between `from` block and `to` block:
 #[derive(Debug)]
diff --git a/ethcore/src/blockchain/update.rs b/ethcore/src/blockchain/update.rs
index 526efac73..6be2647d3 100644
--- a/ethcore/src/blockchain/update.rs
+++ b/ethcore/src/blockchain/update.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use util::common::H256;
+use util::numbers::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
 use extras::{BlockDetails, BlockReceipts, TransactionAddress, BlocksBlooms};

From 82a528961bf3f69d50b11fb9f26fc8ec83c97237 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Tue, 1 Mar 2016 01:13:00 +0300
Subject: [PATCH 4/7] remove line

---
 util/src/common.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/util/src/common.rs b/util/src/common.rs
index a96bf5444..b2a06c4b9 100644
--- a/util/src/common.rs
+++ b/util/src/common.rs
@@ -24,7 +24,6 @@ pub use vector::*;
 pub use numbers::*;
 pub use sha3::*;
 
-
 #[macro_export]
 macro_rules! map {
 	( $( $x:expr => $y:expr ),* ) => {

From 61420d3c9c64d87ab2c83d972c7d2d812b1d9b72 Mon Sep 17 00:00:00 2001
From: Gav Wood <gav@ethcore.io>
Date: Tue, 1 Mar 2016 18:17:59 +0100
Subject: [PATCH 5/7] Fix for morden consensus.

---
 ethcore/src/account.rs | 14 +++++++-------
 ethcore/src/state.rs   |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/ethcore/src/account.rs b/ethcore/src/account.rs
index c36c35232..6901996bc 100644
--- 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]);
diff --git a/ethcore/src/state.rs b/ethcore/src/state.rs
index 8bbf317c1..e35f651ee 100644
--- 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.
@@ -349,7 +349,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();

From aab274d3ef4478120167e1076a0324580cffd516 Mon Sep 17 00:00:00 2001
From: Tomusdrw <tomusdrw@gmail.com>
Date: Thu, 18 Feb 2016 23:01:35 +0100
Subject: [PATCH 6/7] Changing RefCell to Cell in transaction. Implementing
 Copy on Uints.

---
 ethcore/src/transaction.rs | 52 ++++++++++++++++++++------------------
 util/src/hash.rs           |  2 ++
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/ethcore/src/transaction.rs b/ethcore/src/transaction.rs
index fc9886a4d..a51824494 100644
--- 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,13 +238,14 @@ 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,13 +266,14 @@ 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)
+			}
 		}
 	}
 
diff --git a/util/src/hash.rs b/util/src/hash.rs
index 88c57371e..3f708631a 100644
--- a/util/src/hash.rs
+++ b/util/src/hash.rs
@@ -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 {

From 8c9c701de551d8c9d9af71991fd8ca10064f36ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Tue, 1 Mar 2016 21:31:58 +0100
Subject: [PATCH 7/7] Fixing spelling in propagade->propagate

---
 sync/src/chain.rs       | 34 +++++++++++++++++-----------------
 sync/src/tests/chain.rs |  4 ++--
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/sync/src/chain.rs b/sync/src/chain.rs
index 6a7add27f..85380f3cd 100644
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -249,14 +249,14 @@ impl ChainSync {
 			blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
 			num_peers: self.peers.len(),
 			num_active_peers: self.peers.values().filter(|p| p.asking != PeerAsking::Nothing).count(),
-			mem_used: 
+			mem_used:
 				//  TODO: https://github.com/servo/heapsize/pull/50
-				//  self.downloading_hashes.heap_size_of_children() 
-				//+ self.downloading_bodies.heap_size_of_children() 
-				//+ self.downloading_hashes.heap_size_of_children() 
-				self.headers.heap_size_of_children() 
-				+ self.bodies.heap_size_of_children() 
-				+ self.peers.heap_size_of_children() 
+				//  self.downloading_hashes.heap_size_of_children()
+				//+ self.downloading_bodies.heap_size_of_children()
+				//+ self.downloading_hashes.heap_size_of_children()
+				self.headers.heap_size_of_children()
+				+ self.bodies.heap_size_of_children()
+				+ self.peers.heap_size_of_children()
 				+ self.header_ids.heap_size_of_children(),
 		}
 	}
@@ -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));
diff --git a/sync/src/tests/chain.rs b/sync/src/tests/chain.rs
index 1dd9a1e78..b01c894a0 100644
--- 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();