commit before wasm_executor change (we will keep old interface for now:

huge performance cost for wasm but need to get feedback on best/safe
wasm design).

core/primitives/src/lib.rs

@@ -288,7 +288,14 @@ impl SubTrie {
 			parent,
 		}
 	}
+  /// encoded parent trie node content
 	pub fn encoded_node(&self) -> Vec<u8> {
 		parity_codec::Encode::encode(&self.node)
 	}
+  /// encoded parent trie node content
+	pub fn parent_storage_key(&self) -> Vec<u8> {
+    // !! TODO EMCH (there is probably many places with incorrect parent key usage)
+    unimplemented!("TODO build from well known key or better build on construct: create a setter and make parentn non public");
+	}
+
 }

core/sr-io/with_std.rs

@@ -19,7 +19,7 @@ pub use parity_codec as codec;
 // re-export hashing functions.
 pub use primitives::{
 	blake2_256, twox_128, twox_256, ed25519, Blake2Hasher, sr25519,
-	Pair
+	Pair, SubTrie,
 };
 pub use tiny_keccak::keccak256 as keccak_256;
 // Switch to this after PoC-3
@@ -43,13 +43,19 @@ pub type ChildrenStorageOverlay = HashMap<Vec<u8>, StorageOverlay>;
 
 /// Get `key` from storage and return a `Vec`, empty if there's a problem.
 pub fn storage(key: &[u8]) -> Option<Vec<u8>> {
-	ext::with(|ext| ext.storage(key).map(|s| s.to_vec()))
+	ext::with(|ext| ext.storage(key))
 		.expect("storage cannot be called outside of an Externalities-provided environment.")
 }
 
 /// Get `key` from child storage and return a `Vec`, empty if there's a problem.
