Merge branch 'master' into changes_tries_update_configuration

core/client/db/src/changes_tries_storage.rs

@@ -18,6 +18,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
+use hash_db::Prefix;
 use kvdb::{KeyValueDB, DBTransaction};
 use parity_codec::Encode;
 use parking_lot::{RwLock, RwLockWriteGuard};
@@ -288,14 +289,15 @@ where
 		self
 	}
 
-	fn get(&self, key: &H256, _prefix: &[u8]) -> Result<Option<DBValue>, String> {
+	fn get(&self, key: &H256, _prefix: Prefix) -> Result<Option<DBValue>, String> {
 		self.db.get(self.changes_tries_column, &key[..])
 			.map_err(|err| format!("{}", err))
 	}
 }
 
 #[cfg(test)]
 mod tests {
+	use hash_db::EMPTY_PREFIX;
 	use client::backend::{Backend as ClientBackend, NewBlockState, BlockImportOperation};
 	use client::blockchain::HeaderBackend as BlockchainHeaderBackend;
 	use sr_primitives::testing::Header;
@@ -320,7 +322,7 @@ mod tests {
 
 			let storage = backend.changes_tries_storage.storage();
 			for (key, (val, _)) in changes_trie_update.drain() {
-				assert_eq!(storage.get(&key, &[]), Ok(Some(val)));
+				assert_eq!(storage.get(&key, EMPTY_PREFIX), Ok(Some(val)));
 			}
 		};
 
@@ -463,34 +465,34 @@ mod tests {
 		let mut tx = DBTransaction::new();
 		backend.changes_tries_storage.prune(&mut tx, blocks[0], Default::default(), 12).unwrap();
 		backend.storage.db.write(tx).unwrap();
-		assert!(backend.changes_tries_storage.get(&root1, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root2, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root3, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root4, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root5, &[]).unwrap().is_some());
-		assert!(backend.changes_tries_storage.get(&root6, &[]).unwrap().is_some());
-		assert!(backend.changes_tries_storage.get(&root7, &[]).unwrap().is_some());
-		assert!(backend.changes_tries_storage.get(&root8, &[]).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root1, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root2, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root3, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root4, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root5, EMPTY_PREFIX).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root6, EMPTY_PREFIX).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root7, EMPTY_PREFIX).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root8, EMPTY_PREFIX).unwrap().is_some());
 
 		// now simulate finalization of block#16, causing prune of tries at #5..#8
 		let mut tx = DBTransaction::new();
 		backend.changes_tries_storage.prune(&mut tx, blocks[0], Default::default(), 16).unwrap();
 		backend.storage.db.write(tx).unwrap();
-		assert!(backend.changes_tries_storage.get(&root5, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root6, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root7, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root8, &[]).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root5, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root6, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root7, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root8, EMPTY_PREFIX).unwrap().is_none());
 
 		// now "change" pruning mode to archive && simulate finalization of block#20
 		// => no changes tries are pruned, because we never prune in archive mode
 		backend.changes_tries_storage.min_blocks_to_keep = None;
 		let mut tx = DBTransaction::new();
 		backend.changes_tries_storage.prune(&mut tx, blocks[0], Default::default(), 20).unwrap();
 		backend.storage.db.write(tx).unwrap();
-		assert!(backend.changes_tries_storage.get(&root9, &[]).unwrap().is_some());
-		assert!(backend.changes_tries_storage.get(&root10, &[]).unwrap().is_some());
-		assert!(backend.changes_tries_storage.get(&root11, &[]).unwrap().is_some());
-		assert!(backend.changes_tries_storage.get(&root12, &[]).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root9, EMPTY_PREFIX).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root10, EMPTY_PREFIX).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root11, EMPTY_PREFIX).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root12, EMPTY_PREFIX).unwrap().is_some());
 	}
 
 	#[test]
@@ -547,15 +549,15 @@ mod tests {
 		let mut tx = DBTransaction::new();
 		backend.changes_tries_storage.prune(&mut tx, blocks[1], blocks[5], 5).unwrap();
 		backend.storage.db.write(tx).unwrap();
-		assert!(backend.changes_tries_storage.get(&root1, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root2, &[]).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root1, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root2, EMPTY_PREFIX).unwrap().is_some());
 
 		// now simulate finalization of block#6, causing prune of tries at #2
 		let mut tx = DBTransaction::new();
 		backend.changes_tries_storage.prune(&mut tx, blocks[1], blocks[6], 6).unwrap();
 		backend.storage.db.write(tx).unwrap();
