Update a few parity-common dependencies (#9663)

* Update a few parity-common dependencies

* cleanup

* cleanup

* revert update of ethereum/tests

* better reporting of network rlp errors

* Use rlp 0.3.0-beta.1

* fix util function get_dummy_blocks

* Already a Vec

* encode_list returns vec already

* Address grumble

* No need for betas

* Fix double spaces

Author: dvdplm

Cargo.lock

@@ -46,7 +46,7 @@ ethcore-transaction = { path = "ethcore/transaction" }
 ethereum-types = "0.4"
 node-filter = { path = "ethcore/node_filter" }
 ethkey = { path = "ethkey" }
-rlp = { version = "0.2.4", features = ["ethereum"] }
+rlp = { version = "0.3.0", features = ["ethereum"] }
 rpc-cli = { path = "rpc_cli" }
 parity-hash-fetch = { path = "hash-fetch" }
 parity-ipfs-api = { path = "ipfs" }

Cargo.toml

@@ -16,9 +16,9 @@ crossbeam = "0.3"
 ethash = { path = "../ethash" }
 ethcore-bloom-journal = { path = "../util/bloom" }
 parity-bytes = "0.1"
-hashdb = "0.2.1"
-memorydb = "0.2.1"
-patricia-trie = "0.2"
+hashdb = "0.3.0"
+memorydb = "0.3.0"
+patricia-trie = "0.3.0"
 patricia-trie-ethereum = { path = "../util/patricia-trie-ethereum" }
 parity-crypto = "0.1"
 error-chain = { version = "0.12", default-features = false }
@@ -47,7 +47,7 @@ parity-machine = { path = "../machine" }
 parking_lot = "0.6"
 rayon = "1.0"
 rand = "0.4"
-rlp = { version = "0.2.4", features = ["ethereum"] }
+rlp = { version = "0.3.0", features = ["ethereum"] }
 rlp_compress = { path = "../util/rlp_compress" }
 rlp_derive = { path = "../util/rlp_derive" }
 kvdb = "0.1"

ethcore/Cargo.toml

@@ -12,16 +12,16 @@ ethcore = { path = ".."}
 parity-bytes = "0.1"
 ethcore-transaction = { path = "../transaction" }
 ethereum-types = "0.4"
-memorydb = "0.2.1"
-patricia-trie = "0.2"
+memorydb = "0.3.0"
+patricia-trie = "0.3.0"
 patricia-trie-ethereum = { path = "../../util/patricia-trie-ethereum" }
 ethcore-network = { path = "../../util/network" }
 ethcore-io = { path = "../../util/io" }
-hashdb = "0.2.1"
+hashdb = "0.3.0"
 heapsize = "0.4"
 vm = { path = "../vm" }
 fastmap = { path = "../../util/fastmap" }
-rlp = { version = "0.2.4", features = ["ethereum"] }
+rlp = { version = "0.3.0", features = ["ethereum"] }
 rlp_derive = { path = "../../util/rlp_derive" }
 smallvec = "0.6"
 futures = "0.1"

ethcore/light/Cargo.toml

@@ -27,6 +27,7 @@ use ethcore::ids::BlockId;
 use ethereum_types::{H256, U256};
 use hashdb::HashDB;
 use keccak_hasher::KeccakHasher;
+use kvdb::DBValue;
 use memorydb::MemoryDB;
 use bytes::Bytes;
 use trie::{TrieMut, Trie, Recorder};
@@ -52,13 +53,13 @@ pub const SIZE: u64 = 2048;
 /// A canonical hash trie. This is generic over any database it can query.
 /// See module docs for more details.
 #[derive(Debug, Clone)]
-pub struct CHT<DB: HashDB<KeccakHasher>> {
+pub struct CHT<DB: HashDB<KeccakHasher, DBValue>> {
 	db: DB,
 	root: H256, // the root of this CHT.
 	number: u64,
 }
 
-impl<DB: HashDB<KeccakHasher>> CHT<DB> {
+impl<DB: HashDB<KeccakHasher, DBValue>> CHT<DB> {
 	/// Query the root of the CHT.
 	pub fn root(&self) -> H256 { self.root }
 
@@ -92,10 +93,10 @@ pub struct BlockInfo {
 /// Build an in-memory CHT from a closure which provides necessary information
 /// about blocks. If the fetcher ever fails to provide the info, the CHT
 /// will not be generated.
-pub fn build<F>(cht_num: u64, mut fetcher: F) -> Option<CHT<MemoryDB<KeccakHasher>>>
+pub fn build<F>(cht_num: u64, mut fetcher: F) -> Option<CHT<MemoryDB<KeccakHasher, DBValue>>>
 	where F: FnMut(BlockId) -> Option<BlockInfo>
 {
-	let mut db = MemoryDB::<KeccakHasher>::new();
+	let mut db = MemoryDB::<KeccakHasher, DBValue>::new();
 
 	// start from the last block by number and work backwards.
 	let last_num = start_number(cht_num + 1) - 1;
@@ -134,7 +135,7 @@ pub fn compute_root<I>(cht_num: u64, iterable: I) -> Option<H256>
 	let start_num = start_number(cht_num) as usize;
 
 	for (i, (h, td)) in iterable.into_iter().take(SIZE as usize).enumerate() {
-		v.push((key!(i + start_num).into_vec(), val!(h, td).into_vec()))
+		v.push((key!(i + start_num), val!(h, td)))
 	}
 
 	if v.len() == SIZE as usize {
@@ -149,7 +150,7 @@ pub fn compute_root<I>(cht_num: u64, iterable: I) -> Option<H256>
 /// verify the given trie branch and extract the canonical hash and total difficulty.
 // TODO: better support for partially-checked queries.
 pub fn check_proof(proof: &[Bytes], num: u64, root: H256) -> Option<(H256, U256)> {
-	let mut db = MemoryDB::<KeccakHasher>::new();
+	let mut db = MemoryDB::<KeccakHasher, DBValue>::new();
 
 	for node in proof { db.insert(&node[..]); }
 	let res = match TrieDB::new(&db, &root) {

ethcore/light/src/cht.rs

@@ -218,7 +218,7 @@ impl HeaderChain {
 	) -> Result<Self, Error> {
 		let mut live_epoch_proofs = ::std::collections::HashMap::default();
 
-		let genesis = ::rlp::encode(&spec.genesis_header()).into_vec();
+		let genesis = ::rlp::encode(&spec.genesis_header());
 		let decoded_header = spec.genesis_header();
 
 		let chain = if let Some(current) = db.get(col, CURRENT_KEY)? {

ethcore/light/src/client/header_chain.rs

@@ -150,7 +150,7 @@ impl Provider for TestProvider {
 
 	fn storage_proof(&self, req: request::CompleteStorageRequest) -> Option<request::StorageResponse> {
 		Some(StorageResponse {
-			proof: vec![::rlp::encode(&req.key_hash).into_vec()],
+			proof: vec![::rlp::encode(&req.key_hash)],
 			value: req.key_hash | req.address_hash,
 		})
 	}

ethcore/light/src/net/tests/mod.rs

@@ -1156,7 +1156,7 @@ mod tests {
 		header.set_number(10_000);
 		header.set_extra_data(b"test_header".to_vec());
 		let hash = header.hash();
-		let raw_header = encoded::Header::new(::rlp::encode(&header).into_vec());
+		let raw_header = encoded::Header::new(::rlp::encode(&header));
 
 		let cache = Mutex::new(make_cache());
 		assert!(HeaderByHash(hash.into()).check_response(&cache, &hash.into(), &[raw_header]).is_ok())
@@ -1177,14 +1177,14 @@ mod tests {
 		headers.reverse();  // because responses are in reverse order
 
 		let raw_headers = headers.iter()
-			.map(|hdr| encoded::Header::new(::rlp::encode(hdr).into_vec()))
+			.map(|hdr| encoded::Header::new(::rlp::encode(hdr)))
 			.collect::<Vec<_>>();
 
 		let mut invalid_successor = Header::new();
 		invalid_successor.set_number(11);
 		invalid_successor.set_parent_hash(headers[1].hash());
 
-		let raw_invalid_successor = encoded::Header::new(::rlp::encode(&invalid_successor).into_vec());
+		let raw_invalid_successor = encoded::Header::new(::rlp::encode(&invalid_successor));
 
 		let cache = Mutex::new(make_cache());
 
@@ -1247,10 +1247,10 @@ mod tests {
 		let mut body_stream = RlpStream::new_list(2);
 		body_stream.begin_list(0).begin_list(0);
 
-		let req = Body(encoded::Header::new(::rlp::encode(&header).into_vec()).into());
+		let req = Body(encoded::Header::new(::rlp::encode(&header)).into());
 
 		let cache = Mutex::new(make_cache());
-		let response = encoded::Body::new(body_stream.drain().into_vec());
+		let response = encoded::Body::new(body_stream.drain());
 		assert!(req.check_response(&cache, &response).is_ok())
 	}
 
@@ -1270,7 +1270,7 @@ mod tests {
 
 		header.set_receipts_root(receipts_root);
 
-		let req = BlockReceipts(encoded::Header::new(::rlp::encode(&header).into_vec()).into());
+		let req = BlockReceipts(encoded::Header::new(::rlp::encode(&header)).into());
 
 		let cache = Mutex::new(make_cache());
 		assert!(req.check_response(&cache, &receipts).is_ok())
@@ -1318,7 +1318,7 @@ mod tests {
 		header.set_state_root(root.clone());
 
 		let req = Account {
-			header: encoded::Header::new(::rlp::encode(&header).into_vec()).into(),
+			header: encoded::Header::new(::rlp::encode(&header)).into(),
 			address: addr,
 		};
 
@@ -1332,7 +1332,7 @@ mod tests {
 		let code_hash = keccak(&code);
 		let header = Header::new();
 		let req = Code {
-			header: encoded::Header::new(::rlp::encode(&header).into_vec()).into(),
+			header: encoded::Header::new(::rlp::encode(&header)).into(),
 			code_hash: code_hash.into(),
 		};
 

ethcore/light/src/on_demand/request.rs

@@ -1676,7 +1676,7 @@ mod tests {
 		let full_req = Request::Headers(req.clone());
 		let res = HeadersResponse {
 			headers: vec![
-				::ethcore::encoded::Header::new(::rlp::encode(&Header::default()).into_vec())
+				::ethcore::encoded::Header::new(::rlp::encode(&Header::default()))
 			]
 		};
 		let full_res = Response::Headers(res.clone());

ethcore/light/src/types/request/mod.rs

@@ -26,10 +26,10 @@ heapsize = "0.4"
 keccak-hash = "0.1.2"
 log = "0.4"
 parking_lot = "0.6"
-patricia-trie = "0.2"
+patricia-trie = "0.3.0"
 patricia-trie-ethereum = { path = "../../util/patricia-trie-ethereum" }
 rand = "0.3"
-rlp = { version = "0.2.4", features = ["ethereum"] }
+rlp = { version = "0.3.0", features = ["ethereum"] }
 rlp_derive = { path = "../../util/rlp_derive" }
 rustc-hex = "1.0"
 serde = "1.0"

ethcore/private-tx/Cargo.toml

@@ -220,7 +220,7 @@ impl Provider where {
 				let private_state_hash = self.calculate_state_hash(&private_state, contract_nonce);
 				trace!(target: "privatetx", "Hashed effective private state for sender: {:?}", private_state_hash);
 				self.transactions_for_signing.write().add_transaction(private.hash(), signed_transaction, contract_validators, private_state, contract_nonce)?;
-				self.broadcast_private_transaction(private.hash(), private.rlp_bytes().into_vec());
+				self.broadcast_private_transaction(private.hash(), private.rlp_bytes());
 				Ok(Receipt {
 					hash: tx_hash,
 					contract_address: Some(contract),
@@ -259,13 +259,13 @@ impl Provider where {
 			match transaction.validator_account {
 				None => {
 					trace!(target: "privatetx", "Propagating transaction further");
-					self.broadcast_private_transaction(private_hash, transaction.private_transaction.rlp_bytes().into_vec());
+					self.broadcast_private_transaction(private_hash, transaction.private_transaction.rlp_bytes());
 					return Ok(());
 				}
 				Some(validator_account) => {
 					if !self.validator_accounts.contains(&validator_account) {
 						trace!(target: "privatetx", "Propagating transaction further");
-						self.broadcast_private_transaction(private_hash, transaction.private_transaction.rlp_bytes().into_vec());
+						self.broadcast_private_transaction(private_hash, transaction.private_transaction.rlp_bytes());
 						return Ok(());
 					}
 					let tx_action = transaction.transaction.action.clone();
@@ -291,7 +291,7 @@ impl Provider where {
 						let signed_state = signed_state.expect("Error was checked before");
 						let signed_private_transaction = SignedPrivateTransaction::new(private_hash, signed_state, None);
 						trace!(target: "privatetx", "Sending signature for private transaction: {:?}", signed_private_transaction);
-						self.broadcast_signed_private_transaction(signed_private_transaction.hash(), signed_private_transaction.rlp_bytes().into_vec());
+						self.broadcast_signed_private_transaction(signed_private_transaction.hash(), signed_private_transaction.rlp_bytes());
 					} else {
 						bail!("Incorrect type of action for the transaction");
 					}
@@ -316,7 +316,7 @@ impl Provider where {
 		let desc = match self.transactions_for_signing.read().get(&private_hash) {
 			None => {
 				// Not our transaction, broadcast further to peers
-				self.broadcast_signed_private_transaction(signed_tx.hash(), signed_tx.rlp_bytes().into_vec());
+				self.broadcast_signed_private_transaction(signed_tx.hash(), signed_tx.rlp_bytes());
 				return Ok(());
 			},
 			Some(desc) => desc,

ethcore/private-tx/src/lib.rs

@@ -58,15 +58,15 @@ impl Default for Factory {
 impl Factory {
 	/// Create a read-only accountdb.
 	/// This will panic when write operations are called.
-	pub fn readonly<'db>(&self, db: &'db HashDB<KeccakHasher>, address_hash: H256) -> Box<HashDB<KeccakHasher> + 'db> {
+	pub fn readonly<'db>(&self, db: &'db HashDB<KeccakHasher, DBValue>, address_hash: H256) -> Box<HashDB<KeccakHasher, DBValue> + 'db> {
 		match *self {
 			Factory::Mangled => Box::new(AccountDB::from_hash(db, address_hash)),
 			Factory::Plain => Box::new(Wrapping(db)),
 		}
 	}
 
 	/// Create a new mutable hashdb.
-	pub fn create<'db>(&self, db: &'db mut HashDB<KeccakHasher>, address_hash: H256) -> Box<HashDB<KeccakHasher> + 'db> {
+	pub fn create<'db>(&self, db: &'db mut HashDB<KeccakHasher, DBValue>, address_hash: H256) -> Box<HashDB<KeccakHasher, DBValue> + 'db> {
 		match *self {
 			Factory::Mangled => Box::new(AccountDBMut::from_hash(db, address_hash)),
 			Factory::Plain => Box::new(WrappingMut(db)),
@@ -78,32 +78,32 @@ impl Factory {
 /// DB backend wrapper for Account trie
 /// Transforms trie node keys for the database
 pub struct AccountDB<'db> {
-	db: &'db HashDB<KeccakHasher>,
+	db: &'db HashDB<KeccakHasher, DBValue>,
 	address_hash: H256,
 }
 
 impl<'db> AccountDB<'db> {
 	/// Create a new AccountDB from an address.
 	#[cfg(test)]
-	pub fn new(db: &'db HashDB<KeccakHasher>, address: &Address) -> Self {
+	pub fn new(db: &'db HashDB<KeccakHasher, DBValue>, address: &Address) -> Self {
 		Self::from_hash(db, keccak(address))
 	}
 
 	/// Create a new AcountDB from an address' hash.
-	pub fn from_hash(db: &'db HashDB<KeccakHasher>, address_hash: H256) -> Self {
+	pub fn from_hash(db: &'db HashDB<KeccakHasher, DBValue>, address_hash: H256) -> Self {
 		AccountDB {
 			db: db,
 			address_hash: address_hash,
 		}
 	}
 }
 
-impl<'db> AsHashDB<KeccakHasher> for AccountDB<'db> {
-	fn as_hashdb(&self) -> &HashDB<KeccakHasher> { self }
-	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher> { self }
+impl<'db> AsHashDB<KeccakHasher, DBValue> for AccountDB<'db> {
+	fn as_hashdb(&self) -> &HashDB<KeccakHasher, DBValue> { self }
+	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher, DBValue> { self }
 }
 
-impl<'db> HashDB<KeccakHasher> for AccountDB<'db> {
+impl<'db> HashDB<KeccakHasher, DBValue> for AccountDB<'db> {
 	fn keys(&self) -> HashMap<H256, i32> {
 		unimplemented!()
 	}
@@ -137,19 +137,19 @@ impl<'db> HashDB<KeccakHasher> for AccountDB<'db> {
 
 /// DB backend wrapper for Account trie
 pub struct AccountDBMut<'db> {
-	db: &'db mut HashDB<KeccakHasher>,
+	db: &'db mut HashDB<KeccakHasher, DBValue>,
 	address_hash: H256,
 }
 
 impl<'db> AccountDBMut<'db> {
 	/// Create a new AccountDB from an address.
 	#[cfg(test)]
-	pub fn new(db: &'db mut HashDB<KeccakHasher>, address: &Address) -> Self {
+	pub fn new(db: &'db mut HashDB<KeccakHasher, DBValue>, address: &Address) -> Self {
 		Self::from_hash(db, keccak(address))
 	}
 
 	/// Create a new AcountDB from an address' hash.
-	pub fn from_hash(db: &'db mut HashDB<KeccakHasher>, address_hash: H256) -> Self {
+	pub fn from_hash(db: &'db mut HashDB<KeccakHasher, DBValue>, address_hash: H256) -> Self {
 		AccountDBMut {
 			db: db,
 			address_hash: address_hash,
@@ -162,7 +162,7 @@ impl<'db> AccountDBMut<'db> {
 	}
 }
 
-impl<'db> HashDB<KeccakHasher> for AccountDBMut<'db>{
+impl<'db> HashDB<KeccakHasher, DBValue> for AccountDBMut<'db>{
 	fn keys(&self) -> HashMap<H256, i32> {
 		unimplemented!()
 	}
@@ -208,19 +208,19 @@ impl<'db> HashDB<KeccakHasher> for AccountDBMut<'db>{
 	}
 }
 
-impl<'db> AsHashDB<KeccakHasher> for AccountDBMut<'db> {
-	fn as_hashdb(&self) -> &HashDB<KeccakHasher> { self }
-	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher> { self }
+impl<'db> AsHashDB<KeccakHasher, DBValue> for AccountDBMut<'db> {
+	fn as_hashdb(&self) -> &HashDB<KeccakHasher, DBValue> { self }
+	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher, DBValue> { self }
 }
 
-struct Wrapping<'db>(&'db HashDB<KeccakHasher>);
+struct Wrapping<'db>(&'db HashDB<KeccakHasher, DBValue>);
 
-impl<'db> AsHashDB<KeccakHasher> for Wrapping<'db> {
-	fn as_hashdb(&self) -> &HashDB<KeccakHasher> { self }
-	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher> { self }
+impl<'db> AsHashDB<KeccakHasher, DBValue> for Wrapping<'db> {
+	fn as_hashdb(&self) -> &HashDB<KeccakHasher, DBValue> { self }
+	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher, DBValue> { self }
 }
 
-impl<'db> HashDB<KeccakHasher> for Wrapping<'db> {
+impl<'db> HashDB<KeccakHasher, DBValue> for Wrapping<'db> {
 	fn keys(&self) -> HashMap<H256, i32> {
 		unimplemented!()
 	}
@@ -252,13 +252,13 @@ impl<'db> HashDB<KeccakHasher> for Wrapping<'db> {
 	}
 }
 
-struct WrappingMut<'db>(&'db mut HashDB<KeccakHasher>);
-impl<'db> AsHashDB<KeccakHasher> for WrappingMut<'db> {
-	fn as_hashdb(&self) -> &HashDB<KeccakHasher> { self }
-	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher> { self }
+struct WrappingMut<'db>(&'db mut HashDB<KeccakHasher, DBValue>);
+impl<'db> AsHashDB<KeccakHasher, DBValue> for WrappingMut<'db> {
+	fn as_hashdb(&self) -> &HashDB<KeccakHasher, DBValue> { self }
+	fn as_hashdb_mut(&mut self) -> &mut HashDB<KeccakHasher, DBValue> { self }
 }
 
-impl<'db> HashDB<KeccakHasher> for WrappingMut<'db>{
+impl<'db> HashDB<KeccakHasher, DBValue> for WrappingMut<'db>{
 	fn keys(&self) -> HashMap<H256, i32> {
 		unimplemented!()
 	}