avoid key collision on child trie and proof on child trie

core/client/db/src/lib.rs

@@ -47,14 +47,15 @@ use hash_db::{Hasher, Prefix};
 use kvdb::{KeyValueDB, DBTransaction};
 use trie::{MemoryDB, PrefixedMemoryDB, prefixed_key};
 use parking_lot::{Mutex, RwLock};
-use primitives::{H256, Blake2Hasher, ChangesTrieConfiguration, convert_hash};
+use primitives::{H256, Blake2Hasher, ChangesTrieConfiguration, convert_hash,
+	child_trie::{ChildTrie, ChildTrieReadRef}};
 use primitives::storage::well_known_keys;
 use sr_primitives::{
 	generic::{BlockId, DigestItem}, Justification, StorageOverlay, ChildrenStorageOverlay,
 	BuildStorage
 };
 use sr_primitives::traits::{
-	Block as BlockT, Header as HeaderT, NumberFor, Zero, One, SaturatedConversion
+	Block as BlockT, Header as HeaderT, NumberFor, Zero, One, SaturatedConversion,
 };
 use state_machine::backend::Backend as StateBackend;
 use executor::RuntimeInfo;
@@ -109,7 +110,7 @@ impl<B: BlockT> Drop for RefTrackingState<B> {
 }
 
 impl<B: BlockT> StateBackend<Blake2Hasher> for RefTrackingState<B> {
-	type Error =  <DbState as StateBackend<Blake2Hasher>>::Error;
+	type Error = <DbState as StateBackend<Blake2Hasher>>::Error;
 	type Transaction = <DbState as StateBackend<Blake2Hasher>>::Transaction;
 	type TrieBackendStorage = <DbState as StateBackend<Blake2Hasher>>::TrieBackendStorage;
 
@@ -121,16 +122,20 @@ impl<B: BlockT> StateBackend<Blake2Hasher> for RefTrackingState<B> {
 		self.state.storage_hash(key)
 	}
 
-	fn child_storage(&self, storage_key: &[u8], key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
-		self.state.child_storage(storage_key, key)
+	fn child_trie(&self, storage_key: &[u8]) -> Result<Option<ChildTrie>, Self::Error> {
+		self.state.child_trie(storage_key)
+	}
+
+	fn child_storage(&self, child_trie: ChildTrieReadRef, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.child_storage(child_trie, key)
 	}
 
 	fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> {
 		self.state.exists_storage(key)
 	}
 
-	fn exists_child_storage(&self, storage_key: &[u8], key: &[u8]) -> Result<bool, Self::Error> {
-		self.state.exists_child_storage(storage_key, key)
+	fn exists_child_storage(&self, child_trie: ChildTrieReadRef, key: &[u8]) -> Result<bool, Self::Error> {
+		self.state.exists_child_storage(child_trie, key)
 	}
 
 	fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F) {
@@ -141,12 +146,17 @@ impl<B: BlockT> StateBackend<Blake2Hasher> for RefTrackingState<B> {
 		self.state.for_key_values_with_prefix(prefix, f)
 	}
 
-	fn for_keys_in_child_storage<F: FnMut(&[u8])>(&self, storage_key: &[u8], f: F) {
-		self.state.for_keys_in_child_storage(storage_key, f)
+	fn for_keys_in_child_storage<F: FnMut(&[u8])>(&self, child_trie: ChildTrieReadRef, f: F) {
+		self.state.for_keys_in_child_storage(child_trie, f)
 	}
 
-	fn for_child_keys_with_prefix<F: FnMut(&[u8])>(&self, storage_key: &[u8], prefix: &[u8], f: F) {
-		self.state.for_child_keys_with_prefix(storage_key, prefix, f)
+	fn for_child_keys_with_prefix<F: FnMut(&[u8])>(
+		&self,
+		child_trie: ChildTrieReadRef,
+		prefix: &[u8],
+		f: F,
+	) {
+		self.state.for_child_keys_with_prefix(child_trie, prefix, f)
 	}
 
 	fn storage_root<I>(&self, delta: I) -> (H256, Self::Transaction)
@@ -156,11 +166,11 @@ impl<B: BlockT> StateBackend<Blake2Hasher> for RefTrackingState<B> {
 		self.state.storage_root(delta)
 	}
 
-	fn child_storage_root<I>(&self, storage_key: &[u8], delta: I) -> (Vec<u8>, bool, Self::Transaction)
+	fn child_storage_root<I>(&self, child_trie: &ChildTrie, delta: I) -> (Vec<u8>, bool, Self::Transaction)
 		where
 			I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>,
 	{
-		self.state.child_storage_root(storage_key, delta)
+		self.state.child_storage_root(child_trie, delta)
 	}
 
 	fn pairs(&self) -> Vec<(Vec<u8>, Vec<u8>)> {
@@ -171,8 +181,8 @@ impl<B: BlockT> StateBackend<Blake2Hasher> for RefTrackingState<B> {
 		self.state.keys(prefix)
 	}
 
-	fn child_keys(&self, child_key: &[u8], prefix: &[u8]) -> Vec<Vec<u8>> {
-		self.state.child_keys(child_key, prefix)
+	fn child_keys(&self, child_trie: ChildTrieReadRef, prefix: &[u8]) -> Vec<Vec<u8>> {
+		self.state.child_keys(child_trie, prefix)
 	}
 
 	fn as_trie_backend(&mut self) -> Option<&state_machine::TrieBackend<Self::TrieBackendStorage, Blake2Hasher>> {
@@ -469,15 +479,10 @@ where Block: BlockT<Hash=H256>,
 			return Err(client::error::Error::GenesisInvalid.into());
 		}
 
-		for child_key in children.keys() {
-			if !well_known_keys::is_child_storage_key(&child_key) {
-				return Err(client::error::Error::GenesisInvalid.into());
-			}
-		}
 
 		let child_delta = children.into_iter()
-			.map(|(storage_key, child_overlay)|
-				(storage_key, child_overlay.into_iter().map(|(k, v)| (k, Some(v)))));
+			.map(|(_storage_key, (child_overlay, subtrie))|
+				(subtrie, child_overlay.into_iter().map(|(k, v)| (k, Some(v)))));
 
 		let (root, transaction) = self.old_state.full_storage_root(
 			top.into_iter().map(|(k, v)| (k, Some(v))),
@@ -553,8 +558,10 @@ struct DbGenesisStorage(pub H256);
 impl DbGenesisStorage {
 	pub fn new() -> Self {
 		let mut root = H256::default();
-		let mut mdb = MemoryDB::<Blake2Hasher>::default();
-		state_machine::TrieDBMut::<Blake2Hasher>::new(&mut mdb, &mut root);
+		{
+			let mut mdb = MemoryDB::<Blake2Hasher>::default();
+			state_machine::TrieDBMut::<Blake2Hasher>::new(&mut mdb, &mut root);
+		}
 		DbGenesisStorage(root)
 	}
 }
@@ -1713,6 +1720,7 @@ mod tests {
 			).unwrap();
 
 			backend.commit_operation(op).unwrap();
+
 			assert_eq!(backend.storage.db.get(
 				columns::STATE,
 				&trie::prefixed_key::<Blake2Hasher>(&key, EMPTY_PREFIX)
@@ -1787,7 +1795,6 @@ mod tests {
 
 			backend.commit_operation(op).unwrap();
 
-
 			assert!(backend.storage.db.get(
 				columns::STATE,
 				&trie::prefixed_key::<Blake2Hasher>(&key, EMPTY_PREFIX)

core/client/db/src/storage_cache.rs

@@ -24,6 +24,9 @@ use hash_db::Hasher;
 use sr_primitives::traits::{Block as BlockT, Header};
 use state_machine::{backend::Backend as StateBackend, TrieBackend};
 use log::trace;
+use primitives::child_trie::ChildTrie;
+use primitives::child_trie::ChildTrieReadRef;
+
 use super::{StorageCollection, ChildStorageCollection};
 use std::hash::Hash as StdHash;
 const STATE_CACHE_BLOCKS: usize = 12;
@@ -39,6 +42,7 @@ pub struct Cache<B: BlockT, H: Hasher> {
 	/// Storage hashes cache. `None` indicates that key is known to be missing.
 	lru_hashes: LRUMap<StorageKey, OptionHOut<H::Out>>,
 	/// Storage cache for child trie. `None` indicates that key is known to be missing.
+	/// Key is a pair of child trie `KeySpace` and `Key` for value in the child trie.
 	lru_child_storage: LRUMap<ChildStorageKey, Option<StorageValue>>,
 	/// Information on the modifications in recently committed blocks; specifically which keys
 	/// changed in which block. Ordered by block number.
@@ -149,7 +153,7 @@ impl<B: BlockT, H: Hasher> Cache<B, H> {
 	pub fn used_storage_cache_size(&self) -> usize {
 		self.lru_storage.used_size()
 			+ self.lru_child_storage.used_size()
-			//  ignore small hashes storage and self.lru_hashes.used_size()
+			// ignore small hashes storage and self.lru_hashes.used_size()
 	}
 
 	/// Synchronize the shared cache with the best block state.
@@ -504,8 +508,12 @@ impl<H: Hasher, S: StateBackend<H>, B: BlockT> StateBackend<H> for CachingState<
 		Ok(hash)
 	}
 
-	fn child_storage(&self, storage_key: &[u8], key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
-		let key = (storage_key.to_vec(), key.to_vec());
+	fn child_storage(
+		&self,
+		child_trie: ChildTrieReadRef,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		let key = (child_trie.keyspace().to_vec(), key.to_vec());
 		let local_cache = self.cache.local_cache.upgradable_read();
 		if let Some(entry) = local_cache.child_storage.get(&key).cloned() {
 			trace!("Found in local cache: {:?}", key);
@@ -519,7 +527,7 @@ impl<H: Hasher, S: StateBackend<H>, B: BlockT> StateBackend<H> for CachingState<
 			}
 		}
 		trace!("Cache miss: {:?}", key);
-		let value = self.state.child_storage(storage_key, &key.1[..])?;
+		let value = self.state.child_storage(child_trie, &key.1[..])?;
 		RwLockUpgradableReadGuard::upgrade(local_cache).child_storage.insert(key, value.clone());
 		Ok(value)
 	}
@@ -528,8 +536,8 @@ impl<H: Hasher, S: StateBackend<H>, B: BlockT> StateBackend<H> for CachingState<
 		Ok(self.storage(key)?.is_some())
 	}
 
-	fn exists_child_storage(&self, storage_key: &[u8], key: &[u8]) -> Result<bool, Self::Error> {
-		self.state.exists_child_storage(storage_key, key)
+	fn exists_child_storage(&self, child_trie: ChildTrieReadRef, key: &[u8]) -> Result<bool, Self::Error> {
+		self.state.exists_child_storage(child_trie, key)
 	}
 
 	fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F) {
@@ -540,12 +548,12 @@ impl<H: Hasher, S: StateBackend<H>, B: BlockT> StateBackend<H> for CachingState<
 		self.state.for_key_values_with_prefix(prefix, f)
 	}
 
-	fn for_keys_in_child_storage<F: FnMut(&[u8])>(&self, storage_key: &[u8], f: F) {
-		self.state.for_keys_in_child_storage(storage_key, f)
+	fn for_keys_in_child_storage<F: FnMut(&[u8])>(&self, child_trie: ChildTrieReadRef, f: F) {
+		self.state.for_keys_in_child_storage(child_trie, f)
 	}
 
-	fn for_child_keys_with_prefix<F: FnMut(&[u8])>(&self, storage_key: &[u8], prefix: &[u8], f: F) {
-		self.state.for_child_keys_with_prefix(storage_key, prefix, f)
+	fn for_child_keys_with_prefix<F: FnMut(&[u8])>(&self, child_trie: ChildTrieReadRef, prefix: &[u8], f: F) {
+		self.state.for_child_keys_with_prefix(child_trie, prefix, f)
 	}
 
 	fn storage_root<I>(&self, delta: I) -> (H::Out, Self::Transaction)
@@ -556,12 +564,12 @@ impl<H: Hasher, S: StateBackend<H>, B: BlockT> StateBackend<H> for CachingState<
 		self.state.storage_root(delta)
 	}
 
-	fn child_storage_root<I>(&self, storage_key: &[u8], delta: I) -> (Vec<u8>, bool, Self::Transaction)
+	fn child_storage_root<I>(&self, child_trie: &ChildTrie, delta: I) -> (Vec<u8>, bool, Self::Transaction)
 		where
 			I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>,
 			H::Out: Ord
 	{
-		self.state.child_storage_root(storage_key, delta)
+		self.state.child_storage_root(child_trie, delta)
 	}
 
 	fn pairs(&self) -> Vec<(Vec<u8>, Vec<u8>)> {
@@ -572,8 +580,8 @@ impl<H: Hasher, S: StateBackend<H>, B: BlockT> StateBackend<H> for CachingState<
 		self.state.keys(prefix)
 	}
 
-	fn child_keys(&self, child_key: &[u8], prefix: &[u8]) -> Vec<Vec<u8>> {
-		self.state.child_keys(child_key, prefix)
+	fn child_keys(&self, child_trie: ChildTrieReadRef, prefix: &[u8]) -> Vec<Vec<u8>> {
+		self.state.child_keys(child_trie, prefix)
 	}
 
 	fn as_trie_backend(&mut self) -> Option<&TrieBackend<Self::TrieBackendStorage, H>> {

core/client/src/client.rs

@@ -30,6 +30,8 @@ use primitives::{
 	NeverNativeValue, ExecutionContext, NativeOrEncoded,
 	storage::{StorageKey, StorageData, well_known_keys},
 	offchain,
+	child_trie::{ChildTrie, ChildTrieReadRef},
+	storage::StorageKeySpace,
 };
 use substrate_telemetry::{telemetry, SUBSTRATE_INFO};
 use sr_primitives::{
@@ -145,7 +147,7 @@ pub trait BlockchainEvents<Block: BlockT> {
 	fn storage_changes_notification_stream(
 		&self,
 		filter_keys: Option<&[StorageKey]>,
-		child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+		child_filter_keys: Option<&[(StorageKeySpace, Option<Vec<StorageKey>>)]>,
 	) -> error::Result<StorageEventStream<Block::Hash>>;
 }
 
@@ -308,10 +310,10 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		execution_strategies: ExecutionStrategies
 	) -> error::Result<Self> {
 		if backend.blockchain().header(BlockId::Number(Zero::zero()))?.is_none() {
-			let (genesis_storage, children_genesis_storage) = build_genesis_storage.build_storage()?;
+			let genesis_storage = build_genesis_storage.build_storage()?;
 			let mut op = backend.begin_operation()?;
 			backend.begin_state_operation(&mut op, BlockId::Hash(Default::default()))?;
-			let state_root = op.reset_storage(genesis_storage, children_genesis_storage)?;
+			let state_root = op.reset_storage(genesis_storage.top, genesis_storage.children)?;
 			let genesis_block = genesis::construct_genesis_block::<Block>(state_root.into());
 			info!("Initializing Genesis block/state (state: {}, header-hash: {})",
 				genesis_block.header().state_root(),
@@ -371,6 +373,18 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		)
 	}
 
+	/// Given a `BlockId` and a child storage key,
+	/// return the matching child storage keys.
+	pub fn child_trie(
+		&self,
+		id: &BlockId<Block>,
+		child_key: &StorageKey
+	) -> error::Result<Option<ChildTrie>> {
+		self.state_at(id)?
+			.child_trie(&child_key.0[..])
+			.map_err(|e| error::Error::from_state(Box::new(e)))
+	}
+
 	/// Given a `BlockId` and a key, return the value under the hash in that block.
 	pub fn storage_hash(&self, id: &BlockId<Block>, key: &StorageKey)
 		-> error::Result<Option<Block::Hash>> {
@@ -383,38 +397,39 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 	pub fn child_storage_keys(
 		&self,
 		id: &BlockId<Block>,
-		child_storage_key: &StorageKey,
+		child_trie: ChildTrieReadRef,
 		key_prefix: &StorageKey
 	) -> error::Result<Vec<StorageKey>> {
 		let keys = self.state_at(id)?
-			.child_keys(&child_storage_key.0, &key_prefix.0)
+			.child_keys(child_trie, &key_prefix.0)
 			.into_iter()
 			.map(StorageKey)
 			.collect();
 		Ok(keys)
 	}
 
-	/// Given a `BlockId`, a key and a child storage key, return the value under the key in that block.
+	/// Given a `BlockId`, a key and a child trie reference,
+	/// return the value under the key in that block.
 	pub fn child_storage(
 		&self,
 		id: &BlockId<Block>,
-		child_storage_key: &StorageKey,
+		child_trie: ChildTrieReadRef,
 		key: &StorageKey
 	) -> error::Result<Option<StorageData>> {
 		Ok(self.state_at(id)?
-			.child_storage(&child_storage_key.0, &key.0).map_err(|e| error::Error::from_state(Box::new(e)))?
+			.child_storage(child_trie, &key.0).map_err(|e| error::Error::from_state(Box::new(e)))?
 			.map(StorageData))
 	}
 
 	/// Given a `BlockId`, a key and a child storage key, return the hash under the key in that block.
 	pub fn child_storage_hash(
 		&self,
 		id: &BlockId<Block>,
-		child_storage_key: &StorageKey,
+		child_trie: ChildTrieReadRef,
 		key: &StorageKey
 	) -> error::Result<Option<Block::Hash>> {
 		Ok(self.state_at(id)?
-			.child_storage_hash(&child_storage_key.0, &key.0).map_err(|e| error::Error::from_state(Box::new(e)))?
+			.child_storage_hash(child_trie, &key.0).map_err(|e| error::Error::from_state(Box::new(e)))?
 		)
 	}
 
@@ -443,16 +458,16 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 				.map_err(Into::into))
 	}
 
-	/// Reads child storage value at a given block + storage_key + key, returning
+	/// Reads child storage value at a given block + child trie reference + key, returning
 	/// read proof.
 	pub fn read_child_proof(
 		&self,
 		id: &BlockId<Block>,
-		storage_key: &[u8],
+		child_trie: ChildTrieReadRef,
 		key: &[u8]
 	) -> error::Result<Vec<Vec<u8>>> {
 		self.state_at(id)
-			.and_then(|state| prove_child_read(state, storage_key, key)
+			.and_then(|state| prove_child_read(state, child_trie, key)
 				.map(|(_, proof)| proof)
 				.map_err(Into::into))
 	}
@@ -1058,7 +1073,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 				overlay.commit_prospective();
 
 				let (top, children) = overlay.into_committed();
-				let children = children.map(|(sk, it)| (sk, it.collect())).collect();
+				let children = children.map(|(ks, it)| (ks, it.collect())).collect();
 				if import_headers.post().state_root() != &storage_update.1 {
 					return Err(error::Error::InvalidStateRoot);
 				}
@@ -1607,7 +1622,7 @@ where
 	fn storage_changes_notification_stream(
 		&self,
 		filter_keys: Option<&[StorageKey]>,
-		child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+		child_filter_keys: Option<&[(StorageKeySpace, Option<Vec<StorageKey>>)]>,
 	) -> error::Result<StorageEventStream<Block::Hash>> {
 		Ok(self.storage_notifications.lock().listen(filter_keys, child_filter_keys))
 	}