-pub fn child_storage(storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {
-	ext::with(|ext| ext.child_storage(storage_key, key).map(|s| s.to_vec()))
+pub fn child_storage(subtrie: &SubTrie, key: &[u8]) -> Option<Vec<u8>> {
+	ext::with(|ext| ext.child_storage(subtrie, key))
+		.expect("storage cannot be called outside of an Externalities-provided environment.")
+}
+
+/// get child trie at storage key location
+pub fn get_child_trie(storage_key: &[u8]) -> Option<SubTrie> {
+	ext::with(|ext| ext.get_child_trie(storage_key))
 		.expect("storage cannot be called outside of an Externalities-provided environment.")
 }
 
@@ -70,8 +76,8 @@ pub fn read_storage(key: &[u8], value_out: &mut [u8], value_offset: usize) -> Op
 /// the number of bytes that the entry in storage had beyond the offset or None if the storage entry
 /// doesn't exist at all. Note that if the buffer is smaller than the storage entry length, the returned
 /// number of bytes is not equal to the number of bytes written to the `value_out`.
-pub fn read_child_storage(storage_key: &[u8], key: &[u8], value_out: &mut [u8], value_offset: usize) -> Option<usize> {
-	ext::with(|ext| ext.child_storage(storage_key, key).map(|value| {
+pub fn read_child_storage(subtrie: &SubTrie, key: &[u8], value_out: &mut [u8], value_offset: usize) -> Option<usize> {
+	ext::with(|ext| ext.child_storage(subtrie, key).map(|value| {
 		let value = &value[value_offset..];
 		let written = ::std::cmp::min(value.len(), value_out.len());
 		value_out[..written].copy_from_slice(&value[..written]);
@@ -87,9 +93,9 @@ pub fn set_storage(key: &[u8], value: &[u8]) {
 }
 
 /// Set the child storage of a key to some value.
-pub fn set_child_storage(storage_key: &[u8], key: &[u8], value: &[u8]) {
+pub fn set_child_storage(subtrie: &SubTrie, key: &[u8], value: &[u8]) {
 	ext::with(|ext|
-		ext.set_child_storage(storage_key.to_vec(), key.to_vec(), value.to_vec())
+		ext.set_child_storage(subtrie, key.to_vec(), value.to_vec())
 	);
 }
 
@@ -101,9 +107,9 @@ pub fn clear_storage(key: &[u8]) {
 }
 
 /// Clear the storage of a key.
-pub fn clear_child_storage(storage_key: &[u8], key: &[u8]) {
+pub fn clear_child_storage(subtrie: &SubTrie, key: &[u8]) {
 	ext::with(|ext|
-		ext.clear_child_storage(storage_key, key)
+		ext.clear_child_storage(subtrie, key)
 	);
 }
 
@@ -115,9 +121,9 @@ pub fn exists_storage(key: &[u8]) -> bool {
 }
 
 /// Check whether a given `key` exists in storage.
-pub fn exists_child_storage(storage_key: &[u8], key: &[u8]) -> bool {
+pub fn exists_child_storage(subtrie: &SubTrie, key: &[u8]) -> bool {
 	ext::with(|ext|
-		ext.exists_child_storage(storage_key, key)
+		ext.exists_child_storage(subtrie, key)
 	).unwrap_or(false)
 }
 
@@ -129,9 +135,9 @@ pub fn clear_prefix(prefix: &[u8]) {
 }
 
 /// Clear an entire child storage.
-pub fn kill_child_storage(storage_key: &[u8]) {
+pub fn kill_child_storage(subtrie: &SubTrie) {
 	ext::with(|ext|
-		ext.kill_child_storage(storage_key)
+		ext.kill_child_storage(subtrie)
 	);
 }
 
@@ -149,13 +155,6 @@ pub fn storage_root() -> H256 {
 	).unwrap_or(H256::zero())
 }
 
-/// "Commit" all existing operations and compute the resultant child storage root.
-pub fn child_storage_root(storage_key: &[u8]) -> Option<Vec<u8>> {
-	ext::with(|ext|
-		ext.child_storage_root(storage_key)
-	).unwrap_or(None)
-}
-
 /// "Commit" all existing operations and get the resultant storage change root.
 pub fn storage_changes_root(parent_hash: [u8; 32], parent_num: u64) -> Option<H256> {
 	ext::with(|ext|

core/sr-io/without_std.rs

@@ -475,7 +475,7 @@ pub fn storage_root() -> [u8; 32] {
 }
 
 /// "Commit" all existing operations and compute the resultant child storage root.
-pub fn child_storage_root(storage_key: &[u8]) -> Option<Vec<u8>> {
+pub fn child_storage_root(subtrie: &SubTrie) -> Vec<u8> {
 	let mut length: u32 = 0;
 	unsafe {
 		let ptr = ext_child_storage_root.get()(storage_key.as_ptr(), storage_key.len() as u32, &mut length);

core/state-machine/src/basic.rs

@@ -22,6 +22,7 @@ use hash_db::Hasher;
 use heapsize::HeapSizeOf;
 use trie::trie_root;
 use primitives::storage::well_known_keys::{CHANGES_TRIE_CONFIG, CODE, HEAP_PAGES};
+use primitives::SubTrie;
 use parity_codec::Encode;
 use super::{Externalities, OverlayedChanges};
 use log::warn;
@@ -111,8 +112,8 @@ impl<H: Hasher> Externalities<H> for BasicExternalities where H::Out: Ord + Heap
 		}
 	}
 
-	fn child_storage(&self, _storage_key: &[u8], _key: &[u8]) -> Option<Vec<u8>> {
-		None
+	fn child_storage(&self, _subtrie: &SubTrie, _key: &[u8]) -> Option<Vec<u8>> {
+		unreachable!("basic not used for child trie");
 	}
 
 	fn place_storage(&mut self, key: Vec<u8>, maybe_value: Option<Vec<u8>>) {
@@ -128,11 +129,13 @@ impl<H: Hasher> Externalities<H> for BasicExternalities where H::Out: Ord + Heap
 		}
 	}
 
-	fn place_child_storage(&mut self, _storage_key: Vec<u8>, _key: Vec<u8>, _value: Option<Vec<u8>>) -> bool {
-		false
+	fn place_child_storage(&mut self, _subtrie: &SubTrie, _key: Vec<u8>, _value: Option<Vec<u8>>) {
+		unreachable!("basic not used for child trie");
 	}
 
-	fn kill_child_storage(&mut self, _storage_key: &[u8]) { }
+	fn kill_child_storage(&mut self, _subtrie: &SubTrie) {
+		unreachable!("basic not used for child trie");
+	}
 
 	fn clear_prefix(&mut self, prefix: &[u8]) {
 		self.changes.clear_prefix(prefix);
@@ -145,10 +148,6 @@ impl<H: Hasher> Externalities<H> for BasicExternalities where H::Out: Ord + Heap
 		trie_root::<H, _, _, _>(self.inner.clone())
 	}
 
-	fn child_storage_root(&mut self, _storage_key: &[u8]) -> Option<Vec<u8>> {
-		None
-	}
-
 	fn storage_changes_root(&mut self, _parent: H::Out, _parent_num: u64) -> Option<H::Out> {
 		None
 	}

core/state-machine/src/ext.rs

@@ -23,7 +23,8 @@ use crate::changes_trie::{AnchorBlockId, Storage as ChangesTrieStorage, compute_
 use crate::{Externalities, OverlayedChanges, OffchainExt};
 use hash_db::Hasher;
 use primitives::storage::well_known_keys::is_child_storage_key;
-use trie::{MemoryDB, TrieDBMut, TrieMut, default_child_trie_root, is_child_trie_key_valid};
+use primitives::SubTrie;
+use trie::{MemoryDB, TrieDBMut, TrieMut, default_child_trie_root};
 use heapsize::HeapSizeOf;
 
 const EXT_NOT_ALLOWED_TO_FAIL: &str = "Externalities not allowed to fail within runtime";
@@ -136,26 +137,26 @@ where
 	}
 
 	/// Fetch child storage root together with its transaction.
-	fn child_storage_root_transaction(&mut self, storage_key: &[u8]) -> (Vec<u8>, B::Transaction) {
+	fn child_storage_root_transaction(&mut self, subtrie: &SubTrie) -> (Vec<u8>, B::Transaction) {
 		self.mark_dirty();
 
 		let (root, is_default, transaction) = {
-			let delta = self.overlay.committed.children.get(storage_key)
+			let delta = self.overlay.committed.children.get(&subtrie.node.keyspace)
 				.into_iter()
 				.flat_map(|map| map.1.iter().map(|(k, v)| (k.clone(), v.clone())))
-				.chain(self.overlay.prospective.children.get(storage_key)
+				.chain(self.overlay.prospective.children.get(&subtrie.node.keyspace)
 						.into_iter()
 						.flat_map(|map| map.1.iter().map(|(k, v)| (k.clone(), v.clone()))));
 
-			self.backend.child_storage_root(storage_key, delta)
+			self.backend.child_storage_root(subtrie, delta)
 		};
 
 		let root_val = if is_default {
 			None
 		} else {
 			Some(root.clone())
 		};
-		self.overlay.sync_child_storage_root(storage_key, root_val);
+		self.overlay.sync_child_storage_root(subtrie, root_val);
 
 		(root, transaction)
 	}
@@ -204,10 +205,10 @@ where
 			self.backend.storage_hash(key).expect(EXT_NOT_ALLOWED_TO_FAIL))
 	}
 
-	fn child_storage(&self, storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage(&self, subtrie: &SubTrie, key: &[u8]) -> Option<Vec<u8>> {
 		let _guard = panic_handler::AbortGuard::new(true);
-		self.overlay.child_storage(storage_key, key).map(|x| x.map(|x| x.to_vec())).unwrap_or_else(||
-			self.backend.child_storage(storage_key, key).expect(EXT_NOT_ALLOWED_TO_FAIL))
+		self.overlay.child_storage(subtrie, key).map(|x| x.map(|x| x.to_vec())).unwrap_or_else(||
+			self.backend.child_storage(subtrie, key).expect(EXT_NOT_ALLOWED_TO_FAIL))
 	}
 
 	fn exists_storage(&self, key: &[u8]) -> bool {
@@ -218,11 +219,11 @@ where
 		}
 	}
 
-	fn exists_child_storage(&self, storage_key: &[u8], key: &[u8]) -> bool {
+	fn exists_child_storage(&self, subtrie: &SubTrie, key: &[u8]) -> bool {
 		let _guard = panic_handler::AbortGuard::new(true);
-		match self.overlay.child_storage(storage_key, key) {
+		match self.overlay.child_storage(subtrie, key) {
 			Some(x) => x.is_some(),
-			_ => self.backend.exists_child_storage(storage_key, key).expect(EXT_NOT_ALLOWED_TO_FAIL),
+			_ => self.backend.exists_child_storage(subtrie, key).expect(EXT_NOT_ALLOWED_TO_FAIL),
 		}
 	}
 
@@ -237,28 +238,21 @@ where
 		self.overlay.set_storage(key, value);
 	}
 
-	fn place_child_storage(&mut self, storage_key: Vec<u8>, key: Vec<u8>, value: Option<Vec<u8>>) -> bool {
+	fn place_child_storage(&mut self, subtrie: &SubTrie, key: Vec<u8>, value: Option<Vec<u8>>) {
 		let _guard = panic_handler::AbortGuard::new(true);
-		if !is_child_storage_key(&storage_key) || !is_child_trie_key_valid::<H>(&storage_key) {
-			return false;
-		}
 
 		self.mark_dirty();
-		self.overlay.set_child_storage(storage_key, key, value);
-
-		true
+		self.overlay.set_child_storage(&subtrie, key, value);
 	}
 
-	fn kill_child_storage(&mut self, storage_key: &[u8]) {
+	fn kill_child_storage(&mut self, subtrie: &SubTrie) {
 		let _guard = panic_handler::AbortGuard::new(true);
-		if !is_child_storage_key(storage_key) || !is_child_trie_key_valid::<H>(storage_key) {
-			return;
-		}
 
 		self.mark_dirty();
-		self.overlay.clear_child_storage(storage_key);
-		self.backend.for_keys_in_child_storage(storage_key, |key| {
-			self.overlay.set_child_storage(storage_key.to_vec(), key.to_vec(), None);
+		self.overlay.clear_child_storage(subtrie);
+	  self.overlay.sync_child_storage_root(subtrie, None);
+		self.backend.for_keys_in_child_storage(subtrie, |key| {
+			self.overlay.set_child_storage(subtrie, key.to_vec(), None);
 		});
 	}
 
@@ -287,10 +281,11 @@ where
 		}
 
 		let mut transaction = B::Transaction::default();
-		let child_storage_keys: Vec<_> = self.overlay.prospective.children.keys().cloned().collect();
+    // TODO avoid this clone somehow?
+		let child_storage_subtries: Vec<_> = self.overlay.prospective.children.values().map(|v|v.2.clone()).collect();
 
-		for key in child_storage_keys {
-			let (_, t) = self.child_storage_root_transaction(&key);
+		for subtrie in child_storage_subtries {
+			let (_, t) = self.child_storage_root_transaction(&subtrie);
 			transaction.consolidate(t);
 		}
 
@@ -304,19 +299,6 @@ where
 		root
 	}
 
-	fn child_storage_root(&mut self, storage_key: &[u8]) -> Option<Vec<u8>> {
-		let _guard = panic_handler::AbortGuard::new(true);
-		if !is_child_storage_key(storage_key) || !is_child_trie_key_valid::<H>(storage_key) {
-			return None;
-		}
-
-		if self.storage_transaction.is_some() {
-			return Some(self.storage(storage_key).unwrap_or(default_child_trie_root::<H>()));
-		}
-
-		Some(self.child_storage_root_transaction(storage_key).0)
-	}
-
 	fn storage_changes_root(&mut self, parent: H::Out, parent_num: u64) -> Option<H::Out> {
 		let _guard = panic_handler::AbortGuard::new(true);
 		let root_and_tx = compute_changes_trie_root::<_, T, H>(