-		assert!(backend.changes_tries_storage.get(&root2, &[]).unwrap().is_none());
-		assert!(backend.changes_tries_storage.get(&root3, &[]).unwrap().is_some());
+		assert!(backend.changes_tries_storage.get(&root2, EMPTY_PREFIX).unwrap().is_none());
+		assert!(backend.changes_tries_storage.get(&root3, EMPTY_PREFIX).unwrap().is_some());
 	}
 
 	#[test]

core/client/db/src/lib.rs

@@ -1304,7 +1304,7 @@ where Block: BlockT<Hash=H256> {}
 
 #[cfg(test)]
 pub(crate) mod tests {
-	use hash_db::HashDB;
+	use hash_db::{HashDB, EMPTY_PREFIX};
 	use super::*;
 	use crate::columns;
 	use client::backend::Backend as BTrait;

core/client/src/client.rs

@@ -649,7 +649,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 				self
 			}
 
-			fn get(&self, key: &H256, prefix: &[u8]) -> Result<Option<DBValue>, String> {
+			fn get(&self, key: &H256, prefix: Prefix) -> Result<Option<DBValue>, String> {
 				self.storage.get(key, prefix)
 			}
 		}

core/client/src/in_mem.rs

@@ -24,6 +24,7 @@ use sr_primitives::generic::BlockId;
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, Zero, NumberFor};
 use sr_primitives::{Justification, StorageOverlay, ChildrenStorageOverlay};
 use state_machine::backend::{Backend as StateBackend, InMemory};
+
 use hash_db::Hasher;
 use trie::MemoryDB;
 

core/state-machine/src/changes_trie/mod.rs

@@ -51,7 +51,7 @@ pub use self::changes_iterator::{
 pub use self::prune::{prune, oldest_non_pruned_trie};
 
 use std::convert::TryInto;
-use hash_db::Hasher;
+use hash_db::{Hasher, Prefix};
 use crate::backend::Backend;
 use num_traits::{One, Zero};
 use parity_codec::{Decode, Encode};

core/state-machine/src/changes_trie/storage.rs

@@ -17,7 +17,7 @@
 //! Changes trie storage utilities.
 
 use std::collections::BTreeMap;
-use hash_db::{Hasher, Prefix};
+use hash_db::{Hasher, Prefix, EMPTY_PREFIX};
 use trie::DBValue;
 use trie::MemoryDB;
 use parking_lot::RwLock;
@@ -69,7 +69,7 @@ impl<H: Hasher, Number: BlockNumber> InMemoryStorage<H, Number> {
 
 		let mut proof_db = MemoryDB::<H>::default();
 		for item in proof {
-			proof_db.insert(&[], &item);
+			proof_db.insert(EMPTY_PREFIX, &item);
 		}
 		Self::with_db(proof_db)
 	}
@@ -147,7 +147,7 @@ impl<H: Hasher, Number: BlockNumber> Storage<H, Number> for InMemoryStorage<H, N
 		self
 	}
 
-	fn get(&self, key: &H::Out, prefix: &[u8]) -> Result<Option<DBValue>, String> {
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>, String> {
 		MemoryDB::<H>::get(&self.data.read().mdb, key, prefix)
 	}
 }

core/state-machine/src/ext.rs

@@ -388,6 +388,8 @@ mod tests {
 		let state = Some(ChangesTrieState::new(changes_trie_config(), Zero::zero(), &storage));
 		let backend = TestBackend::default();
 		let mut ext = TestExt::new(&mut overlay, &backend, state.as_ref(), None);
+		let root = hex!("bb0c2ef6e1d36d5490f9766cfcc7dfe2a6ca804504c3bb206053890d6dd02376").into();
+
 		assert_eq!(ext.storage_changes_root(Default::default()).unwrap(),
 			Some(root));
 	}
@@ -400,6 +402,8 @@ mod tests {
 		let state = Some(ChangesTrieState::new(changes_trie_config(), Zero::zero(), &storage));
 		let backend = TestBackend::default();
 		let mut ext = TestExt::new(&mut overlay, &backend, state.as_ref(), None);
+		let root = hex!("96f5aae4690e7302737b6f9b7f8567d5bbb9eac1c315f80101235a92d9ec27f4").into();
+
 		assert_eq!(ext.storage_changes_root(Default::default()).unwrap(),
 			Some(root));
 	}

node/runtime/src/lib.rs

@@ -79,8 +79,8 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// and set impl_version to equal spec_version. If only runtime
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
-	spec_version: 126,
-	impl_version: 127,
+	spec_version: 130,
+	impl_version: 130,
 	apis: RUNTIME_API_VERSIONS,
 };