Merge branch 'master' into dapps-https

Conflicts:
	Cargo.lock

Cargo.lock

@@ -32,6 +32,7 @@ dependencies = [
  "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "number_prefix 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 0.1.68 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.1.0",
  "rpassword 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -223,8 +224,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "elastic-array"
-version = "0.4.0"
+version = "0.5.0"
-source = "git+https://github.com/ethcore/elastic-array#9a9bebd6ea291c58e4d6b44dd5dc18368638fefe"
+source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "env_logger"
@@ -296,6 +297,7 @@ dependencies = [
  "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
  "rayon 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.1.0",
  "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -434,6 +436,7 @@ dependencies = [
  "mio 0.5.1 (git+https://github.com/ethcore/mio?branch=v0.5.x)",
  "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.1.0",
  "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "slab 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -460,6 +463,7 @@ dependencies = [
  "jsonrpc-core 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "jsonrpc-http-server 6.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.1.0",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_codegen 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -511,7 +515,7 @@ dependencies = [
  "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
  "bigint 0.1.0",
  "clippy 0.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
- "elastic-array 0.4.0 (git+https://github.com/ethcore/elastic-array)",
+ "elastic-array 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "eth-secp256k1 0.5.4 (git+https://github.com/ethcore/rust-secp256k1)",
  "ethcore-devtools 1.4.0",
@@ -522,6 +526,7 @@ dependencies = [
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.1.0",
  "rocksdb 0.4.5 (git+https://github.com/ethcore/rust-rocksdb)",
  "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -605,6 +610,7 @@ dependencies = [
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.1.0",
  "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -1329,6 +1335,16 @@ dependencies = [
  "untrusted 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "rlp"
+version = "0.1.0"
+dependencies = [
+ "bigint 0.1.0",
+ "elastic-array 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "rocksdb"
 version = "0.4.5"
@@ -1842,7 +1858,7 @@ dependencies = [
 "checksum deque 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1614659040e711785ed8ea24219140654da1729f3ec8a47a9719d041112fe7bf"
 "checksum docopt 0.6.80 (registry+https://github.com/rust-lang/crates.io-index)" = "4cc0acb4ce0828c6a5a11d47baa432fe885881c27428c3a4e473e454ffe57a76"
 "checksum dtoa 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0dd841b58510c9618291ffa448da2e4e0f699d984d436122372f446dae62263d"
-"checksum elastic-array 0.4.0 (git+https://github.com/ethcore/elastic-array)" = "<none>"
+"checksum elastic-array 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4bc9250a632e7c001b741eb0ec6cee93c9a5b6d5f1879696a4b94d62b012210a"
 "checksum env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "aba65b63ffcc17ffacd6cf5aa843da7c5a25e3bd4bbe0b7def8b214e411250e5"
 "checksum eth-secp256k1 0.5.4 (git+https://github.com/ethcore/rust-secp256k1)" = "<none>"
 "checksum ethabi 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f7b0c53453517f620847be51943db329276ae52f2e210cfc659e81182864be2f"

Cargo.toml

@@ -38,6 +38,7 @@ ethcore-ipc-nano = { path = "ipc/nano" }
 ethcore-ipc = { path = "ipc/rpc" }
 ethcore-ipc-hypervisor = { path = "ipc/hypervisor" }
 ethcore-logger = { path = "logger" }
+rlp = { path = "util/rlp" }
 json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git" }
 ethcore-dapps = { path = "dapps", optional = true }
 clippy = { version = "0.0.85", optional = true}

ethcore/Cargo.toml

@@ -35,6 +35,7 @@ ethcore-ipc = { path = "../ipc/rpc" }
 ethstore = { path = "../ethstore" }
 ethkey = { path = "../ethkey" }
 ethcore-ipc-nano = { path = "../ipc/nano" }
+rlp = { path = "../util/rlp" }
 rand = "0.3"
 
 [dependencies.hyper]

ethcore/src/account_db.rs

@@ -16,6 +16,7 @@
 
 //! DB backend wrapper for Account trie
 use util::*;
+use rlp::NULL_RLP;
 
 static NULL_RLP_STATIC: [u8; 1] = [0x80; 1];
 

ethcore/src/block.rs

@@ -22,6 +22,7 @@ use state::*;
 use verification::PreverifiedBlock;
 use trace::FlatTrace;
 use factory::Factories;
+use rlp::*;
 
 /// A block, encoded as it is on the block chain.
 #[derive(Default, Debug, Clone, PartialEq)]

ethcore/src/blockchain/blockchain.rs

@@ -18,6 +18,7 @@
 
 use bloomchain as bc;
 use util::*;
+use rlp::*;
 use header::*;
 use super::extras::*;
 use transaction::*;

ethcore/src/blockchain/extras.rs

@@ -18,6 +18,7 @@
 
 use bloomchain;
 use util::*;
+use rlp::*;
 use header::BlockNumber;
 use receipt::Receipt;
 use db::Key;

ethcore/src/blockchain/generator/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::rlp::*;
+use rlp::*;
 use util::{H256, H2048};
 use util::bytes::Bytes;
 use header::Header;

ethcore/src/blooms/bloom.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use bloomchain as bc;
-use util::rlp::*;
+use rlp::*;
 use util::HeapSizeOf;
 use basic_types::LogBloom;
 

ethcore/src/blooms/bloom_group.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use bloomchain::group as bc;
-use util::rlp::*;
+use rlp::*;
 use util::HeapSizeOf;
 use super::Bloom;
 

ethcore/src/builtin.rs

@@ -127,14 +127,14 @@ impl Impl for EcRecover {
 		let s = H256::from_slice(&input[96..128]);
 
 		let bit = match v[31] {
-			27 | 28 if &v.as_slice()[..31] == &[0; 31] => v[31] - 27,
+			27 | 28 if &v.0[..31] == &[0; 31] => v[31] - 27,
 			_ => return,
 		};
 
 		let s = Signature::from_rsv(&r, &s, bit);
 		if s.is_valid() {
 			if let Ok(p) = ec_recover(&s, &hash) {
-				let r = p.as_slice().sha3();
+				let r = p.sha3();
 
 				let out_len = min(output.len(), 32);
 

ethcore/src/client/client.rs

@@ -22,11 +22,11 @@ use std::time::{Instant};
 use time::precise_time_ns;
 
 // util
-use util::{journaldb, rlp, Bytes, View, PerfTimer, Itertools, Mutex, RwLock};
+use util::{Bytes, PerfTimer, Itertools, Mutex, RwLock};
-use util::journaldb::JournalDB;
+use util::journaldb::{self, JournalDB};
-use util::rlp::{UntrustedRlp};
 use util::{U256, H256, Address, H2048, Uint};
 use util::sha3::*;
+use util::TrieFactory;
 use util::kvdb::*;
 
 // other
@@ -63,9 +63,10 @@ use trace;
 use trace::FlatTransactionTraces;
 use evm::Factory as EvmFactory;
 use miner::{Miner, MinerService};
-use util::TrieFactory;
 use snapshot::{self, io as snapshot_io};
 use factory::Factories;
+use rlp::{View, UntrustedRlp};
+
 
 // re-export
 pub use types::blockchain_info::BlockChainInfo;
@@ -877,7 +878,7 @@ impl BlockChainClient for Client {
 	}
 
 	fn block_receipts(&self, hash: &H256) -> Option<Bytes> {
-		self.chain.block_receipts(hash).map(|receipts| rlp::encode(&receipts).to_vec())
+		self.chain.block_receipts(hash).map(|receipts| ::rlp::encode(&receipts).to_vec())
 	}
 
 	fn import_block(&self, bytes: Bytes) -> Result<H256, BlockImportError> {

ethcore/src/client/test_client.rs

@@ -18,6 +18,7 @@
 
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use util::*;
+use rlp::*;
 use ethkey::{Generator, Random};
 use devtools::*;
 use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action};
@@ -33,7 +34,7 @@ use receipt::{Receipt, LocalizedReceipt};
 use blockchain::extras::BlockReceipts;
 use error::{ImportResult};
 use evm::{Factory as EvmFactory, VMType};
-use miner::{Miner, MinerService};
+use miner::{Miner, MinerService, TransactionImportResult};
 use spec::Spec;
 
 use block_queue::BlockQueueInfo;
@@ -204,7 +205,7 @@ impl TestBlockChainClient {
 					txs.append(&signed_tx);
 					txs.out()
 				},
-				_ => rlp::EMPTY_LIST_RLP.to_vec()
+				_ => ::rlp::EMPTY_LIST_RLP.to_vec()
 			};
 
 			let mut rlp = RlpStream::new_list(3);
@@ -222,8 +223,8 @@ impl TestBlockChainClient {
 		header.set_extra_data(b"This extra data is way too long to be considered valid".to_vec());
 		let mut rlp = RlpStream::new_list(3);
 		rlp.append(&header);
-		rlp.append_raw(&rlp::NULL_RLP, 1);
+		rlp.append_raw(&::rlp::NULL_RLP, 1);
-		rlp.append_raw(&rlp::NULL_RLP, 1);
+		rlp.append_raw(&::rlp::NULL_RLP, 1);
 		self.blocks.write().insert(hash, rlp.out());
 	}
 
@@ -234,8 +235,8 @@ impl TestBlockChainClient {
 		header.set_parent_hash(H256::from(42));
 		let mut rlp = RlpStream::new_list(3);
 		rlp.append(&header);
-		rlp.append_raw(&rlp::NULL_RLP, 1);
+		rlp.append_raw(&::rlp::NULL_RLP, 1);
-		rlp.append_raw(&rlp::NULL_RLP, 1);
+		rlp.append_raw(&::rlp::NULL_RLP, 1);
 		self.blocks.write().insert(hash, rlp.out());
 	}
 
@@ -254,6 +255,24 @@ impl TestBlockChainClient {
 			BlockID::Latest | BlockID::Pending => self.numbers.read().get(&(self.numbers.read().len() - 1)).cloned()
 		}
 	}
+
+	/// Inserts a transaction to miners transactions queue.
+	pub fn insert_transaction_to_queue(&self) {
+		let keypair = Random.generate().unwrap();
+		let tx = Transaction {
+			action: Action::Create,
+			value: U256::from(100),
+			data: "3331600055".from_hex().unwrap(),
+			gas: U256::from(100_000),
+			gas_price: U256::one(),
+			nonce: U256::zero()
+		};
+		let signed_tx = tx.sign(keypair.secret());
+		self.set_balance(signed_tx.sender().unwrap(), 10_000_000.into());
+		let res = self.miner.import_external_transactions(self, vec![signed_tx]);
+		let res = res.into_iter().next().unwrap().expect("Successful import");
+		assert_eq!(res, TransactionImportResult::Current);
+	}
 }
 
 pub fn get_temp_journal_db() -> GuardedTempResult<Box<JournalDB>> {

ethcore/src/db.rs

@@ -20,7 +20,8 @@ use std::ops::Deref;
 use std::hash::Hash;
 use std::collections::HashMap;
 use util::{DBTransaction, Database, RwLock};
-use util::rlp::{encode, Encodable, decode, Decodable};
+
+use rlp;
 
 // database columns
 /// Column for State
@@ -83,12 +84,12 @@ pub trait Key<T> {
 /// Should be used to write value into database.
 pub trait Writable {
 	/// Writes the value into the database.
-	fn write<T, R>(&mut self, col: Option<u32>, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]>;
+	fn write<T, R>(&mut self, col: Option<u32>, key: &Key<T, Target = R>, value: &T) where T: rlp::Encodable, R: Deref<Target = [u8]>;
 
 	/// Writes the value into the database and updates the cache.
 	fn write_with_cache<K, T, R>(&mut self, col: Option<u32>, cache: &mut Cache<K, T>, key: K, value: T, policy: CacheUpdatePolicy) where
 	K: Key<T, Target = R> + Hash + Eq,
-	T: Encodable,
+	T: rlp::Encodable,
 	R: Deref<Target = [u8]> {
 		self.write(col, &key, &value);
 		match policy {
@@ -104,7 +105,7 @@ pub trait Writable {
 	/// Writes the values into the database and updates the cache.
 	fn extend_with_cache<K, T, R>(&mut self, col: Option<u32>, cache: &mut Cache<K, T>, values: HashMap<K, T>, policy: CacheUpdatePolicy) where
 	K: Key<T, Target = R> + Hash + Eq,
-	T: Encodable,
+	T: rlp::Encodable,
 	R: Deref<Target = [u8]> {
 		match policy {
 			CacheUpdatePolicy::Overwrite => {
@@ -127,13 +128,13 @@ pub trait Writable {
 pub trait Readable {
 	/// Returns value for given key.
 	fn read<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) -> Option<T> where
-	T: Decodable,
+	T: rlp::Decodable,
 	R: Deref<Target = [u8]>;
 
 	/// Returns value for given key either in cache or in database.
 	fn read_with_cache<K, T, C>(&self, col: Option<u32>, cache: &RwLock<C>, key: &K) -> Option<T> where
 		K: Key<T> + Eq + Hash + Clone,
-		T: Clone + Decodable,
+		T: Clone + rlp::Decodable,
 		C: Cache<K, T> {
 		{
 			let read = cache.read();
@@ -169,17 +170,17 @@ pub trait Readable {
 }
 
 impl Writable for DBTransaction {
-	fn write<T, R>(&mut self, col: Option<u32>, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]> {
+	fn write<T, R>(&mut self, col: Option<u32>, key: &Key<T, Target = R>, value: &T) where T: rlp::Encodable, R: Deref<Target = [u8]> {
-		self.put(col, &key.key(), &encode(value));
+		self.put(col, &key.key(), &rlp::encode(value));
 	}
 }
 
 impl Readable for Database {
-	fn read<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) -> Option<T> where T: Decodable, R: Deref<Target = [u8]> {
+	fn read<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) -> Option<T> where T: rlp::Decodable, R: Deref<Target = [u8]> {
 		let result = self.get(col, &key.key());
 
 		match result {
-			Ok(option) => option.map(|v| decode(&v)),
+			Ok(option) => option.map(|v| rlp::decode(&v)),
 			Err(err) => {
 				panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
 			}

ethcore/src/engines/basic_authority.rs

@@ -109,7 +109,7 @@ impl Engine for BasicAuthority {
 			let message = header.bare_hash();
 			// account should be pernamently unlocked, otherwise sealing will fail
 			if let Ok(signature) = ap.sign(*block.header().author(), message) {
-				return Some(vec![encode(&(&*signature as &[u8])).to_vec()]);
+				return Some(vec![::rlp::encode(&(&*signature as &[u8])).to_vec()]);
 			} else {
 				trace!(target: "basicauthority", "generate_seal: FAIL: accounts secret key unavailable");
 			}
@@ -131,6 +131,8 @@ impl Engine for BasicAuthority {
 	}
 
 	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+		use rlp::{UntrustedRlp, View};
+
 		// check the signature is legit.
 		let sig = try!(UntrustedRlp::new(&header.seal()[0]).as_val::<H520>());
 		let signer = public_to_address(&try!(recover(&sig.into(), &header.bare_hash())));
@@ -172,7 +174,7 @@ impl Engine for BasicAuthority {
 impl Header {
 	/// Get the none field of the header.
 	pub fn signature(&self) -> H520 {
-		decode(&self.seal()[0])
+		::rlp::decode(&self.seal()[0])
 	}
 }
 
@@ -228,7 +230,7 @@ mod tests {
 	fn can_do_signature_verification_fail() {
 		let engine = new_test_authority().engine;
 		let mut header: Header = Header::default();
-		header.set_seal(vec![rlp::encode(&H520::default()).to_vec()]);
+		header.set_seal(vec![::rlp::encode(&H520::default()).to_vec()]);
 
 		let verify_result = engine.verify_block_unordered(&header, None);
 		assert!(verify_result.is_err());

ethcore/src/engines/instant_seal.rs

@@ -100,7 +100,7 @@ mod tests {
 
 		assert!(engine.verify_block_basic(&header, None).is_ok());
 
-		header.set_seal(vec![rlp::encode(&H520::default()).to_vec()]);
+		header.set_seal(vec![::rlp::encode(&H520::default()).to_vec()]);
 
 		assert!(engine.verify_block_unordered(&header, None).is_ok());
 	}

ethcore/src/error.rs

@@ -28,7 +28,7 @@ use ethkey::Error as EthkeyError;
 
 pub use types::executed::{ExecutionError, CallError};
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 /// Errors concerning transaction processing.
 pub enum TransactionError {
 	/// Transaction is already imported to the queue
@@ -87,7 +87,7 @@ impl fmt::Display for TransactionError {
 	}
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Clone, Copy, Eq)]
 /// Errors concerning block processing.
 pub enum BlockError {
 	/// Block has too many uncles.
@@ -185,7 +185,7 @@ impl fmt::Display for BlockError {
 	}
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 /// Import to the block queue result
 pub enum ImportError {
 	/// Already in the block chain.
@@ -302,8 +302,8 @@ impl From<ExecutionError> for Error {
 	}
 }
 
-impl From<DecoderError> for Error {
+impl From<::rlp::DecoderError> for Error {
-	fn from(err: DecoderError) -> Error {
+	fn from(err: ::rlp::DecoderError) -> Error {
 		Error::Util(UtilError::Decoder(err))
 	}
 }

ethcore/src/ethereum/ethash.rs

@@ -21,6 +21,7 @@ use spec::CommonParams;
 use engines::Engine;
 use evm::Schedule;
 use ethjson;
+use rlp::{self, UntrustedRlp, View};
 
 /// Ethash params.
 #[derive(Debug, PartialEq)]
@@ -328,17 +329,17 @@ impl Ethash {
 impl Header {
 	/// Get the none field of the header.
 	pub fn nonce(&self) -> H64 {
-		decode(&self.seal()[1])
+		rlp::decode(&self.seal()[1])
 	}
 
 	/// Get the mix hash field of the header.
 	pub fn mix_hash(&self) -> H256 {
-		decode(&self.seal()[0])
+		rlp::decode(&self.seal()[0])
 	}
 
 	/// Set the nonce and mix hash fields of the header.
 	pub fn set_nonce_and_mix_hash(&mut self, nonce: &H64, mix_hash: &H256) {
-		self.set_seal(vec![encode(mix_hash).to_vec(), encode(nonce).to_vec()]);
+		self.set_seal(vec![rlp::encode(mix_hash).to_vec(), rlp::encode(nonce).to_vec()]);
 	}
 }
 
@@ -349,6 +350,7 @@ mod tests {
 	use tests::helpers::*;
 	use super::super::new_morden;
 	use super::Ethash;
+	use rlp;
 
 	#[test]
 	fn on_close_block() {

ethcore/src/evm/interpreter/gasometer.rs

@@ -76,7 +76,7 @@ impl<Gas: CostType> Gasometer<Gas> {
 			instructions::SSTORE => {
 				let address = H256::from(stack.peek(0));
 				let newval = stack.peek(1);
-				let val = U256::from(ext.storage_at(&address).as_slice());
+				let val = U256::from(&*ext.storage_at(&address));
 
 				let gas = if val.is_zero() && !newval.is_zero() {
 					schedule.sstore_set_gas

ethcore/src/evm/interpreter/mod.rs

@@ -403,18 +403,18 @@ impl<Cost: CostType> Interpreter<Cost> {
 				let offset = stack.pop_back();
 				let size = stack.pop_back();
 				let sha3 = self.mem.read_slice(offset, size).sha3();
-				stack.push(U256::from(sha3.as_slice()));
+				stack.push(U256::from(&*sha3));
 			},
 			instructions::SLOAD => {
 				let key = H256::from(&stack.pop_back());
-				let word = U256::from(ext.storage_at(&key).as_slice());
+				let word = U256::from(&*ext.storage_at(&key));
 				stack.push(word);
 			},
 			instructions::SSTORE => {
 				let address = H256::from(&stack.pop_back());
 				let val = stack.pop_back();
 
-				let current_val = U256::from(ext.storage_at(&address).as_slice());
+				let current_val = U256::from(&*ext.storage_at(&address));
 				// Increase refund for clear
 				if !self.is_zero(&current_val) && self.is_zero(&val) {
 					ext.inc_sstore_clears();
@@ -491,7 +491,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 			instructions::BLOCKHASH => {
 				let block_number = stack.pop_back();
 				let block_hash = ext.blockhash(&block_number);
-				stack.push(U256::from(block_hash.as_slice()));
+				stack.push(U256::from(&*block_hash));
 			},
 			instructions::COINBASE => {
 				stack.push(address_to_u256(ext.env_info().author.clone()));
@@ -807,7 +807,7 @@ fn u256_to_address(value: &U256) -> Address {
 
 #[inline]
 fn address_to_u256(value: Address) -> U256 {
-	U256::from(H256::from(value).as_slice())
+	U256::from(&*H256::from(value))
 }
 
 #[test]

ethcore/src/executive.rs

@@ -32,6 +32,8 @@ const MAX_VM_DEPTH_FOR_THREAD: usize = 64;
 
 /// Returns new address created from address and given nonce.
 pub fn contract_address(address: &Address, nonce: &U256) -> Address {
+	use rlp::{RlpStream, Stream};
+
 	let mut stream = RlpStream::new_list(2);
 	stream.append(address);
 	stream.append(nonce);

ethcore/src/header.rs

@@ -19,6 +19,7 @@
 use util::*;
 use basic_types::*;
 use time::get_time;
+use rlp::*;
 
 use std::cell::RefCell;
 
@@ -297,7 +298,7 @@ impl Encodable for Header {
 #[cfg(test)]
 mod tests {
 	use rustc_serialize::hex::FromHex;
-	use util::rlp::{decode, encode};
+	use rlp;
 	use super::Header;
 
 	#[test]
@@ -307,7 +308,7 @@ mod tests {
 		let mix_hash = "a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd".from_hex().unwrap();
 		let nonce = "88ab4e252a7e8c2a23".from_hex().unwrap();
 
-		let header: Header = decode(&header_rlp);
+		let header: Header = rlp::decode(&header_rlp);
 		let seal_fields = header.seal;
 		assert_eq!(seal_fields.len(), 2);
 		assert_eq!(seal_fields[0], mix_hash);
@@ -319,8 +320,8 @@ mod tests {
 		// that's rlp of block header created with ethash engine.
 		let header_rlp = "f901f9a0d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a088d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158a007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefba82524d84568e932a80a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd88ab4e252a7e8c2a23".from_hex().unwrap();
 
-		let header: Header = decode(&header_rlp);
+		let header: Header = rlp::decode(&header_rlp);
-		let encoded_header = encode(&header).to_vec();
+		let encoded_header = rlp::encode(&header).to_vec();
 
 		assert_eq!(header_rlp, encoded_header);
 	}

ethcore/src/json_tests/transaction.rs

@@ -17,6 +17,7 @@
 use super::test_common::*;
 use evm;
 use ethjson;
+use rlp::{UntrustedRlp, View};
 
 fn do_json_test(json_data: &[u8]) -> Vec<String> {
 	let tests = ethjson::transaction::Test::load(json_data).unwrap();

ethcore/src/lib.rs

@@ -79,12 +79,9 @@
 //!   cargo build --release
 //!   ```
 
-#[macro_use] extern crate log;
+
-#[macro_use] extern crate ethcore_util as util;
 extern crate ethcore_io as io;
-#[macro_use] extern crate lazy_static;
 extern crate rustc_serialize;
-#[macro_use] extern crate heapsize;
 extern crate crypto;
 extern crate time;
 extern crate env_logger;
@@ -92,19 +89,32 @@ extern crate num_cpus;
 extern crate crossbeam;
 extern crate ethjson;
 extern crate bloomchain;
-#[macro_use] extern crate ethcore_ipc as ipc;
 extern crate rayon;
 extern crate hyper;
 extern crate ethash;
 extern crate ethkey;
-pub extern crate ethstore;
 extern crate semver;
 extern crate ethcore_ipc_nano as nanoipc;
 extern crate ethcore_devtools as devtools;
 extern crate rand;
 extern crate bit_set;
+extern crate rlp;
 
-#[cfg(feature = "jit" )] extern crate evmjit;
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate ethcore_util as util;
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate heapsize;
+#[macro_use]
+extern crate ethcore_ipc as ipc;
+
+#[cfg(feature = "jit" )]
+extern crate evmjit;
+
+pub extern crate ethstore;
 
 pub mod account_provider;
 pub mod engines;

ethcore/src/migrations/blocks/v8.rs

@@ -17,7 +17,7 @@
 //! This migration compresses the state db.
 
 use util::migration::{SimpleMigration, Progress};
-use util::rlp::{Compressible, UntrustedRlp, View, RlpType};
+use rlp::{Compressible, UntrustedRlp, View, RlpType};
 
 /// Compressing migration.
 #[derive(Default)]

ethcore/src/migrations/state/v7.rs

@@ -23,9 +23,11 @@ use util::Bytes;
 use util::{Address, FixedHash, H256};
 use util::kvdb::Database;
 use util::migration::{Batch, Config, Error, Migration, SimpleMigration, Progress};
-use util::rlp::{decode, Rlp, RlpStream, Stream, View};
 use util::sha3::Hashable;
 
+use rlp::{decode, Rlp, RlpStream, Stream, View};
+
+
 // attempt to migrate a key, value pair. None if migration not possible.
 fn attempt_migrate(mut key_h: H256, val: &[u8]) -> Option<H256> {
 	let val_hash = val.sha3();

ethcore/src/migrations/v9.rs

@@ -17,7 +17,7 @@
 
 //! This migration consolidates all databases into single one using Column Families.
 
-use util::{Rlp, RlpStream, View, Stream};
+use rlp::{Rlp, RlpStream, View, Stream};
 use util::kvdb::Database;
 use util::migration::{Batch, Config, Error, Migration, Progress};
 

ethcore/src/miner/transaction_queue.rs

@@ -1229,6 +1229,8 @@ mod test {
 
 	#[test]
 	fn should_reject_incorectly_signed_transaction() {
+		use rlp::{self, RlpStream, Stream};
+
 		// given
 		let mut txq = TransactionQueue::new();
 		let tx = new_unsigned_tx(123.into(), 1.into());
@@ -1243,7 +1245,7 @@ mod test {
 			s.append(&0u64); // v
 			s.append(&U256::zero()); // r
 			s.append(&U256::zero()); // s
-			decode(s.as_raw())
+			rlp::decode(s.as_raw())
 		};
 		// when
 		let res = txq.add(stx, &default_account_details, TransactionOrigin::External);

ethcore/src/pod_account.rs

@@ -19,6 +19,7 @@ use state::Account;
 use account_db::AccountDBMut;
 use ethjson;
 use types::account_diff::*;
+use rlp::{self, RlpStream, Stream};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 /// An account, expressed as Plain-Old-Data (hence the name).
@@ -57,7 +58,7 @@ impl PodAccount {
 		let mut stream = RlpStream::new_list(4);
 		stream.append(&self.nonce);
 		stream.append(&self.balance);
-		stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), encode(&U256::from(v.as_slice())).to_vec())).collect()));
+		stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), rlp::encode(&U256::from(&**v)).to_vec())).collect()));
 		stream.append(&self.code.as_ref().unwrap_or(&vec![]).sha3());
 		stream.out()
 	}
@@ -71,7 +72,7 @@ impl PodAccount {
 		let mut r = H256::new();
 		let mut t = SecTrieDBMut::new(db, &mut r);
 		for (k, v) in &self.storage {
-			if let Err(e) = t.insert(k, &encode(&U256::from(v.as_slice()))) {
+			if let Err(e) = t.insert(k, &rlp::encode(&U256::from(&**v))) {
 				warn!("Encountered potential DB corruption: {}", e);
 			}
 		}

ethcore/src/snapshot/account.rs

@@ -17,11 +17,12 @@
 //! Account state encoding and decoding
 
 use account_db::{AccountDB, AccountDBMut};
-use util::{U256, FixedHash, H256, Bytes, HashDB, SHA3_EMPTY};
-use util::rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View};
-use util::trie::{TrieDB, Trie};
 use snapshot::Error;
 
+use util::{U256, FixedHash, H256, Bytes, HashDB, SHA3_EMPTY};
+use util::trie::{TrieDB, Trie};
+use rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View};
+
 use std::collections::{HashMap, HashSet};
 
 // whether an encoded account has code and how it is referred to.
@@ -206,9 +207,9 @@ mod tests {
 	use tests::helpers::get_temp_journal_db;
 	use snapshot::tests::helpers::fill_storage;
 
-	use util::{SHA3_NULL_RLP, SHA3_EMPTY};
+	use util::sha3::{SHA3_EMPTY, SHA3_NULL_RLP};
 	use util::{Address, FixedHash, H256, HashDB};
-	use util::rlp::{UntrustedRlp, View};
+	use rlp::{UntrustedRlp, View};
 
 	use std::collections::{HashSet, HashMap};
 

ethcore/src/snapshot/block.rs

@@ -20,8 +20,8 @@ use block::Block;
 use header::Header;
 
 use views::BlockView;
-use util::rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View};
+use rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View};
-use util::rlp::{Compressible, RlpType};
+use rlp::{Compressible, RlpType};
 use util::{Bytes, Hashable, H256};
 
 const HEADER_FIELDS: usize = 10;

ethcore/src/snapshot/error.rs

@@ -22,7 +22,7 @@ use ids::BlockID;
 
 use util::H256;
 use util::trie::TrieError;
-use util::rlp::DecoderError;
+use rlp::DecoderError;
 
 /// Snapshot-related errors.
 #[derive(Debug)]

ethcore/src/snapshot/io.rs

@@ -27,7 +27,7 @@ use std::path::{Path, PathBuf};
 
 use util::Bytes;
 use util::hash::H256;
-use util::rlp::{self, Encodable, RlpStream, UntrustedRlp, Stream, View};
+use rlp::{self, Encodable, RlpStream, UntrustedRlp, Stream, View};
 
 use super::ManifestData;
 

ethcore/src/snapshot/mod.rs

@@ -32,9 +32,9 @@ use util::Mutex;
 use util::hash::{FixedHash, H256};
 use util::journaldb::{self, Algorithm, JournalDB};
 use util::kvdb::Database;
-use util::rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View, Compressible, RlpType};
+use util::sha3::SHA3_NULL_RLP;
-use util::rlp::SHA3_NULL_RLP;
 use util::trie::{TrieDB, TrieDBMut, Trie, TrieMut};
+use rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View, Compressible, RlpType};
 
 use self::account::Account;
 use self::block::AbridgedBlock;

ethcore/src/snapshot/tests/helpers.rs

@@ -25,7 +25,7 @@ use util::hash::{FixedHash, H256};
 use util::hashdb::HashDB;
 use util::trie::{Alphabet, StandardMap, SecTrieDBMut, TrieMut, ValueMode};
 use util::trie::{TrieDB, TrieDBMut, Trie};
-use util::rlp::SHA3_NULL_RLP;
+use util::sha3::SHA3_NULL_RLP;
 
 // the proportion of accounts we will alter each tick.
 const ACCOUNT_CHURN: f32 = 0.01;

ethcore/src/spec/genesis.rs

@@ -14,8 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::rlp::*;
 use util::{Address, H256, Uint, U256};
+use util::sha3::SHA3_NULL_RLP;
 use ethjson;
 use super::seal::Seal;
 

ethcore/src/spec/seal.rs

@@ -16,7 +16,7 @@
 
 //! Spec seal.
 
-use util::rlp::*;
+use rlp::*;
 use util::hash::{H64, H256};
 use ethjson;
 

ethcore/src/spec/spec.rs

@@ -24,6 +24,7 @@ use super::genesis::Genesis;
 use super::seal::Generic as GenericSeal;
 use ethereum;
 use ethjson;
+use rlp::{Rlp, RlpStream, View, Stream};
 
 /// Parameters common to all engines.
 #[derive(Debug, PartialEq, Clone)]
@@ -231,7 +232,7 @@ impl Spec {
 			{
 				let mut t = SecTrieDBMut::new(db, &mut root);
 				for (address, account) in self.genesis_state.get().iter() {
-					try!(t.insert(address.as_slice(), &account.rlp()));
+					try!(t.insert(&**address, &account.rlp()));
 				}
 			}
 			for (address, account) in self.genesis_state.get().iter() {

ethcore/src/state/account.rs

@@ -19,6 +19,7 @@
 use std::collections::hash_map::Entry;
 use util::*;
 use pod_account::*;
+use rlp::*;
 
 use std::cell::{Ref, RefCell, Cell};
 
@@ -287,7 +288,7 @@ impl Account {
 				// so we can call overloaded `to_bytes` method
 				let res = match v.is_zero() {
 					true => t.remove(k),
-					false => t.insert(k, &encode(&U256::from(v.as_slice()))),
+					false => t.insert(k, &encode(&U256::from(&*v))),
 				};
 
 				if let Err(e) = res {
@@ -333,6 +334,7 @@ mod tests {
 	use util::*;
 	use super::*;
 	use account_db::*;
+	use rlp::*;
 
 	#[test]
 	fn account_compress() {

ethcore/src/tests/client.rs

@@ -22,6 +22,7 @@ use tests::helpers::*;
 use common::*;
 use devtools::*;
 use miner::Miner;
+use rlp::{Rlp, View};
 
 #[test]
 fn imports_from_empty() {

ethcore/src/tests/helpers.rs

@@ -27,6 +27,7 @@ use engines::Engine;
 use ethereum;
 use devtools::*;
 use miner::Miner;
+use rlp::{self, RlpStream, Stream};
 
 #[cfg(feature = "json-tests")]
 pub enum ChainEra {
@@ -116,7 +117,7 @@ pub fn create_test_block_with_data(header: &Header, transactions: &[SignedTransa
 	rlp.append(header);
 	rlp.begin_list(transactions.len());
 	for t in transactions {
-		rlp.append_raw(&encode::<SignedTransaction>(t).to_vec(), 1);
+		rlp.append_raw(&rlp::encode::<SignedTransaction>(t).to_vec(), 1);
 	}
 	rlp.append(&uncles);
 	rlp.out()

ethcore/src/trace/bloom.rs

@@ -1,6 +1,6 @@
 use bloomchain::Bloom;
 use bloomchain::group::{BloomGroup, GroupPosition};
-use util::rlp::*;
+use rlp::*;
 use basic_types::LogBloom;
 
 /// Helper structure representing bloom of the trace.

ethcore/src/types/account_diff.rs

@@ -98,12 +98,10 @@ impl AccountDiff {
 
 // TODO: refactor into something nicer.
 fn interpreted_hash(u: &H256) -> String {
-	use util::bytes::*;
-
 	if u <= &H256::from(0xffffffff) {
-		format!("{} = 0x{:x}", U256::from(u.as_slice()).low_u32(), U256::from(u.as_slice()).low_u32())
+		format!("{} = 0x{:x}", U256::from(&**u).low_u32(), U256::from(&**u).low_u32())
 	} else if u <= &H256::from(u64::max_value()) {
-		format!("{} = 0x{:x}", U256::from(u.as_slice()).low_u64(), U256::from(u.as_slice()).low_u64())
+		format!("{} = 0x{:x}", U256::from(&**u).low_u64(), U256::from(&**u).low_u64())
 //	} else if u <= &H256::from("0xffffffffffffffffffffffffffffffffffffffff") {
 //		format!("@{}", Address::from(u))
 	} else {
@@ -113,7 +111,7 @@ fn interpreted_hash(u: &H256) -> String {
 
 impl fmt::Display for AccountDiff {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		use util::bytes::*;
+		use util::bytes::ToPretty;
 
 		match self.nonce {
 			Diff::Born(ref x) => try!(write!(f, "  non {}", x)),

ethcore/src/types/executed.rs

@@ -17,7 +17,7 @@
 //! Transaction execution format module.
 
 use util::{Bytes, U256, Address, U512};
-use util::rlp::*;
+use rlp::*;
 use trace::{VMTrace, FlatTrace};
 use types::log_entry::LogEntry;
 use types::state_diff::StateDiff;
@@ -203,7 +203,8 @@ pub type ExecutionResult = Result<Executed, ExecutionError>;
 
 #[test]
 fn should_encode_and_decode_call_type() {
-	use util::rlp;
+	use rlp;
+
 	let original = CallType::Call;
 	let encoded = rlp::encode(&original);
 	let decoded = rlp::decode(&encoded);

ethcore/src/types/log_entry.rs

@@ -18,8 +18,9 @@
 
 use std::ops::Deref;
 use util::{H256, Address, Bytes, HeapSizeOf, Hashable};
-use util::rlp::*;
 use util::bloom::Bloomable;
+use rlp::*;
+
 use basic_types::LogBloom;
 use header::BlockNumber;
 use ethjson;

ethcore/src/types/receipt.rs

@@ -17,8 +17,9 @@
 //! Receipt
 
 use util::{H256, U256, Address};
-use util::rlp::*;
 use util::HeapSizeOf;
+use rlp::*;
+
 use basic_types::LogBloom;
 use header::BlockNumber;
 use log_entry::{LogEntry, LocalizedLogEntry};

ethcore/src/types/trace_types/flat.rs

@@ -17,7 +17,7 @@
 //! Flat trace module
 
 use std::collections::VecDeque;
-use util::rlp::*;
+use rlp::*;
 use util::HeapSizeOf;
 use basic_types::LogBloom;
 use super::trace::{Action, Res};
@@ -167,7 +167,6 @@ mod tests {
 
 	#[test]
 	fn test_trace_serialization() {
-		use util::rlp;
 		// block #51921
 
 		let flat_trace = FlatTrace {
@@ -220,8 +219,8 @@ mod tests {
 			FlatTransactionTraces(vec![flat_trace1, flat_trace2])
 		]);
 
-		let encoded = rlp::encode(&block_traces);
+		let encoded = ::rlp::encode(&block_traces);
-		let decoded = rlp::decode(&encoded);
+		let decoded = ::rlp::decode(&encoded);
 		assert_eq!(block_traces, decoded);
 	}
 }

ethcore/src/types/trace_types/trace.rs

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

ethcore/src/types/transaction.rs

@@ -18,7 +18,7 @@
 
 use std::ops::Deref;
 use std::cell::*;
-use util::rlp::*;
+use rlp::*;
 use util::sha3::Hashable;
 use util::{H256, Address, U256, Bytes};
 use ethkey::{Signature, sign, Secret, recover, public_to_address, Error as EthkeyError};
@@ -275,7 +275,7 @@ impl SignedTransaction {
 		match hash {
 			Some(h) => h,
 			None => {
-				let h = self.rlp_sha3();
+				let h = (&*self.rlp_bytes()).sha3();
 				self.hash.set(Some(h));
 				h
 			}

ethcore/src/types/transaction_import.rs

@@ -18,9 +18,8 @@
 
 use ipc::binary::{BinaryConvertError, BinaryConvertable};
 use error::{TransactionError, Error};
-use util::Populatable;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 /// Represents the result of importing transaction.
 pub enum TransactionImportResult {
 	/// Transaction was imported to current queue.

ethcore/src/verification/verification.rs

@@ -24,6 +24,7 @@
 use common::*;
 use engines::Engine;
 use blockchain::*;
+use rlp::{UntrustedRlp, View};
 
 /// Preprocessed block data gathered in `verify_block_unordered` call
 pub struct PreverifiedBlock {
@@ -240,6 +241,7 @@ mod tests {
 	use spec::*;
 	use transaction::*;
 	use tests::helpers::*;
+	use rlp::View;
 
 	fn check_ok(result: Result<(), Error>) {
 		result.unwrap_or_else(|e| panic!("Block verification failed: {:?}", e));
@@ -346,6 +348,8 @@ mod tests {
 	#[test]
 	#[cfg_attr(feature="dev", allow(similar_names))]
 	fn test_verify_block() {
+		use rlp::{RlpStream, Stream};
+
 		// Test against morden
 		let mut good = Header::new();
 		let spec = Spec::new_test();
@@ -411,7 +415,7 @@ mod tests {
 		let mut uncles_rlp = RlpStream::new();
 		uncles_rlp.append(&good_uncles);
 		let good_uncles_hash = uncles_rlp.as_raw().sha3();
-		let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| encode::<SignedTransaction>(t).to_vec()).collect());
+		let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| ::rlp::encode::<SignedTransaction>(t).to_vec()).collect());
 
 		let mut parent = good.clone();
 		parent.set_number(9);

ethcore/src/views/block.rs

@@ -20,6 +20,7 @@ use util::*;
 use header::*;
 use transaction::*;
 use super::{TransactionView, HeaderView};
+use rlp::{Rlp, View};
 
 /// View onto block rlp.
 pub struct BlockView<'a> {

ethcore/src/views/body.rs

@@ -20,6 +20,7 @@ use util::*;
 use header::*;
 use transaction::*;
 use super::{TransactionView, HeaderView};
+use rlp::{Rlp, View};
 
 /// View onto block rlp.
 pub struct BodyView<'a> {

ethcore/src/views/header.rs

@@ -16,7 +16,8 @@
 
 //! View onto block header rlp
 
-use util::{Rlp, U256, Bytes, Hashable, H256, Address, H2048, View};
+use util::{U256, Bytes, Hashable, H256, Address, H2048};
+use rlp::{Rlp, View};
 use header::BlockNumber;
 
 /// View onto block header rlp.

ethcore/src/views/transaction.rs

@@ -15,7 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! View onto transaction rlp
-use util::{Rlp, U256, Bytes, Hashable, H256, View};
+use util::{U256, Bytes, Hashable, H256};
+use rlp::{Rlp, View};
 
 /// View onto transaction rlp.
 pub struct TransactionView<'a> {

ipc/hypervisor/src/service.rs.in

@@ -42,7 +42,7 @@ pub struct ModuleState {
 
 #[derive(Ipc)]
 pub trait ControlService {
-	fn shutdown(&self);
+	fn shutdown(&self) -> bool;
 }
 
 #[derive(Ipc)]

ipc/rpc/src/binary.rs

@@ -16,7 +16,6 @@
 
 //! Binary representation of types
 
-use util::bytes::Populatable;
 use util::{U256, U512, H256, H2048, Address};
 use std::mem;
 use std::collections::{VecDeque, BTreeMap};
@@ -706,14 +705,21 @@ pub fn serialize<T: BinaryConvertable>(t: &T) -> Result<Vec<u8>, BinaryError> {
 #[macro_export]
 macro_rules! binary_fixed_size {
 	($target_ty: ty) => {
-		impl BinaryConvertable for $target_ty {
+		impl BinaryConvertable for $target_ty where $target_ty: Copy {
 			fn from_bytes(bytes: &[u8], _length_stack: &mut ::std::collections::VecDeque<usize>) -> Result<Self, BinaryConvertError> {
-				match bytes.len().cmp(&::std::mem::size_of::<$target_ty>()) {
+				let size = ::std::mem::size_of::<$target_ty>();
+				match bytes.len().cmp(&size) {
 					::std::cmp::Ordering::Equal => (),
-					_ => return Err(BinaryConvertError::size(::std::mem::size_of::<$target_ty>(), bytes.len())),
+					_ => return Err(BinaryConvertError::size(size, bytes.len())),
 				};
-				let mut res: Self = unsafe { ::std::mem::uninitialized() };
+				let res: Self = unsafe {
-				res.copy_raw(bytes);
+					let mut temp = ::std::mem::zeroed();
+					let temp_ptr = &mut temp as *mut _ as *mut u8;
+					::std::ptr::copy_nonoverlapping(bytes.as_ptr(), temp_ptr, size);
+
+					temp
+				};
+
 				Ok(res)
 			}
 
@@ -731,14 +737,14 @@ macro_rules! binary_fixed_size {
 }
 
 /// Fixed-sized version of Handshake struct
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct BinHandshake {
 	api_version: BinVersion,
 	protocol_version: BinVersion,
 }
 
 /// Shorten version of semver Version without `pre` and `build` information
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct BinVersion {
 	pub major: u64,
 	pub minor: u64,

parity/blockchain.rs

@@ -24,7 +24,8 @@ use std::sync::Arc;
 use rustc_serialize::hex::FromHex;
 use ethcore_logger::{setup_log, Config as LogConfig};
 use io::{PanicHandler, ForwardPanic};
-use util::{PayloadInfo, ToPretty};
+use util::ToPretty;
+use rlp::PayloadInfo;
 use ethcore::service::ClientService;
 use ethcore::client::{Mode, DatabaseCompactionProfile, Switch, VMType, BlockImportError, BlockChainClient, BlockID};
 use ethcore::error::ImportError;

parity/boot.rs

@@ -42,7 +42,7 @@ pub fn host_service<T: ?Sized + Send + Sync + 'static>(addr: &str, stop_guard: A
 		let mut worker = nanoipc::Worker::<T>::new(&service);
 		worker.add_reqrep(&socket_url).unwrap();
 
-		while !stop_guard.load(Ordering::Relaxed) {
+		while !stop_guard.load(Ordering::SeqCst) {
 			worker.poll();
 		}
 	});

parity/main.rs

@@ -26,12 +26,8 @@ extern crate docopt;
 extern crate num_cpus;
 extern crate rustc_serialize;
 extern crate ethcore_devtools as devtools;
-#[macro_use]
-extern crate ethcore_util as util;
 extern crate ethcore;
 extern crate ethsync;
-#[macro_use]
-extern crate log as rlog;
 extern crate env_logger;
 extern crate ethcore_logger;
 extern crate ctrlc;
@@ -43,8 +39,8 @@ extern crate semver;
 extern crate ethcore_io as io;
 extern crate ethcore_ipc as ipc;
 extern crate ethcore_ipc_nano as nanoipc;
-#[macro_use]
+extern crate rlp;
-extern crate hyper; // for price_info.rs
+
 extern crate json_ipc_server as jsonipc;
 
 extern crate ethcore_ipc_hypervisor as hypervisor;
@@ -52,11 +48,19 @@ extern crate ethcore_rpc;
 
 extern crate ethcore_signer;
 extern crate ansi_term;
-#[macro_use]
+
-extern crate lazy_static;
 extern crate regex;
 extern crate isatty;
 
+#[macro_use]
+extern crate ethcore_util as util;
+#[macro_use]
+extern crate log as rlog;
+#[macro_use]
+extern crate hyper; // for price_info.rs
+#[macro_use]
+extern crate lazy_static;
+
 #[cfg(feature="stratum")]
 extern crate ethcore_stratum;
 

parity/sync.rs

@@ -31,9 +31,10 @@ struct SyncControlService {
 }
 
 impl ControlService for SyncControlService {
-	fn shutdown(&self) {
+	fn shutdown(&self) -> bool {
 		trace!(target: "hypervisor", "Received shutdown from control service");
-		self.stop.store(true, ::std::sync::atomic::Ordering::Relaxed);
+		self.stop.store(true, ::std::sync::atomic::Ordering::SeqCst);
+		true
 	}
 }
 
@@ -75,14 +76,15 @@ pub fn main() {
 	let control_service = Arc::new(SyncControlService::default());
 	let as_control = control_service.clone() as Arc<ControlService>;
 	let mut worker = nanoipc::Worker::<ControlService>::new(&as_control);
+	let thread_stop = control_service.stop.clone();
 	worker.add_reqrep(
 		&service_urls::with_base(&service_config.io_path, service_urls::SYNC_CONTROL)
 	).unwrap();
 
-	while !control_service.stop.load(::std::sync::atomic::Ordering::Relaxed) {
+	while !thread_stop.load(::std::sync::atomic::Ordering::SeqCst) {
 		worker.poll();
 	}
-	service_stop.store(true, ::std::sync::atomic::Ordering::Relaxed);
+	service_stop.store(true, ::std::sync::atomic::Ordering::SeqCst);
 
 	hypervisor.module_shutdown(SYNC_MODULE_ID);
 	trace!(target: "hypervisor", "Sync process terminated gracefully");

rpc/Cargo.toml

@@ -23,6 +23,7 @@ ethash = { path = "../ethash" }
 ethsync = { path = "../sync" }
 ethjson = { path = "../json" }
 ethcore-devtools = { path = "../devtools" }
+rlp = { path = "../util/rlp" }
 rustc-serialize = "0.3"
 transient-hashmap = "0.1"
 serde_macros = { version = "0.8.0", optional = true }

rpc/src/lib.rs

@@ -19,15 +19,12 @@
 #![cfg_attr(feature="nightly", feature(custom_derive, custom_attribute, plugin))]
 #![cfg_attr(feature="nightly", plugin(serde_macros, clippy))]
 
-#[macro_use]
-extern crate log;
 extern crate rustc_serialize;
 extern crate serde;
 extern crate serde_json;
 extern crate jsonrpc_core;
 extern crate jsonrpc_http_server;
-#[macro_use]
+
-extern crate ethcore_util as util;
 extern crate ethcore_io as io;
 extern crate ethcore;
 extern crate ethkey;
@@ -37,6 +34,12 @@ extern crate transient_hashmap;
 extern crate json_ipc_server as ipc;
 extern crate ethcore_ipc;
 extern crate time;
+extern crate rlp;
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate ethcore_util as util;
 
 #[cfg(test)]
 extern crate ethjson;

rpc/src/v1/helpers/dispatch.rs

@@ -15,7 +15,6 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::{Address, H256, U256, Uint};
-use util::rlp::encode;
 use util::bytes::ToPretty;
 use ethcore::miner::MinerService;
 use ethcore::client::MiningBlockChainClient;
@@ -70,7 +69,7 @@ pub fn unlock_sign_and_dispatch<C, M>(client: &C, miner: &M, request: Transactio
 		t.with_signature(signature)
 	};
 
-	trace!(target: "miner", "send_transaction: dispatching tx: {}", encode(&signed_transaction).to_vec().pretty());
+	trace!(target: "miner", "send_transaction: dispatching tx: {}", ::rlp::encode(&signed_transaction).to_vec().pretty());
 	dispatch_transaction(&*client, &*miner, signed_transaction)
 }
 
@@ -84,7 +83,7 @@ pub fn sign_and_dispatch<C, M>(client: &C, miner: &M, request: TransactionReques
 		t.with_signature(signature)
 	};
 
-	trace!(target: "miner", "send_transaction: dispatching tx: {}", encode(&signed_transaction).to_vec().pretty());
+	trace!(target: "miner", "send_transaction: dispatching tx: {}", ::rlp::encode(&signed_transaction).to_vec().pretty());
 	dispatch_transaction(&*client, &*miner, signed_transaction)
 }
 

rpc/src/v1/impls/eth.rs

@@ -29,8 +29,8 @@ use ethcore::miner::{MinerService, ExternalMinerService};
 use jsonrpc_core::*;
 use util::{H256, Address, FixedHash, U256, H64, Uint};
 use util::sha3::*;
-use util::rlp::{encode, decode, UntrustedRlp, View};
 use util::{FromHex, Mutex};
+use rlp::{self, UntrustedRlp, View};
 use ethcore::account_provider::AccountProvider;
 use ethcore::client::{MiningBlockChainClient, BlockID, TransactionID, UncleID};
 use ethcore::header::Header as BlockHeader;
@@ -123,7 +123,7 @@ impl<C, S: ?Sized, M, EM> EthClient<C, S, M, EM> where
 					timestamp: view.timestamp().into(),
 					difficulty: view.difficulty().into(),
 					total_difficulty: total_difficulty.into(),
-					seal_fields: view.seal().into_iter().map(|f| decode(&f)).map(Bytes::new).collect(),
+					seal_fields: view.seal().into_iter().map(|f| rlp::decode(&f)).map(Bytes::new).collect(),
 					uncles: block_view.uncle_hashes().into_iter().map(Into::into).collect(),
 					transactions: match include_txs {
 						true => BlockTransactions::Full(block_view.localized_transactions().into_iter().map(Into::into).collect()),
@@ -147,7 +147,7 @@ impl<C, S: ?Sized, M, EM> EthClient<C, S, M, EM> where
 	fn uncle(&self, id: UncleID) -> Result<Value, Error> {
 		let client = take_weak!(self.client);
 		let uncle: BlockHeader = match client.uncle(id) {
-			Some(rlp) => decode(&rlp),
+			Some(rlp) => rlp::decode(&rlp),
 			None => { return Ok(Value::Null); }
 		};
 		let parent_difficulty = match client.block_total_difficulty(BlockID::Hash(uncle.parent_hash().clone())) {
@@ -173,7 +173,7 @@ impl<C, S: ?Sized, M, EM> EthClient<C, S, M, EM> where
 			total_difficulty: (uncle.difficulty().clone() + parent_difficulty).into(),
 			receipts_root: uncle.receipts_root().clone().into(),
 			extra_data: uncle.extra_data().clone().into(),
-			seal_fields: uncle.seal().clone().into_iter().map(|f| decode(&f)).map(Bytes::new).collect(),
+			seal_fields: uncle.seal().clone().into_iter().map(|f| rlp::decode(&f)).map(Bytes::new).collect(),
 			uncles: vec![],
 			transactions: BlockTransactions::Hashes(vec![]),
 		};
@@ -566,7 +566,7 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
 			trace!(target: "miner", "submit_work: Decoded: nonce={}, pow_hash={}, mix_hash={}", nonce, pow_hash, mix_hash);
 			let miner = take_weak!(self.miner);
 			let client = take_weak!(self.client);
-			let seal = vec![encode(&mix_hash).to_vec(), encode(&nonce).to_vec()];
+			let seal = vec![rlp::encode(&mix_hash).to_vec(), rlp::encode(&nonce).to_vec()];
 			let r = miner.submit_seal(&*client, pow_hash, seal);
 			Ok(to_value(&r.is_ok()))
 		})

rpc/src/v1/impls/traces.rs

@@ -18,7 +18,7 @@
 
 use std::sync::{Weak, Arc};
 use jsonrpc_core::*;
-use util::rlp::{UntrustedRlp, View};
+use rlp::{UntrustedRlp, View};
 use ethcore::client::{BlockChainClient, CallAnalytics, TransactionID, TraceId};
 use ethcore::miner::MinerService;
 use ethcore::transaction::{Transaction as EthTransaction, SignedTransaction, Action};

rpc/src/v1/tests/eth.rs

@@ -156,7 +156,7 @@ fn eth_get_balance() {
 		"params": ["0xaaaf5374fce5edbc8e2a8697c15331677e6ebaaa", "latest"],
 		"id": 1
 	}"#;
-	let res_latest = r#"{"jsonrpc":"2.0","result":"0x09","id":1}"#.to_owned();
+	let res_latest = r#"{"jsonrpc":"2.0","result":"0x9","id":1}"#.to_owned();
 	assert_eq!(tester.handler.handle_request_sync(req_latest).unwrap(), res_latest);
 
 	// non-existant account
@@ -167,7 +167,7 @@ fn eth_get_balance() {
 		"id": 3
 	}"#;
 
-	let res_new_acc = r#"{"jsonrpc":"2.0","result":"0x00","id":3}"#.to_owned();
+	let res_new_acc = r#"{"jsonrpc":"2.0","result":"0x0","id":3}"#.to_owned();
 	assert_eq!(tester.handler.handle_request_sync(req_new_acc).unwrap(), res_new_acc);
 }
 
@@ -297,7 +297,7 @@ fn eth_transaction_count() {
 		"id": 15
 	}"#;
 
-	let res_before = r#"{"jsonrpc":"2.0","result":"0x00","id":15}"#;
+	let res_before = r#"{"jsonrpc":"2.0","result":"0x0","id":15}"#;
 
 	assert_eq!(tester.handler.handle_request_sync(&req_before).unwrap(), res_before);
 
@@ -308,7 +308,7 @@ fn eth_transaction_count() {
 			"from": ""#.to_owned() + format!("0x{:?}", address).as_ref() + r#"",
 			"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
 			"gas": "0x30000",
-			"gasPrice": "0x01",
+			"gasPrice": "0x1",
 			"value": "0x9184e72a"
 		}],
 		"id": 16
@@ -325,7 +325,7 @@ fn eth_transaction_count() {
 		"id": 17
 	}"#;
 
-	let res_after_latest = r#"{"jsonrpc":"2.0","result":"0x00","id":17}"#;
+	let res_after_latest = r#"{"jsonrpc":"2.0","result":"0x0","id":17}"#;
 
 	assert_eq!(&tester.handler.handle_request_sync(&req_after_latest).unwrap(), res_after_latest);
 
@@ -337,7 +337,7 @@ fn eth_transaction_count() {
 		"id": 18
 	}"#;
 
-	let res_after_pending = r#"{"jsonrpc":"2.0","result":"0x01","id":18}"#;
+	let res_after_pending = r#"{"jsonrpc":"2.0","result":"0x1","id":18}"#;
 
 	assert_eq!(&tester.handler.handle_request_sync(&req_after_pending).unwrap(), res_after_pending);
 }
@@ -365,7 +365,7 @@ fn verify_transaction_counts(name: String, chain: BlockChain) {
 		}"#;
 
 		let res = r#"{"jsonrpc":"2.0","result":""#.to_owned()
-			+ format!("0x{:02x}", count).as_ref()
+			+ format!("0x{:x}", count).as_ref()
 			+ r#"","id":"#
 			+ format!("{}", *id).as_ref() + r#"}"#;
 		*id += 1;
@@ -383,7 +383,7 @@ fn verify_transaction_counts(name: String, chain: BlockChain) {
 		}"#;
 
 		let res = r#"{"jsonrpc":"2.0","result":""#.to_owned()
-			+ format!("0x{:02x}", count).as_ref()
+			+ format!("0x{:x}", count).as_ref()
 			+ r#"","id":"#
 			+ format!("{}", *id).as_ref() + r#"}"#;
 		*id += 1;
@@ -425,7 +425,7 @@ fn starting_nonce_test() {
 		"#)
 	).unwrap();
 
-	assert_eq!(r#"{"jsonrpc":"2.0","result":"0x0100","id":15}"#, &sample);
+	assert_eq!(r#"{"jsonrpc":"2.0","result":"0x100","id":15}"#, &sample);
 }
 
 register_test!(eth_transaction_count_1, verify_transaction_counts, "BlockchainTests/bcWalletTest");

rpc/src/v1/tests/mocked/eth.rs

@@ -122,7 +122,7 @@ fn rpc_eth_syncing() {
 		}
 	}
 
-	let true_res = r#"{"jsonrpc":"2.0","result":{"currentBlock":"0x03e8","highestBlock":"0x09c4","startingBlock":"0x00"},"id":1}"#;
+	let true_res = r#"{"jsonrpc":"2.0","result":{"currentBlock":"0x3e8","highestBlock":"0x9c4","startingBlock":"0x0"},"id":1}"#;
 	assert_eq!(tester.io.handle_request_sync(request), Some(true_res.to_owned()));
 
 	{
@@ -226,7 +226,7 @@ fn rpc_eth_mining() {
 #[test]
 fn rpc_eth_gas_price() {
 	let request = r#"{"jsonrpc": "2.0", "method": "eth_gasPrice", "params": [], "id": 1}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x04a817c800","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x4a817c800","id":1}"#;
 
 	assert_eq!(EthTester::default().io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -248,7 +248,7 @@ fn rpc_eth_block_number() {
 	tester.client.add_blocks(10, EachBlockWith::Nothing);
 
 	let request = r#"{"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x0a","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0xa","id":1}"#;
 
 	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -264,7 +264,7 @@ fn rpc_eth_balance() {
 		"params": ["0x0000000000000000000000000000000000000001", "latest"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x05","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x5","id":1}"#;
 
 	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -284,7 +284,7 @@ fn rpc_eth_balance_pending() {
 	// the TestMinerService doesn't communicate with the the TestBlockChainClient in any way.
 	// if this returns zero, we know that the "pending" call is being properly forwarded to the
 	// miner.
-	let response = r#"{"jsonrpc":"2.0","result":"0x00","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x0","id":1}"#;
 
 	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -313,7 +313,7 @@ fn rpc_eth_transaction_count() {
 		"params": ["0x0000000000000000000000000000000000000001", "latest"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x00","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x0","id":1}"#;
 
 	assert_eq!(EthTester::default().io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -339,7 +339,7 @@ fn rpc_eth_transaction_count_by_number() {
 		"params": ["latest"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x00","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x0","id":1}"#;
 
 	assert_eq!(EthTester::default().io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -352,7 +352,7 @@ fn rpc_eth_transaction_count_by_number_pending() {
 		"params": ["pending"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x01","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x1","id":1}"#;
 
 	assert_eq!(EthTester::default().io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -364,11 +364,11 @@ fn rpc_eth_pending_transaction_by_hash() {
 
 	let tester = EthTester::default();
 	{
-		let tx: SignedTransaction = decode(&FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
+		let tx: SignedTransaction = ::rlp::decode(&FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
 		tester.miner.pending_transactions.lock().insert(H256::zero(), tx);
 	}
 
-	let response = r#"{"jsonrpc":"2.0","result":{"blockHash":null,"blockNumber":null,"creates":null,"from":"0x0f65fe9276bc9a24ae7083ae28e2660ef72df99e","gas":"0x5208","gasPrice":"0x01","hash":"0x41df922fd0d4766fcc02e161f8295ec28522f329ae487f14d811e4b64c8d6e31","input":"0x","nonce":"0x00","raw":"0xf85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804","to":"0x095e7baea6a6c7c4c2dfeb977efac326af552d87","transactionIndex":null,"value":"0x0a"},"id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":{"blockHash":null,"blockNumber":null,"creates":null,"from":"0x0f65fe9276bc9a24ae7083ae28e2660ef72df99e","gas":"0x5208","gasPrice":"0x1","hash":"0x41df922fd0d4766fcc02e161f8295ec28522f329ae487f14d811e4b64c8d6e31","input":"0x","nonce":"0x0","raw":"0xf85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804","to":"0x095e7baea6a6c7c4c2dfeb977efac326af552d87","transactionIndex":null,"value":"0xa"},"id":1}"#;
 	let request = r#"{
 		"jsonrpc": "2.0",
 		"method": "eth_getTransactionByHash",
@@ -400,7 +400,7 @@ fn rpc_eth_uncle_count_by_block_number() {
 		"params": ["latest"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x00","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x0","id":1}"#;
 
 	assert_eq!(EthTester::default().io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -705,7 +705,7 @@ fn rpc_eth_send_raw_transaction() {
 	let signature = tester.accounts_provider.sign(address, t.hash()).unwrap();
 	let t = t.with_signature(signature);
 
-	let rlp = ::util::rlp::encode(&t).to_vec().to_hex();
+	let rlp = ::rlp::encode(&t).to_vec().to_hex();
 
 	let req = r#"{
 		"jsonrpc": "2.0",
@@ -758,7 +758,7 @@ fn rpc_eth_transaction_receipt() {
 		"params": ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":{"blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x04510c","contractAddress":null,"cumulativeGasUsed":"0x20","gasUsed":"0x10","logs":[{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x04510c","data":"0x","logIndex":"0x01","topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x00","type":"mined"}],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x00"},"id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":{"blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","contractAddress":null,"cumulativeGasUsed":"0x20","gasUsed":"0x10","logs":[{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","data":"0x","logIndex":"0x1","topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","type":"mined"}],"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0"},"id":1}"#;
 
 	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -835,7 +835,7 @@ fn rpc_get_work_returns_correct_work_package() {
 	eth_tester.miner.set_author(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap());
 
 	let request = r#"{"jsonrpc": "2.0", "method": "eth_getWork", "params": [], "id": 1}"#;
-	let response = r#"{"jsonrpc":"2.0","result":["0x3bbe93f74e7b97ae00784aeff8819c5cb600dd87e8b282a5d3446f3f871f0347","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x01"],"id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":["0x3bbe93f74e7b97ae00784aeff8819c5cb600dd87e8b282a5d3446f3f871f0347","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x1"],"id":1}"#;
 
 	assert_eq!(eth_tester.io.handle_request_sync(request), Some(response.to_owned()));
 }
@@ -864,7 +864,7 @@ fn rpc_get_work_should_timeout() {
 	// Request without providing timeout. This should work since we're disabling timeout.
 	let request = r#"{"jsonrpc": "2.0", "method": "eth_getWork", "params": [], "id": 1}"#;
 	let work_response = format!(
-		r#"{{"jsonrpc":"2.0","result":["0x{:?}","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x01"],"id":1}}"#,
+		r#"{{"jsonrpc":"2.0","result":["0x{:?}","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x1"],"id":1}}"#,
 		hash,
 	);
 	assert_eq!(eth_tester.io.handle_request_sync(request), Some(work_response.to_owned()));
@@ -872,7 +872,7 @@ fn rpc_get_work_should_timeout() {
 	// Request with timeout of 0 seconds. This should work since we're disabling timeout.
 	let request = r#"{"jsonrpc": "2.0", "method": "eth_getWork", "params": ["0"], "id": 1}"#;
 	let work_response = format!(
-		r#"{{"jsonrpc":"2.0","result":["0x{:?}","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x01"],"id":1}}"#,
+		r#"{{"jsonrpc":"2.0","result":["0x{:?}","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000800000000000000000000000000000000000000000000000000000000000","0x1"],"id":1}}"#,
 		hash,
 	);
 	assert_eq!(eth_tester.io.handle_request_sync(request), Some(work_response.to_owned()));

rpc/src/v1/tests/mocked/eth_signing.rs

@@ -104,7 +104,7 @@ fn should_post_sign_to_queue() {
 		],
 		"id": 1
 	}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x01","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x1","id":1}"#;
 
 	// then
 	assert_eq!(tester.io.handle_request_sync(&request), Some(response.to_owned()));

rpc/src/v1/tests/mocked/ethcore.rs

@@ -126,7 +126,7 @@ fn rpc_ethcore_min_gas_price() {
 	io.add_delegate(ethcore_client(&client, &miner, &sync, &net).to_delegate());
 
 	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_minGasPrice", "params": [], "id": 1}"#;
-	let response = r#"{"jsonrpc":"2.0","result":"0x01312d00","id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":"0x1312d00","id":1}"#;
 
 	assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
 }

rpc/src/v1/tests/mocked/personal_signer.rs

@@ -86,8 +86,8 @@ fn should_return_list_of_items_to_confirm() {
 	let request = r#"{"jsonrpc":"2.0","method":"personal_requestsToConfirm","params":[],"id":1}"#;
 	let response = concat!(
 		r#"{"jsonrpc":"2.0","result":["#,
-		r#"{"id":"0x01","payload":{"transaction":{"data":"0x","from":"0x0000000000000000000000000000000000000001","gas":"0x989680","gasPrice":"0x2710","nonce":null,"to":"0xd46e8dd67c5d32be8058bb8eb970870f07244567","value":"0x01"}}},"#,
+		r#"{"id":"0x1","payload":{"transaction":{"data":"0x","from":"0x0000000000000000000000000000000000000001","gas":"0x989680","gasPrice":"0x2710","nonce":null,"to":"0xd46e8dd67c5d32be8058bb8eb970870f07244567","value":"0x1"}}},"#,
-		r#"{"id":"0x02","payload":{"sign":{"address":"0x0000000000000000000000000000000000000001","hash":"0x0000000000000000000000000000000000000000000000000000000000000005"}}}"#,
+		r#"{"id":"0x2","payload":{"sign":{"address":"0x0000000000000000000000000000000000000001","hash":"0x0000000000000000000000000000000000000000000000000000000000000005"}}}"#,
 		r#"],"id":1}"#
 	);
 
@@ -112,7 +112,7 @@ fn should_reject_transaction_from_queue_without_dispatching() {
 	assert_eq!(tester.queue.requests().len(), 1);
 
 	// when
-	let request = r#"{"jsonrpc":"2.0","method":"personal_rejectRequest","params":["0x01"],"id":1}"#;
+	let request = r#"{"jsonrpc":"2.0","method":"personal_rejectRequest","params":["0x1"],"id":1}"#;
 	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
 
 	// then
@@ -137,7 +137,7 @@ fn should_not_remove_transaction_if_password_is_invalid() {
 	assert_eq!(tester.queue.requests().len(), 1);
 
 	// when
-	let request = r#"{"jsonrpc":"2.0","method":"personal_confirmRequest","params":["0x01",{},"xxx"],"id":1}"#;
+	let request = r#"{"jsonrpc":"2.0","method":"personal_confirmRequest","params":["0x1",{},"xxx"],"id":1}"#;
 	let response = r#"{"jsonrpc":"2.0","error":{"code":-32021,"message":"Account password is invalid or account does not exist.","data":"SStore(InvalidAccount)"},"id":1}"#;
 
 	// then
@@ -153,7 +153,7 @@ fn should_not_remove_sign_if_password_is_invalid() {
 	assert_eq!(tester.queue.requests().len(), 1);
 
 	// when
-	let request = r#"{"jsonrpc":"2.0","method":"personal_confirmRequest","params":["0x01",{},"xxx"],"id":1}"#;
+	let request = r#"{"jsonrpc":"2.0","method":"personal_confirmRequest","params":["0x1",{},"xxx"],"id":1}"#;
 	let response = r#"{"jsonrpc":"2.0","error":{"code":-32021,"message":"Account password is invalid or account does not exist.","data":"SStore(InvalidAccount)"},"id":1}"#;
 
 	// then
@@ -195,7 +195,7 @@ fn should_confirm_transaction_and_dispatch() {
 	let request = r#"{
 		"jsonrpc":"2.0",
 		"method":"personal_confirmRequest",
-		"params":["0x01", {"gasPrice":"0x1000"}, "test"],
+		"params":["0x1", {"gasPrice":"0x1000"}, "test"],
 		"id":1
 	}"#;
 	let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#;

rpc/src/v1/types/block.rs

@@ -103,7 +103,7 @@ mod tests {
 	fn test_serialize_block_transactions() {
 		let t = BlockTransactions::Full(vec![Transaction::default()]);
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"[{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x00","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x00","gasPrice":"0x00","gas":"0x00","input":"0x","creates":null,"raw":"0x"}]"#);
+		assert_eq!(serialized, r#"[{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x0","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x0","gasPrice":"0x0","gas":"0x0","input":"0x","creates":null,"raw":"0x"}]"#);
 
 		let t = BlockTransactions::Hashes(vec![H256::default().into()]);
 		let serialized = serde_json::to_string(&t).unwrap();
@@ -136,6 +136,6 @@ mod tests {
 		};
 
 		let serialized = serde_json::to_string(&block).unwrap();
-		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000","author":"0x0000000000000000000000000000000000000000","miner":"0x0000000000000000000000000000000000000000","stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","number":"0x00","gasUsed":"0x00","gasLimit":"0x00","extraData":"0x","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","timestamp":"0x00","difficulty":"0x00","totalDifficulty":"0x00","sealFields":["0x","0x"],"uncles":[],"transactions":[],"size":"0x45"}"#);
+		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000","author":"0x0000000000000000000000000000000000000000","miner":"0x0000000000000000000000000000000000000000","stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","number":"0x0","gasUsed":"0x0","gasLimit":"0x0","extraData":"0x","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","timestamp":"0x0","difficulty":"0x0","totalDifficulty":"0x0","sealFields":["0x","0x"],"uncles":[],"transactions":[],"size":"0x45"}"#);
 	}
 }

rpc/src/v1/types/confirmations.rs

@@ -96,7 +96,7 @@ mod tests {
 
 		// when
 		let res = serde_json::to_string(&ConfirmationRequest::from(request));
-		let expected = r#"{"id":"0x0f","payload":{"sign":{"address":"0x0000000000000000000000000000000000000001","hash":"0x0000000000000000000000000000000000000000000000000000000000000005"}}}"#;
+		let expected = r#"{"id":"0xf","payload":{"sign":{"address":"0x0000000000000000000000000000000000000001","hash":"0x0000000000000000000000000000000000000000000000000000000000000005"}}}"#;
 
 		// then
 		assert_eq!(res.unwrap(), expected.to_owned());
@@ -120,7 +120,7 @@ mod tests {
 
 		// when
 		let res = serde_json::to_string(&ConfirmationRequest::from(request));
-		let expected = r#"{"id":"0x0f","payload":{"transaction":{"from":"0x0000000000000000000000000000000000000000","to":null,"gasPrice":"0x2710","gas":"0x3a98","value":"0x0186a0","data":"0x010203","nonce":"0x01"}}}"#;
+		let expected = r#"{"id":"0xf","payload":{"transaction":{"from":"0x0000000000000000000000000000000000000000","to":null,"gasPrice":"0x2710","gas":"0x3a98","value":"0x186a0","data":"0x010203","nonce":"0x1"}}}"#;
 
 		// then
 		assert_eq!(res.unwrap(), expected.to_owned());
@@ -130,7 +130,7 @@ mod tests {
 	fn should_deserialize_modification() {
 		// given
 		let s1 = r#"{
-			"gasPrice":"0x0ba43b7400"
+			"gasPrice":"0xba43b7400"
 		}"#;
 		let s2 = r#"{}"#;
 

rpc/src/v1/types/log.rs

@@ -86,7 +86,7 @@ mod tests {
 
 	#[test]
 	fn log_serialization() {
-		let s = r#"{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"data":"0x","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x04510c","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x00","logIndex":"0x01","type":"mined"}"#;
+		let s = r#"{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"data":"0x","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","logIndex":"0x1","type":"mined"}"#;
 
 		let log = Log {
 			address: H160::from_str("33990122638b9132ca29c723bdf037f1a891a70c").unwrap(),

rpc/src/v1/types/receipt.rs

@@ -98,7 +98,7 @@ mod tests {
 
 	#[test]
 	fn receipt_serialization() {
-		let s = r#"{"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x00","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x04510c","cumulativeGasUsed":"0x20","gasUsed":"0x10","contractAddress":null,"logs":[{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"data":"0x","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x04510c","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x00","logIndex":"0x01","type":"mined"}]}"#;
+		let s = r#"{"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","cumulativeGasUsed":"0x20","gasUsed":"0x10","contractAddress":null,"logs":[{"address":"0x33990122638b9132ca29c723bdf037f1a891a70c","topics":["0xa6697e974e6a320f454390be03f74955e8978f1a6971ea6730542e37b66179bc","0x4861736852656700000000000000000000000000000000000000000000000000"],"data":"0x","blockHash":"0xed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5","blockNumber":"0x4510c","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","logIndex":"0x1","type":"mined"}]}"#;
 
 		let receipt = Receipt {
 			transaction_hash: Some(H256::from(0)),

rpc/src/v1/types/sync.rs

@@ -70,7 +70,7 @@ mod tests {
 	fn test_serialize_sync_info() {
 		let t = SyncInfo::default();
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"startingBlock":"0x00","currentBlock":"0x00","highestBlock":"0x00"}"#);
+		assert_eq!(serialized, r#"{"startingBlock":"0x0","currentBlock":"0x0","highestBlock":"0x0"}"#);
 	}
 
 	#[test]
@@ -88,6 +88,6 @@ mod tests {
 
 		let t = SyncStatus::Info(SyncInfo::default());
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"startingBlock":"0x00","currentBlock":"0x00","highestBlock":"0x00"}"#);
+		assert_eq!(serialized, r#"{"startingBlock":"0x0","currentBlock":"0x0","highestBlock":"0x0"}"#);
 	}
 }

rpc/src/v1/types/trace.rs

@@ -549,7 +549,7 @@ mod tests {
 			block_hash: H256::from(14),
 		};
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"action":{"call":{"from":"0x0000000000000000000000000000000000000004","to":"0x0000000000000000000000000000000000000005","value":"0x06","gas":"0x07","input":"0x1234","callType":"call"}},"result":{"call":{"gasUsed":"0x08","output":"0x5678"}},"traceAddress":["0x0a"],"subtraces":"0x01","transactionPosition":"0x0b","transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":"0x0d","blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
+		assert_eq!(serialized, r#"{"action":{"call":{"from":"0x0000000000000000000000000000000000000004","to":"0x0000000000000000000000000000000000000005","value":"0x6","gas":"0x7","input":"0x1234","callType":"call"}},"result":{"call":{"gasUsed":"0x8","output":"0x5678"}},"traceAddress":["0xa"],"subtraces":"0x1","transactionPosition":"0xb","transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":"0xd","blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
 	}
 
 	#[test]
@@ -614,7 +614,7 @@ mod tests {
 			}
 		]);
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"0x000000000000000000000000000000000000002a":{"balance":"=","nonce":{"+":"0x01"},"code":"=","storage":{"0x000000000000000000000000000000000000000000000000000000000000002a":"="}},"0x0000000000000000000000000000000000000045":{"balance":"=","nonce":{"*":{"from":"0x01","to":"0x00"}},"code":{"-":"0x60"},"storage":{}}}"#);
+		assert_eq!(serialized, r#"{"0x000000000000000000000000000000000000002a":{"balance":"=","nonce":{"+":"0x1"},"code":"=","storage":{"0x000000000000000000000000000000000000000000000000000000000000002a":"="}},"0x0000000000000000000000000000000000000045":{"balance":"=","nonce":{"*":{"from":"0x1","to":"0x0"}},"code":{"-":"0x60"},"storage":{}}}"#);
 	}
 
 	#[test]
@@ -634,7 +634,7 @@ mod tests {
 		})];
 
 		let serialized = serde_json::to_string(&actions).unwrap();
-		assert_eq!(serialized, r#"[{"call":{"from":"0x0000000000000000000000000000000000000001","to":"0x0000000000000000000000000000000000000002","value":"0x03","gas":"0x04","input":"0x1234","callType":"call"}},{"create":{"from":"0x0000000000000000000000000000000000000005","value":"0x06","gas":"0x07","init":"0x5678"}}]"#);
+		assert_eq!(serialized, r#"[{"call":{"from":"0x0000000000000000000000000000000000000001","to":"0x0000000000000000000000000000000000000002","value":"0x3","gas":"0x4","input":"0x1234","callType":"call"}},{"create":{"from":"0x0000000000000000000000000000000000000005","value":"0x6","gas":"0x7","init":"0x5678"}}]"#);
 	}
 
 	#[test]
@@ -654,6 +654,6 @@ mod tests {
 		];
 
 		let serialized = serde_json::to_string(&results).unwrap();
-		assert_eq!(serialized, r#"[{"call":{"gasUsed":"0x01","output":"0x1234"}},{"create":{"gasUsed":"0x02","code":"0x4556","address":"0x0000000000000000000000000000000000000003"}},"failedCall","failedCreate"]"#);
+		assert_eq!(serialized, r#"[{"call":{"gasUsed":"0x1","output":"0x1234"}},{"create":{"gasUsed":"0x2","code":"0x4556","address":"0x0000000000000000000000000000000000000003"}},"failedCall","failedCreate"]"#);
 	}
 }

rpc/src/v1/types/transaction.rs

@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use util::rlp::encode;
 use ethcore::contract_address;
 use ethcore::transaction::{LocalizedTransaction, Action, SignedTransaction};
 use v1::types::{Bytes, H160, H256, U256};
@@ -75,7 +74,7 @@ impl From<LocalizedTransaction> for Transaction {
 				Action::Create => Some(contract_address(&t.sender().unwrap(), &t.nonce).into()),
 				Action::Call(_) => None,
 			},
-			raw: encode(&t.signed).to_vec().into(),
+			raw: ::rlp::encode(&t.signed).to_vec().into(),
 		}
 	}
 }
@@ -101,7 +100,7 @@ impl From<SignedTransaction> for Transaction {
 				Action::Create => Some(contract_address(&t.sender().unwrap(), &t.nonce).into()),
 				Action::Call(_) => None,
 			},
-			raw: encode(&t).to_vec().into(),
+			raw: ::rlp::encode(&t).to_vec().into(),
 		}
 	}
 }
@@ -115,7 +114,7 @@ mod tests {
 	fn test_transaction_serialize() {
 		let t = Transaction::default();
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x00","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x00","gasPrice":"0x00","gas":"0x00","input":"0x","creates":null,"raw":"0x"}"#);
+		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x0","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x0","gasPrice":"0x0","gas":"0x0","input":"0x","creates":null,"raw":"0x"}"#);
 	}
 }
 

rpc/src/v1/types/uint.rs

@@ -52,7 +52,13 @@ macro_rules! impl_uint {
 				let mut bytes = [0u8; 8 * $size];
 				self.0.to_big_endian(&mut bytes);
 				let len = cmp::max((self.0.bits() + 7) / 8, 1);
-				hex.push_str(&bytes[bytes.len() - len..].to_hex());
+				let bytes_hex = bytes[bytes.len() - len..].to_hex();
+
+				if bytes_hex.starts_with('0') {
+					hex.push_str(&bytes_hex[1..]);
+				} else {
+					hex.push_str(&bytes_hex);
+				}
 				serializer.serialize_str(&hex)
 			}
 		}
@@ -87,3 +93,38 @@ macro_rules! impl_uint {
 }
 
 impl_uint!(U256, EthU256, 4);
+
+
+#[cfg(test)]
+mod tests {
+	use super::U256;
+	use serde_json;
+
+	#[test]
+	fn should_serialize_u256() {
+		let serialized1 = serde_json::to_string(&U256(0.into())).unwrap();
+		let serialized2 = serde_json::to_string(&U256(1.into())).unwrap();
+		let serialized3 = serde_json::to_string(&U256(16.into())).unwrap();
+		let serialized4 = serde_json::to_string(&U256(256.into())).unwrap();
+
+		assert_eq!(serialized1, r#""0x0""#);
+		assert_eq!(serialized2, r#""0x1""#);
+		assert_eq!(serialized3, r#""0x10""#);
+		assert_eq!(serialized4, r#""0x100""#);
+	}
+
+	#[test]
+	fn should_deserialize_u256() {
+		let deserialized1: U256 = serde_json::from_str(r#""0x""#).unwrap();
+		let deserialized2: U256 = serde_json::from_str(r#""0x0""#).unwrap();
+		let deserialized3: U256 = serde_json::from_str(r#""0x1""#).unwrap();
+		let deserialized4: U256 = serde_json::from_str(r#""0x01""#).unwrap();
+		let deserialized5: U256 = serde_json::from_str(r#""0x100""#).unwrap();
+
+		assert_eq!(deserialized1, U256(0.into()));
+		assert_eq!(deserialized2, U256(0.into()));
+		assert_eq!(deserialized3, U256(1.into()));
+		assert_eq!(deserialized4, U256(1.into()));
+		assert_eq!(deserialized5, U256(256.into()));
+	}
+}

scripts/targets.sh

@@ -2,6 +2,7 @@
 
 export TARGETS="
 	-p bigint\
+	-p rlp\
 	-p ethash \
 	-p ethcore \
 	-p ethcore-dapps \

sync/Cargo.toml

@@ -16,6 +16,7 @@ ethcore-util = { path = "../util" }
 ethcore-network = { path = "../util/network" }
 ethcore-io = { path = "../util/io" }
 ethcore = { path = "../ethcore" }
+rlp = { path = "../util/rlp" }
 clippy = { version = "0.0.85", optional = true}
 log = "0.3"
 env_logger = "0.3"

sync/src/api.rs

@@ -17,7 +17,7 @@
 use std::sync::Arc;
 use network::{NetworkProtocolHandler, NetworkService, NetworkContext, PeerId,
 	NetworkConfiguration as BasicNetworkConfiguration, NonReservedPeerMode, NetworkError};
-use util::{U256, H256, Populatable};
+use util::{U256, H256};
 use io::{TimerToken};
 use ethcore::client::{BlockChainClient, ChainNotify};
 use ethcore::header::BlockNumber;
@@ -32,7 +32,7 @@ use parking_lot::RwLock;
 pub const ETH_PROTOCOL: &'static str = "eth";
 
 /// Sync configuration
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct SyncConfig {
 	/// Max blocks to download ahead
 	pub max_download_ahead_blocks: usize,
@@ -119,6 +119,7 @@ impl NetworkProtocolHandler for SyncProtocolHandler {
 	fn timeout(&self, io: &NetworkContext, _timer: TimerToken) {
 		self.sync.write().maintain_peers(&mut NetSyncIo::new(io, &*self.chain));
 		self.sync.write().maintain_sync(&mut NetSyncIo::new(io, &*self.chain));
+		self.sync.write().propagate_new_transactions(&mut NetSyncIo::new(io, &*self.chain));
 	}
 }
 

sync/src/blocks.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
+use rlp::*;
 use network::NetworkError;
 use ethcore::header::{ Header as BlockHeader};
 
@@ -283,11 +284,11 @@ impl BlockCollection {
 			transactions_root: info.transactions_root().clone(),
 			uncles: info.uncles_hash().clone(),
 		};
-		if header_id.transactions_root == rlp::SHA3_NULL_RLP && header_id.uncles == rlp::SHA3_EMPTY_LIST_RLP {
+		if header_id.transactions_root == sha3::SHA3_NULL_RLP && header_id.uncles == sha3::SHA3_EMPTY_LIST_RLP {
 			// empty body, just mark as downloaded
 			let mut body_stream = RlpStream::new_list(2);
-			body_stream.append_raw(&rlp::EMPTY_LIST_RLP, 1);
+			body_stream.append_raw(&::rlp::EMPTY_LIST_RLP, 1);
-			body_stream.append_raw(&rlp::EMPTY_LIST_RLP, 1);
+			body_stream.append_raw(&::rlp::EMPTY_LIST_RLP, 1);
 			block.body = Some(body_stream.out());
 		}
 		else {
@@ -337,6 +338,7 @@ mod test {
 	use ethcore::views::HeaderView;
 	use ethcore::header::BlockNumber;
 	use util::*;
+	use rlp::*;
 
 	fn is_empty(bc: &BlockCollection) -> bool {
 		bc.heads.is_empty() &&

sync/src/chain.rs

@@ -88,6 +88,7 @@
 ///
 
 use util::*;
+use rlp::*;
 use network::*;
 use std::mem::{replace};
 use ethcore::views::{HeaderView, BlockView};
@@ -156,7 +157,7 @@ pub enum SyncState {
 }
 
 /// Syncing status and statistics
-#[derive(Clone)]
+#[derive(Clone, Copy)]
 pub struct SyncStatus {
 	/// State
 	pub state: SyncState,
@@ -241,7 +242,9 @@ struct PeerInfo {
 	asking_hash: Option<H256>,
 	/// Request timestamp
 	ask_time: f64,
-	/// Pending request is expird and result should be ignored
+	/// Holds a set of transactions recently sent to this peer to avoid spamming.
+	last_sent_transactions: HashSet<H256>,
+	/// Pending request is expired and result should be ignored
 	expired: bool,
 	/// Peer fork confirmation status
 	confirmation: ForkConfirmation,
@@ -406,6 +409,7 @@ impl ChainSync {
 			asking_blocks: Vec::new(),
 			asking_hash: None,
 			ask_time: 0f64,
+			last_sent_transactions: HashSet::new(),
 			expired: false,
 			confirmation: if self.fork_block.is_none() { ForkConfirmation::Confirmed } else { ForkConfirmation::Unconfirmed },
 		};
@@ -1447,42 +1451,65 @@ impl ChainSync {
 	}
 
 	/// propagates new transactions to all peers
-	fn propagate_new_transactions(&mut self, io: &mut SyncIo) -> usize {
+	pub fn propagate_new_transactions(&mut self, io: &mut SyncIo) -> usize {
 
 		// Early out of nobody to send to.
 		if self.peers.is_empty() {
 			return 0;
 		}
 
-		let mut transactions = io.chain().pending_transactions();
+		let transactions = io.chain().pending_transactions();
 		if transactions.is_empty() {
 			return 0;
 		}
 
-		let mut packet = RlpStream::new_list(transactions.len());
+		let all_transactions_hashes = transactions.iter().map(|ref tx| tx.hash()).collect::<HashSet<H256>>();
-		let tx_count = transactions.len();
+		let all_transactions_rlp = {
-		for tx in transactions.drain(..) {
+			let mut packet = RlpStream::new_list(transactions.len());
-			packet.append(&tx);
+			for tx in &transactions { packet.append(tx); }
-		}
+			packet.out()
-		let rlp = packet.out();
-
-		let lucky_peers = {
-			// sqrt(x)/x scaled to max u32
-			let fraction = (self.peers.len() as f64).powf(-0.5).mul(u32::max_value() as f64).round() as u32;
-			let small = self.peers.len() < MIN_PEERS_PROPAGATION;
-			let lucky_peers = self.peers.iter()
-				.filter_map(|(&p, _)| if small || ::rand::random::<u32>() < fraction { Some(p.clone()) } else { None })
-				.collect::<Vec<_>>();
-
-			// taking at max of MAX_PEERS_PROPAGATION
-			lucky_peers.iter().cloned().take(min(lucky_peers.len(), MAX_PEERS_PROPAGATION)).collect::<Vec<PeerId>>()
 		};
 
+		// sqrt(x)/x scaled to max u32
+		let fraction = (self.peers.len() as f64).powf(-0.5).mul(u32::max_value() as f64).round() as u32;
+		let small = self.peers.len() < MIN_PEERS_PROPAGATION;
+
+		let lucky_peers = self.peers.iter_mut()
+			.filter(|_| small || ::rand::random::<u32>() < fraction)
+			.take(MAX_PEERS_PROPAGATION)
+			.filter_map(|(peer_id, mut peer_info)| {
+				// Send all transactions
+				if peer_info.last_sent_transactions.is_empty() {
+					peer_info.last_sent_transactions = all_transactions_hashes.clone();
+					return Some((*peer_id, all_transactions_rlp.clone()));
+				}
+
+				// Get hashes of all transactions to send to this peer
+				let to_send = all_transactions_hashes.difference(&peer_info.last_sent_transactions).cloned().collect::<HashSet<_>>();
+				if to_send.is_empty() {
+					return None;
+				}
+
+				// Construct RLP
+				let mut packet = RlpStream::new_list(to_send.len());
+				for tx in &transactions {
+					if to_send.contains(&tx.hash()) {
+						packet.append(tx);
+					}
+				}
+
+				peer_info.last_sent_transactions = all_transactions_hashes.clone();
+				Some((*peer_id, packet.out()))
+			})
+			.collect::<Vec<_>>();
+
+		// Send RLPs
 		let sent = lucky_peers.len();
-		for peer_id in lucky_peers {
+		for (peer_id, rlp) in lucky_peers.into_iter() {
-			self.send_packet(io, peer_id, TRANSACTIONS_PACKET, rlp.clone());
+			self.send_packet(io, peer_id, TRANSACTIONS_PACKET, rlp);
 		}
-		trace!(target: "sync", "Sent {} transactions to {} peers.", tx_count, sent);
+
+		trace!(target: "sync", "Sent up to {} transactions to {} peers.", transactions.len(), sent);
 		sent
 	}
 
@@ -1512,16 +1539,18 @@ impl ChainSync {
 		self.check_resume(io);
 	}
 
-	/// called when block is imported to chain, updates transactions queue and propagates the blocks
+	/// called when block is imported to chain - propagates the blocks and updates transactions sent to peers
 	pub fn chain_new_blocks(&mut self, io: &mut SyncIo, _imported: &[H256], invalid: &[H256], _enacted: &[H256], _retracted: &[H256], sealed: &[H256]) {
 		if io.is_chain_queue_empty() {
-			// Propagate latests blocks
 			self.propagate_latest_blocks(io, sealed);
 		}
 		if !invalid.is_empty() {
 			trace!(target: "sync", "Bad blocks in the queue, restarting");
 			self.restart_on_bad_block(io);
 		}
+		for peer_info in self.peers.values_mut() {
+			peer_info.last_sent_transactions.clear();
+		}
 	}
 }
 
@@ -1531,6 +1560,7 @@ mod tests {
 	use super::*;
 	use ::SyncConfig;
 	use util::*;
+	use rlp::*;
 	use super::{PeerInfo, PeerAsking};
 	use ethcore::views::BlockView;
 	use ethcore::header::*;
@@ -1548,8 +1578,8 @@ mod tests {
 
 		let mut rlp = RlpStream::new_list(3);
 		rlp.append(&header);
-		rlp.append_raw(&rlp::EMPTY_LIST_RLP, 1);
+		rlp.append_raw(&::rlp::EMPTY_LIST_RLP, 1);
-		rlp.append_raw(&rlp::EMPTY_LIST_RLP, 1);
+		rlp.append_raw(&::rlp::EMPTY_LIST_RLP, 1);
 		rlp.out()
 	}
 
@@ -1723,6 +1753,7 @@ mod tests {
 				asking_blocks: Vec::new(),
 				asking_hash: None,
 				ask_time: 0f64,
+				last_sent_transactions: HashSet::new(),
 				expired: false,
 				confirmation: super::ForkConfirmation::Confirmed,
 			});
@@ -1819,6 +1850,83 @@ mod tests {
 		assert_eq!(0x07, io.queue[0].packet_id);
 	}
 
+	#[test]
+	fn propagates_transactions() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let mut queue = VecDeque::new();
+		let mut io = TestIo::new(&mut client, &mut queue, None);
+		let peer_count = sync.propagate_new_transactions(&mut io);
+		// Try to propagate same transactions for the second time
+		let peer_count2 = sync.propagate_new_transactions(&mut io);
+
+		// 1 message should be send
+		assert_eq!(1, io.queue.len());
+		// 1 peer should be updated but only once
+		assert_eq!(1, peer_count);
+		assert_eq!(0, peer_count2);
+		// TRANSACTIONS_PACKET
+		assert_eq!(0x02, io.queue[0].packet_id);
+	}
+
+	#[test]
+	fn propagates_transactions_again_after_new_block() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let mut queue = VecDeque::new();
+		let mut io = TestIo::new(&mut client, &mut queue, None);
+		let peer_count = sync.propagate_new_transactions(&mut io);
+		sync.chain_new_blocks(&mut io, &[], &[], &[], &[], &[]);
+		// Try to propagate same transactions for the second time
+		let peer_count2 = sync.propagate_new_transactions(&mut io);
+
+		// 2 message should be send
+		assert_eq!(2, io.queue.len());
+		// 1 peer should be updated twice
+		assert_eq!(1, peer_count);
+		assert_eq!(1, peer_count2);
+		// TRANSACTIONS_PACKET
+		assert_eq!(0x02, io.queue[0].packet_id);
+		assert_eq!(0x02, io.queue[1].packet_id);
+	}
+
+	#[test]
+	fn propagates_transactions_without_alternating() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let mut queue = VecDeque::new();
+		// should sent some
+		{
+
+			let mut io = TestIo::new(&mut client, &mut queue, None);
+			let peer_count = sync.propagate_new_transactions(&mut io);
+			assert_eq!(1, io.queue.len());
+			assert_eq!(1, peer_count);
+		}
+		// Insert some more
+		client.insert_transaction_to_queue();
+		let mut io = TestIo::new(&mut client, &mut queue, None);
+		// Propagate new transactions
+		let peer_count2 = sync.propagate_new_transactions(&mut io);
+		// And now the peer should have all transactions
+		let peer_count3 = sync.propagate_new_transactions(&mut io);
+
+		// 2 message should be send (in total)
+		assert_eq!(2, io.queue.len());
+		// 1 peer should be updated but only once after inserting new transaction
+		assert_eq!(1, peer_count2);
+		assert_eq!(0, peer_count3);
+		// TRANSACTIONS_PACKET
+		assert_eq!(0x02, io.queue[0].packet_id);
+		assert_eq!(0x02, io.queue[1].packet_id);
+	}
+
 	#[test]
 	fn handles_peer_new_block_malformed() {
 		let mut client = TestBlockChainClient::new();

sync/src/lib.rs

@@ -34,7 +34,6 @@
 //! extern crate ethcore;
 //! extern crate ethsync;
 //! use std::env;
-//! use std::sync::Arc;
 //! use io::IoChannel;
 //! use ethcore::client::{Client, ClientConfig};
 //! use ethsync::{EthSync, SyncConfig, ManageNetwork, NetworkConfiguration};
@@ -62,22 +61,24 @@
 //! }
 //! ```
 
-#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate ethcore_util as util;
 extern crate ethcore_network as network;
 extern crate ethcore_io as io;
 extern crate ethcore;
 extern crate env_logger;
 extern crate time;
 extern crate rand;
+extern crate semver;
+extern crate parking_lot;
+extern crate rlp;
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate ethcore_util as util;
 #[macro_use]
 extern crate heapsize;
 #[macro_use]
 extern crate ethcore_ipc as ipc;
-extern crate semver;
-extern crate parking_lot;
 
 mod chain;
 mod blocks;

util/Cargo.toml

@@ -18,7 +18,8 @@ rocksdb = { git = "https://github.com/ethcore/rust-rocksdb" }
 lazy_static = "0.2"
 eth-secp256k1 = { git = "https://github.com/ethcore/rust-secp256k1" }
 rust-crypto = "0.2.34"
-elastic-array = { git = "https://github.com/ethcore/elastic-array" }
+elastic-array = "0.5"
+rlp = { path = "rlp" }
 heapsize = { version = "0.3", features = ["unstable"] }
 itertools = "0.4"
 sha3 = { path = "sha3" }

util/network/Cargo.toml

@@ -25,6 +25,7 @@ ethcore-util = { path = ".." }
 ethcore-devtools = { path = "../../devtools" }
 ethkey = { path = "../../ethkey" }
 ethcrypto = { path = "../../ethcrypto" }
+rlp = { path = "../rlp" }
 
 [features]
 default = []

util/network/src/connection.rs

@@ -23,7 +23,7 @@ use mio::tcp::*;
 use util::hash::*;
 use util::sha3::*;
 use util::bytes::*;
-use util::rlp::*;
+use rlp::*;
 use std::io::{self, Cursor, Read, Write};
 use error::*;
 use io::{IoContext, StreamToken};

util/network/src/discovery.rs

@@ -24,7 +24,7 @@ use mio::udp::*;
 use util::sha3::*;
 use time;
 use util::hash::*;
-use util::rlp::*;
+use rlp::*;
 use node_table::*;
 use error::NetworkError;
 use io::{StreamToken, IoContext};

util/network/src/error.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use io::IoError;
-use util::rlp::*;
+use rlp::*;
 use util::UtilError;
 use std::fmt;
 use ethkey::Error as KeyError;

util/network/src/handshake.rs

@@ -18,9 +18,9 @@ use std::sync::Arc;
 use rand::random;
 use mio::tcp::*;
 use util::hash::*;
-use util::rlp::*;
 use util::sha3::Hashable;
 use util::bytes::Bytes;
+use rlp::*;
 use connection::{Connection};
 use host::{HostInfo};
 use node_table::NodeId;

util/network/src/host.rs

@@ -29,8 +29,8 @@ use mio::*;
 use mio::tcp::*;
 use util::hash::*;
 use util::Hashable;
-use util::rlp::*;
 use util::version;
+use rlp::*;
 use session::{Session, SessionData};
 use error::*;
 use io::*;

util/network/src/lib.rs

@@ -54,9 +54,6 @@
 //! }
 //! ```
 
-
-#[macro_use]
-extern crate log;
 extern crate ethcore_io as io;
 extern crate ethcore_util as util;
 extern crate parking_lot;
@@ -72,6 +69,11 @@ extern crate libc;
 extern crate slab;
 extern crate ethkey;
 extern crate ethcrypto as crypto;
+extern crate rlp;
+
+#[macro_use]
+extern crate log;
+
 #[cfg(test)]
 extern crate ethcore_devtools as devtools;
 

util/network/src/node_table.rs

@@ -26,8 +26,8 @@ use std::fmt;
 use std::fs;
 use std::io::{Read, Write};
 use util::hash::*;
-use util::rlp::*;
 use util::UtilError;
+use rlp::*;
 use time::Tm;
 use error::NetworkError;
 use discovery::{TableUpdates, NodeEntry};

util/network/src/session.rs

@@ -19,8 +19,8 @@ use std::io;
 use std::sync::*;
 use mio::*;
 use mio::tcp::*;
-use util::rlp::*;
 use util::hash::*;
+use rlp::*;
 use connection::{EncryptedConnection, Packet, Connection};
 use handshake::Handshake;
 use io::{IoContext, StreamToken};

util/rlp/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+description = "Recursive-length prefix encoding, decoding, and compression"
+license = "GPL-3.0"
+name = "rlp"
+version = "0.1.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+
+[dependencies]
+elastic-array = "0.5"
+bigint = { path = "../bigint" }
+lazy_static = "0.2"
+rustc-serialize = "0.3"

util/rlp/src/bytes.rs

@@ -22,7 +22,7 @@ use std::fmt;
 use std::cmp::Ordering;
 use std::error::Error as StdError;
 use bigint::uint::{Uint, U128, U256};
-use hash::{H64, H128, H160, H256, H512, H520, H2048};
+use bigint::hash::{H64, H128, H160, H256, H512, H520, H2048};
 use elastic_array::*;
 
 /// Vector like object

util/rlp/src/commonrlps.rs

@@ -16,7 +16,7 @@
 
 //! Contains RLPs used for compression.
 
-use rlp::rlpcompression::InvalidRlpSwapper;
+use rlpcompression::InvalidRlpSwapper;
 
 lazy_static! {
 	/// Swapper for snapshot compression.
@@ -48,59 +48,3 @@ static COMMON_RLPS: &'static [&'static [u8]] = &[
 ];
 
 static INVALID_RLPS: &'static [&'static [u8]] = &[&[0x81, 0x0], &[0x81, 0x1], &[0x81, 0x2], &[0x81, 0x3], &[0x81, 0x4], &[0x81, 0x5], &[0x81, 0x6], &[0x81, 0x7], &[0x81, 0x8], &[0x81, 0x9], &[0x81, 0xa], &[0x81, 0xb], &[0x81, 0xc], &[0x81, 0xd], &[0x81, 0xe], &[0x81, 0xf], &[0x81, 0x10], &[0x81, 0x11], &[0x81, 0x12], &[0x81, 0x13], &[0x81, 0x14], &[0x81, 0x15], &[0x81, 0x16], &[0x81, 0x17], &[0x81, 0x18], &[0x81, 0x19], &[0x81, 0x1a], &[0x81, 0x1b], &[0x81, 0x1c], &[0x81, 0x1d], &[0x81, 0x1e], &[0x81, 0x1f], &[0x81, 0x20], &[0x81, 0x21], &[0x81, 0x22], &[0x81, 0x23], &[0x81, 0x24], &[0x81, 0x25], &[0x81, 0x26], &[0x81, 0x27], &[0x81, 0x28], &[0x81, 0x29], &[0x81, 0x2a], &[0x81, 0x2b], &[0x81, 0x2c], &[0x81, 0x2d], &[0x81, 0x2e], &[0x81, 0x2f], &[0x81, 0x30], &[0x81, 0x31], &[0x81, 0x32], &[0x81, 0x33], &[0x81, 0x34], &[0x81, 0x35], &[0x81, 0x36], &[0x81, 0x37], &[0x81, 0x38], &[0x81, 0x39], &[0x81, 0x3a], &[0x81, 0x3b], &[0x81, 0x3c], &[0x81, 0x3d], &[0x81, 0x3e], &[0x81, 0x3f], &[0x81, 0x40], &[0x81, 0x41], &[0x81, 0x42], &[0x81, 0x43], &[0x81, 0x44], &[0x81, 0x45], &[0x81, 0x46], &[0x81, 0x47], &[0x81, 0x48], &[0x81, 0x49], &[0x81, 0x4a], &[0x81, 0x4b], &[0x81, 0x4c], &[0x81, 0x4d], &[0x81, 0x4e], &[0x81, 0x4f], &[0x81, 0x50], &[0x81, 0x51], &[0x81, 0x52], &[0x81, 0x53], &[0x81, 0x54], &[0x81, 0x55], &[0x81, 0x56], &[0x81, 0x57], &[0x81, 0x58], &[0x81, 0x59], &[0x81, 0x5a], &[0x81, 0x5b], &[0x81, 0x5c], &[0x81, 0x5d], &[0x81, 0x5e], &[0x81, 0x5f], &[0x81, 0x60], &[0x81, 0x61], &[0x81, 0x62], &[0x81, 0x63], &[0x81, 0x64], &[0x81, 0x65], &[0x81, 0x66], &[0x81, 0x67], &[0x81, 0x68], &[0x81, 0x69], &[0x81, 0x6a], &[0x81, 0x6b], &[0x81, 0x6c], &[0x81, 0x6d], &[0x81, 0x6e], &[0x81, 0x6f], &[0x81, 0x70], &[0x81, 0x71], &[0x81, 0x72], &[0x81, 0x73], &[0x81, 0x74], &[0x81, 0x75], &[0x81, 0x76], &[0x81, 0x77], &[0x81, 0x78], &[0x81, 0x79], &[0x81, 0x7a], &[0x81, 0x7b], &[0x81, 0x7c], &[0x81, 0x7d], &[0x81, 0x7e]];
-
-#[cfg(test)]
-mod tests {
-	#[test]
-	#[ignore]
-	fn analyze_db() {
-		use rlp::{UntrustedRlp, View};
-		use std::collections::HashMap;
-		use kvdb::*;
-
-		let path =  "db path".to_string();
-		let values: Vec<_> = Database::open_default(&path).unwrap().iter(Some(2)).map(|(_, v)| v).collect();
-		let mut rlp_counts: HashMap<_, u32> = HashMap::new();
-		let mut rlp_sizes: HashMap<_, u32> = HashMap::new();
-
-		fn flat_rlp<'a>(acc: &mut Vec<UntrustedRlp<'a>>, rlp: UntrustedRlp<'a>) {
-			match rlp.is_data() {
-				true => if rlp.size()>=70 {
-					match rlp.data() {
-						Ok(x) => flat_rlp(acc, UntrustedRlp::new(x)),
-						_ => acc.push(rlp),
-					}
-				} else {
-					acc.push(rlp);
-				},
-				false => for r in rlp.iter() { flat_rlp(acc, r); },
-			}
-		}
-
-		fn space_saving(bytes: &[u8]) -> u32 {
-			let l = bytes.len() as u32;
-			match l >= 2 {
-				true => l-2,
-				false => 0,
-			}
-		}
-
-		for v in &values {
-			let rlp = UntrustedRlp::new(v);
-			let mut flat = Vec::new();
-			flat_rlp(&mut flat, rlp);
-			for r in &flat {
-				*rlp_counts.entry(r.as_raw()).or_insert(0) += 1;
-				*rlp_sizes.entry(r.as_raw()).or_insert(0) += space_saving(r.as_raw());
-			}
-		}
-		let mut size_vec: Vec<_> = rlp_sizes.iter().collect();
-		size_vec.sort_by(|a, b| b.1.cmp(a.1));
-
-		// Exclude rare large RLPs.
-		for v in size_vec.iter().filter(|v| rlp_counts.get(v.0).unwrap()>&100).take(20) {
-			println!("{:?}, {:?}", v, rlp_counts.get(v.0).unwrap());
-		}
-		println!("DONE");
-	}
-}

util/rlp/src/lib.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/>.
 
-//! Rlp serialization module
+//! Recursive Length Prefix serialization crate.
 //!
 //! Allows encoding, decoding, and view onto rlp-slice
 //!
@@ -64,27 +64,29 @@ pub use self::untrusted_rlp::{UntrustedRlp, UntrustedRlpIterator, PayloadInfo, P
 pub use self::rlpin::{Rlp, RlpIterator};
 pub use self::rlpstream::RlpStream;
 pub use self::rlpcompression::RlpType;
-pub use elastic_array::ElasticArray1024;
+
-use super::hash::H256;
+extern crate bigint;
+extern crate elastic_array;
+extern crate rustc_serialize;
+
+#[macro_use]
+extern crate lazy_static;
+
+use elastic_array::ElasticArray1024;
 
 /// The RLP encoded empty data (used to mean "null value").
 pub const NULL_RLP: [u8; 1] = [0x80; 1];
 /// The RLP encoded empty list.
 pub const EMPTY_LIST_RLP: [u8; 1] = [0xC0; 1];
-/// The SHA3 of the RLP encoding of empty data.
-pub const SHA3_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] );
-/// The SHA3 of the RLP encoding of empty list.
-pub const SHA3_EMPTY_LIST_RLP: H256 = H256( [0x1d, 0xcc, 0x4d, 0xe8, 0xde, 0xc7, 0x5d, 0x7a, 0xab, 0x85, 0xb5, 0x67, 0xb6, 0xcc, 0xd4, 0x1a, 0xd3, 0x12, 0x45, 0x1b, 0x94, 0x8a, 0x74, 0x13, 0xf0, 0xa1, 0x42, 0xfd, 0x40, 0xd4, 0x93, 0x47] );
 
 /// Shortcut function to decode trusted rlp
 ///
 /// ```rust
-/// extern crate ethcore_util as util;
+/// extern crate rlp;
-/// use util::rlp::*;
 ///
 /// fn main () {
 /// 	let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'];
-/// 	let animals: Vec<String> = decode(&data);
+/// 	let animals: Vec<String> = rlp::decode(&data);
 /// 	assert_eq!(animals, vec!["cat".to_string(), "dog".to_string()]);
 /// }
 /// ```
@@ -96,12 +98,11 @@ pub fn decode<T>(bytes: &[u8]) -> T where T: RlpDecodable {
 /// Shortcut function to encode structure into rlp.
 ///
 /// ```rust
-/// extern crate ethcore_util as util;
+/// extern crate rlp;
-/// use util::rlp::*;
 ///
 /// fn main () {
 /// 	let animal = "cat";
-/// 	let out = encode(&animal).to_vec();
+/// 	let out = rlp::encode(&animal).to_vec();
 /// 	assert_eq!(out, vec![0x83, b'c', b'a', b't']);
 /// }
 /// ```

util/rlp/src/rlpcompression.rs

@@ -14,9 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use rlp::{UntrustedRlp, View, Compressible, encode, ElasticArray1024, Stream, RlpStream};
+use ::{UntrustedRlp, View, Compressible, encode, Stream, RlpStream};
-use rlp::commonrlps::{BLOCKS_RLP_SWAPPER, SNAPSHOT_RLP_SWAPPER};
+use commonrlps::{BLOCKS_RLP_SWAPPER, SNAPSHOT_RLP_SWAPPER};
+
 use std::collections::HashMap;
+use elastic_array::ElasticArray1024;
 
 /// Stores RLPs used for compression
 pub struct InvalidRlpSwapper<'a> {
@@ -169,8 +171,8 @@ impl<'a> Compressible for UntrustedRlp<'a> {
 
 #[cfg(test)]
 mod tests {
-	use rlp::{UntrustedRlp, Compressible, View, RlpType};
+	use ::{UntrustedRlp, Compressible, View, RlpType};
-	use rlp::rlpcompression::InvalidRlpSwapper;
+	use rlpcompression::InvalidRlpSwapper;
 
 	#[test]
 	fn invalid_rlp_swapper() {
@@ -222,24 +224,4 @@ mod tests {
 		let malformed_rlp = UntrustedRlp::new(&malformed);
 		assert_eq!(malformed_rlp.decompress(RlpType::Blocks).to_vec(), malformed);
 	}
-
-	#[test]
-	#[ignore]
-	fn test_compression() {
-		use kvdb::*;
-		let path = "db to test".to_string();
-		let values: Vec<_> = Database::open_default(&path).unwrap().iter(Some(2)).map(|(_, v)| v).collect();
-		let mut decomp_size = 0;
-		let mut comp_size = 0;
-
-		for v in &values {
-			let rlp = UntrustedRlp::new(v);
-			let compressed = rlp.compress(RlpType::Blocks).to_vec();
-			comp_size += compressed.len();
-			let decompressed = rlp.decompress(RlpType::Blocks).to_vec();
-			decomp_size += decompressed.len();
-		}
-		println!("Decompressed bytes {:?}, compressed bytes: {:?}", decomp_size, comp_size);
-		assert!(decomp_size > comp_size);
-	}
 }