moved_child is a bad idea, just delete in top, if it is reinserted this

will be handle by full_storage order.

core/primitives/src/child_trie.rs

@@ -18,6 +18,7 @@
 
 use parity_codec::{Encode, Decode};
 use rstd::prelude::*;
+use rstd::ptr;
 use crate::storage::well_known_keys::CHILD_STORAGE_KEY_PREFIX;
 #[cfg(feature = "std")]
 pub use impl_serde::serialize as bytes;
@@ -190,19 +191,23 @@ impl ChildTrie {
 	///
 	/// This can be quite unsafe for user, so use with care (write new trie information
 	/// as soon as possible).
-	pub fn fetch_or_new_pending(
+	pub fn fetch_or_new(
 		keyspace_builder: &mut impl KeySpaceGenerator,
 		parent_fetcher: impl FnOnce(&[u8]) -> Option<Self>,
+		child_trie_update: impl FnOnce(ChildTrie),
 		parent: &[u8],
 	) -> Self {
-		parent_fetcher(parent).unwrap_or_else(|| {
+		parent_fetcher(parent)
+			.unwrap_or_else(|| {
 			let parent = Self::prefix_parent_key(parent);
-			ChildTrie {
+			let ct = ChildTrie {
 				keyspace: keyspace_builder.generate_keyspace(),
 				root: Default::default(),
 				parent,
 				extension: Default::default(),
-			}
+			};
+			child_trie_update(ct.clone());
+			ct
 		})
 	}
 	/// Get a reference to the child trie information
@@ -262,8 +267,77 @@ impl ChildTrie {
 		enc.extend_from_slice(&self.extension[..]);
 		enc
 	}
+
+	/// Function to send child trie without relying on
+	/// contiguous memory.
+	pub fn unsafe_ptr_child_trie(&self) -> PtrChildTrie {
+		(
+			self.keyspace.as_ptr(),
+			self.keyspace.len() as u32,
+			self.root.as_ref().map(|r| r.as_ptr()).unwrap_or(ptr::null()),
+			self.root.as_ref().map(|r| r.len() as u32).unwrap_or(u32::max_value()),
+			self.parent.as_ptr(),
+			self.parent.len() as u32,
+			self.extension.as_ptr(),
+			self.extension.len() as u32,
+		)
+	}
+	/// Function to rebuild child trie accessed from 
+	pub fn unsafe_from_ptr_child_trie(pct: PtrChildTrieMut) -> Self {
+		let (
+			keyspace,
+			kl,
+			root,
+			rl,
+			parent,
+			pl,
+			extension,
+			el,
+		) = pct;
+		unsafe {
+			let keyspace = from_raw_parts(keyspace, kl).expect("non optional; qed");
+			let root = from_raw_parts(root, rl);
+			let parent = from_raw_parts(parent, pl).expect("non optional; qed");
+			let extension = from_raw_parts(extension, el).expect("non optional; qed");
+			ChildTrie { keyspace, root, parent, extension }
+		}
+	}
 }
 
+// this is redundant with runtime io without_std TODO EMCH move to some util crate
+unsafe fn from_raw_parts(ptr: *mut u8, len: u32) -> Option<Vec<u8>> {
+	if len == u32::max_value() {
+		None
+	} else {
+		Some(<Vec<u8>>::from_raw_parts(ptr, len as usize, len as usize))
+	}
+}
+
+/// Pointers repersentation of ChildTrie
+type PtrChildTrie = (
+	*const u8,
+	u32,
+	*const u8,
+	u32,
+	*const u8,
+	u32,
+	*const u8,
+	u32,
+);
+
+/// Mut Pointers repersentation of ChildTrie
+type PtrChildTrieMut = (
+	*mut u8,
+	u32,
+	*mut u8,
+	u32,
+	*mut u8,
+	u32,
+	*mut u8,
+	u32,
+);
+
+
 impl AsRef<ChildTrie> for ChildTrie {
 	fn as_ref(&self) -> &ChildTrie {
 		self

core/sr-io/src/lib.rs

@@ -108,6 +108,11 @@ export_api! {
 		/// Get child trie for a given `storage_key` location, or `None` if undefined.
 		fn child_trie(storage_key: &[u8]) -> Option<ChildTrie>;
 
+		/// Update or create an existing child trie.
+		/// Return false if it could not be updated (eg direct change
+		/// of root is not allowed).
+		fn set_child_trie(ct: ChildTrie) -> bool;
+
 		/// 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

core/sr-io/with_std.rs

@@ -72,6 +72,11 @@ impl StorageApi for () {
 			.expect("storage cannot be called outside of an Externalities-provided environment.")
 	}
 
+	fn set_child_trie(ct: ChildTrie) -> bool {
+		ext::with(|ext| ext.set_child_trie(ct))
+			.expect("storage cannot be called outside of an Externalities-provided environment.")
+	}
+
 	fn child_storage(child_trie: ChildTrieReadRef, key: &[u8]) -> Option<Vec<u8>> {
 		ext::with(|ext| {
 			ext.child_storage(child_trie, key).map(|s| s.to_vec())

core/sr-io/without_std.rs

@@ -19,8 +19,9 @@ pub use rstd;
 pub use rstd::{mem, slice};
 
 use core::{intrinsics, panic::PanicInfo};
-use rstd::{vec::Vec, cell::Cell, convert::TryInto};
-use primitives::{offchain, Blake2Hasher, child_trie::{ChildTrie, ChildTrieReadRef}};
+use rstd::{vec::Vec, cell::Cell, convert::TryInto, ptr};
+use primitives::{offchain, Blake2Hasher,
+	child_trie::{ChildTrie, ChildTrieReadRef}};
 
 #[cfg(not(feature = "no_panic_handler"))]
 #[panic_handler]
@@ -201,6 +202,30 @@ pub mod ext {
 
 		/// Set value for key in storage.
 		fn ext_set_storage(key_data: *const u8, key_len: u32, value_data: *const u8, value_len: u32);
+		/// Get child trie at a storage location.
+		fn ext_get_child_trie(
+			storage_key_data: *const u8,
+			storage_key_len: u32,
+			a: *mut *mut u8,
+			b: *mut u32,
+			c: *mut *mut u8,
+			d: *mut u32,
+			e: *mut *mut u8,
+			f: *mut u32,
+			g: *mut *mut u8,
+			h: *mut u32
+		) -> bool;
+		/// Set child trie return false if there is an attempt to change non empty root.
+		fn ext_set_child_trie(
+			a: *const u8,
+			b: u32,
+			c: *const u8,
+			d: u32,
+			e: *const u8,
+			f: u32,
+			g: *const u8,
+			h: u32
+		) -> bool;
 		/// Remove key and value from storage.
 		fn ext_clear_storage(key_data: *const u8, key_len: u32);
 		/// Checks if the given key exists in the storage.
@@ -584,12 +609,43 @@ impl StorageApi for () {
 
 	/// Get child trie at storage key location.
 	fn child_trie(storage_key: &[u8]) -> Option<ChildTrie> {
-		let prefixed_key = ChildTrie::prefix_parent_key(storage_key);
-		let prefixed_key_cat = ChildTrie::parent_key_slice(&prefixed_key);
-		storage(prefixed_key_cat)
-			.and_then(|enc_node| ChildTrie::decode_node_with_parent(&enc_node, prefixed_key))
+		let mut a = ptr::null_mut();
+		let mut b = 0u32;
+		let mut c = ptr::null_mut();
+		let mut d = 0u32;
+		let mut e = ptr::null_mut();
+		let mut f = 0u32;
+		let mut g = ptr::null_mut();
+		let mut h = 0u32;
+		unsafe {
+			if ext_get_child_trie.get()(
+				storage_key.as_ptr(),
+				storage_key.len() as u32,
+				&mut a as *mut _,
+				&mut b,
+				&mut c as *mut _,
+				&mut d,
+				&mut e as *mut _,
+				&mut f,
+				&mut g as *mut _,
+				&mut h,
+			) {
+				Some(ChildTrie::unsafe_from_ptr_child_trie((a, b, c, d, e, f, g, h)))
+			} else {
+				None
+			}
+		}
+	}
+
+	/// Set child trie. Can fail and return false (eg change of root).
+	fn set_child_trie(ct: ChildTrie) -> bool {
+		unsafe {
+			let p = ct.unsafe_ptr_child_trie();
+			ext_set_child_trie.get()(p.0, p.1, p.2, p.3, p.4, p.5, p.6, p.7)
+		}
 	}
 
+
 	fn child_storage(child_trie: ChildTrieReadRef, key: &[u8]) -> Option<Vec<u8>> {
 		let mut length: u32 = 0;
 		let empty_byte: [u8;0] = [];

core/state-machine/src/basic.rs

@@ -146,6 +146,10 @@ impl<H: Hasher> Externalities<H> for BasicExternalities where H::Out: Ord {
 		unreachable!("basic not used for child trie");
 	}
 
+	fn set_child_trie(&mut self, _ct: ChildTrie) -> bool {
+		unreachable!("basic not used for child trie");
+	}
+
 	fn clear_prefix(&mut self, prefix: &[u8]) {
 		self.changes.clear_prefix(prefix);
 		self.inner.retain(|key, _| !key.starts_with(prefix));

core/state-machine/src/ext.rs

@@ -238,6 +238,27 @@ where
 		self.overlay.set_child_storage(child_trie, key, value);
 	}
 
+	fn set_child_trie(&mut self, ct: ChildTrie) -> bool {
+		let _guard = panic_handler::AbortGuard::new(true);
+		// do check for backend
+		let ct = match self.child_trie(ct.parent_trie().as_ref()) {
+			Some(ct_old) => if
+				(ct_old.root_initial_value() != ct.root_initial_value()
+				&& !ct.is_new()) ||
+				ct_old.keyspace() != ct.keyspace() {
+				return false;
+			} else {
+				ct
+			},
+			None => if ct.is_new() {
+				ct
+			} else {
+				return false;
+			},
+		};
+		self.overlay.set_child_trie(ct)
+	}
+
 	fn kill_child_storage(&mut self, child_trie: &ChildTrie) {
 		let _guard = panic_handler::AbortGuard::new(true);
 

core/state-machine/src/lib.rs

@@ -165,14 +165,18 @@ pub trait Externalities<H: Hasher> {
 	/// Read child runtime storage.
 	fn child_storage(&self, child_trie: ChildTrieReadRef, key: &[u8]) -> Option<Vec<u8>>;
 
-	/// get child trie infos at storage_key
+	/// Get child trie infos at 'storage_key'.
 	fn child_trie(&self, storage_key: &[u8]) -> Option<ChildTrie>;
 
 	/// Set storage entry `key` of current contract being called (effective immediately).
 	fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
 		self.place_storage(key, Some(value));
 	}
 
+	/// Set child trie infos, can fail if there is an attempt to change a
+	/// non empty child root directly.
+	fn set_child_trie(&mut self, ct: ChildTrie) -> bool;
+
 	/// Set child storage entry `key` of current contract being called (effective immediately).
 	fn set_child_storage(&mut self, child_trie: &ChildTrie, key: Vec<u8>, value: Vec<u8>) {
 		self.place_child_storage(child_trie, key, Some(value))
@@ -1179,9 +1183,10 @@ mod tests {
 		);
 
 		assert_eq!(ext.child_trie(&b"testchild"[..]), None);
-		let child_trie = ChildTrie::fetch_or_new_pending(
+		let child_trie = ChildTrie::fetch_or_new(
 			&mut TestKeySpaceGenerator::new(),
 			|_| None,
+			|_| (),
 			b"testchild",
 		);
 		ext.set_child_storage(&child_trie, b"abc".to_vec(), b"def".to_vec());
@@ -1293,8 +1298,8 @@ mod tests {
 		use std::collections::HashSet;
 
 		let mut ks_gen = TestKeySpaceGenerator::new();
-		let child_trie1 = ChildTrie::fetch_or_new_pending(&mut ks_gen, |_| None, &[0x01]);
-		let child_trie2 = ChildTrie::fetch_or_new_pending(&mut ks_gen, |_| None, &[0x23]);
+		let child_trie1 = ChildTrie::fetch_or_new(&mut ks_gen, |_| None, |_| (), &[0x01]);
+		let child_trie2 = ChildTrie::fetch_or_new(&mut ks_gen, |_| None, |_| (), &[0x23]);
 		let mut tr1 = {
 			let mut ttrie = test_trie();
 			let backend = ttrie.as_trie_backend().unwrap();