Multiple storage root support (#902)

* Implement a non generic version of child delta trie

* Use delta_trie_root in state_machine

* Expand InMemory backend to support multi-storage

* Create Consolidate trait

* Fix all crate compile and remove unused OverlayedChanges::drain

* Implement child storage root support and overlay changes

* Add child storage reader

* Add child storage writer

* Implement child storage cleaning

* Fix light backend compile

* Add all required ext functions for wasm executor

* Add ext def to io

* Add all io functions

* Fix nostd compile

* Add simple test

* Remove unnecessary vec copy in child_storage_root_transaction

* Use values_mut/for_each to make it shorter

* Use extend to shorter a for loop

* Move record_all_keys to trie so it's easier to generic them later

* space -> tab

* Remove to_owned in debug format

* Clean out all to_owned

* Break debug_trace to multiple lines

* Remove 0..

* UserError copy/paste typo

* Replace Vec::from_raw_parts by slice::from_raw_parts

* Use iter::empty()

* Wrap some long lines

* Wrap a missing line

* Remove unnecessary map

https://github.com/paritytech/substrate/pull/856#discussion_r226222663

* Call ext_free after from_raw_parts

* Fix tests in other crates

substrate/core/sr-io/with_std.rs

@@ -47,6 +47,12 @@ pub fn storage(key: &[u8]) -> Option<Vec<u8>> {
 		.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()))
+		.expect("storage cannot be called outside of an Externalities-provided environment.")
+}
+
 /// Get `key` from storage, placing the value into `value_out` (as much of it as possible) and return
 /// 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
@@ -55,7 +61,20 @@ pub fn read_storage(key: &[u8], value_out: &mut [u8], value_offset: usize) -> Op
 	ext::with(|ext| ext.storage(key).map(|value| {
 		let value = &value[value_offset..];
 		let written = ::std::cmp::min(value.len(), value_out.len());
-		value_out[0..written].copy_from_slice(&value[0..written]);
+		value_out[..written].copy_from_slice(&value[..written]);
+		value.len()
+	})).expect("read_storage cannot be called outside of an Externalities-provided environment.")
+}
+
+/// Get `key` from child storage, placing the value into `value_out` (as much of it as possible) and return
+/// 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| {
+		let value = &value[value_offset..];
+		let written = ::std::cmp::min(value.len(), value_out.len());
+		value_out[..written].copy_from_slice(&value[..written]);
 		value.len()
 	})).expect("read_storage cannot be called outside of an Externalities-provided environment.")
 }
@@ -67,6 +86,13 @@ 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]) {
+	ext::with(|ext|
+		ext.set_child_storage(storage_key.to_vec(), key.to_vec(), value.to_vec())
+	);
+}
+
 /// Clear the storage of a key.
 pub fn clear_storage(key: &[u8]) {
 	ext::with(|ext|
@@ -74,6 +100,13 @@ pub fn clear_storage(key: &[u8]) {
 	);
 }
 
+/// Clear the storage of a key.
+pub fn clear_child_storage(storage_key: &[u8], key: &[u8]) {
+	ext::with(|ext|
+		ext.clear_child_storage(storage_key, key)
+	);
+}
+
 /// Check whether a given `key` exists in storage.
 pub fn exists_storage(key: &[u8]) -> bool {
 	ext::with(|ext|
@@ -81,6 +114,13 @@ pub fn exists_storage(key: &[u8]) -> bool {
 	).unwrap_or(false)
 }
 
+/// Check whether a given `key` exists in storage.
+pub fn exists_child_storage(storage_key: &[u8], key: &[u8]) -> bool {
+	ext::with(|ext|
+		ext.exists_child_storage(storage_key, key)
+	).unwrap_or(false)
+}
+
 /// Clear the storage entries with a key that starts with the given prefix.
 pub fn clear_prefix(prefix: &[u8]) {
 	ext::with(|ext|
@@ -88,6 +128,13 @@ pub fn clear_prefix(prefix: &[u8]) {
 	);
 }
 
+/// Clear an entire child storage.
+pub fn kill_child_storage(storage_key: &[u8]) {
+	ext::with(|ext|
+		ext.kill_child_storage(storage_key)
+	);
+}
+
 /// The current relay chain identifier.
 pub fn chain_id() -> u64 {
 	ext::with(|ext|
@@ -102,6 +149,13 @@ pub fn storage_root() -> H256 {
 	).unwrap_or(H256::new())
 }
 
+/// "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(block: u64) -> Option<H256> {
 	ext::with(|ext|