Add missing wasm boilerplate.

core/executor/src/wasm_executor.rs

@@ -174,6 +174,74 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		debug_trace!(target: "sr-io", "free {}", addr);
 		Ok(())
 	},
+	ext_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
+	) -> u32 => {
+		let storage_key = this.memory.get(storage_key_data, storage_key_len as usize)
+			.map_err(|_| UserError("Invalid attempt to determine storage_key in ext_get_child_trie"))?;
+
+			Ok(if let Some(ct) = this.ext.child_trie(&storage_key) {
+
+				let mut alloc_vec =
+					|value: Option<&[u8]>, dest_vec, dest_len| -> std::result::Result<(), UserError> {
+					if let Some(value) = value {
+						let offset = this.heap.allocate(value.len() as u32)? as u32;
+						this.memory.set(offset, &value)
+							.map_err(|_| UserError("Invalid attempt to set memory in ext_child_trie"))?;
+						this.memory.write_primitive(dest_len, value.len() as u32)
+							.map_err(|_| UserError("Invalid attempt to write length in ext_child_trie"))?;
+						this.memory.write_primitive(dest_vec, offset)
+							.map_err(|_| UserError("Invalid attempt to write vec ptr in ext_child_trie"))?;
+					} else {
+						this.memory.write_primitive(dest_len, u32::max_value())
+							.map_err(|_| UserError("Invalid attempt to write failed length in ext_child_trie"))?;
+					}
+					Ok(())
+				};
+				let p = ct.unsafe_to_ptr_vec();
+				alloc_vec(Some(p.0), a, b)?;
+				alloc_vec(p.1, c, d)?;
+				alloc_vec(Some(p.2), e, f)?;
+				alloc_vec(Some(p.3), g, h)?;
+				1
+			} else {
+				0
+			})
+	},
+	ext_set_child_trie(
+			a: *const u8,
+			b: u32,
+			c: *const u8,
+			d: u32,
+			e: *const u8,
+			f: u32,
+			g: *const u8,
+			h: u32
+	) -> u32 => {
+		let f1 = this.memory.get(a, b as usize)
+			.map_err(|_| UserError("Invalid attempt to determine f1 in ext_set_child_trie"))?;
+		let f2 = if d == u32::max_value() {
+			None
+		} else {
+			Some(this.memory.get(c, d as usize)
+				.map_err(|_| UserError("Invalid attempt to determine f2 in ext_set_child_trie"))?)
+		};
+		let f3 = this.memory.get(e, f as usize)
+			.map_err(|_| UserError("Invalid attempt to determine f3 in ext_set_child_trie"))?;
+		let f4 = this.memory.get(g, h as usize)
+			.map_err(|_| UserError("Invalid attempt to determine f4 in ext_set_child_trie"))?;
+		let ct = ChildTrie::unsafe_from_ptr_vecs(f1, f2, f3, f4);
+		Ok(if this.ext.set_child_trie(ct) { 1 } else { 0 })
+	},
 	ext_set_storage(key_data: *const u8, key_len: u32, value_data: *const u8, value_len: u32) => {
 		let key = this.memory.get(key_data, key_len as usize)
 			.map_err(|_| UserError("Invalid attempt to determine key in ext_set_storage"))?;

core/primitives/src/child_trie.rs

@@ -282,7 +282,17 @@ impl ChildTrie {
 			self.extension.len() as u32,
 		)
 	}
-	/// Function to rebuild child trie accessed from 
+	/// Function to access child trie field unsafely (for memcopy).
+	pub fn unsafe_to_ptr_vec(&self) -> (&[u8], Option<&[u8]>, &[u8], &[u8]) {
+		(
+			self.keyspace.as_ref(),
+			self.root.as_ref().map(|r| r.as_ref()),
+			self.parent.as_ref(),
+			self.extension.as_ref(),
+		)
+	}
+
+	/// Function to rebuild child trie accessed from.
 	pub fn unsafe_from_ptr_child_trie(pct: PtrChildTrieMut) -> Self {
 		let (
 			keyspace,
@@ -302,9 +312,13 @@ impl ChildTrie {
 			ChildTrie { keyspace, root, parent, extension }
 		}
 	}
+	/// Function to rebuild child trie accessed from mem copied field.
+	pub fn unsafe_from_ptr_vecs(a: Vec<u8>, b: Option<Vec<u8>>, c: Vec<u8>, d: Vec<u8>) -> Self {
+		ChildTrie { keyspace: a, root: b , parent: c, extension: d }
+	}
+
 }
 
-// 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
@@ -337,12 +351,12 @@ type PtrChildTrieMut = (
 	u32,
 );
 
-
 impl AsRef<ChildTrie> for ChildTrie {
 	fn as_ref(&self) -> &ChildTrie {
 		self
 	}
 }
+
 /// Builder for `KeySpace`.
 /// Implementation of this trait must ensure unicity of generated `KeySpace` over the whole runtime context.
 /// In the context of deterministic generation this can be difficult, so

core/sr-io/without_std.rs

@@ -203,7 +203,12 @@ 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(
+		///
+    /// # Returns
+		///
+		/// - `1` if child trie found and content written.
+		/// - `0` otherwhise.
+		fn ext_child_trie(
 			storage_key_data: *const u8,
 			storage_key_len: u32,
 			a: *mut *mut u8,
@@ -214,8 +219,12 @@ pub mod ext {
 			f: *mut u32,
 			g: *mut *mut u8,
 			h: *mut u32
-		) -> bool;
+		) -> u32;
 		/// Set child trie return false if there is an attempt to change non empty root.
+		/// # Returns
+		///
+		/// - `1` if set successfull
+		/// - `0` if not
 		fn ext_set_child_trie(
 			a: *const u8,
 			b: u32,
@@ -225,7 +234,7 @@ pub mod ext {
 			f: u32,
 			g: *const u8,
 			h: u32
-		) -> bool;
+		) -> u32;
 		/// 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.
@@ -618,7 +627,7 @@ impl StorageApi for () {
 		let mut g = ptr::null_mut();
 		let mut h = 0u32;
 		unsafe {
-			if ext_get_child_trie.get()(
+			if ext_child_trie.get()(
 				storage_key.as_ptr(),
 				storage_key.len() as u32,
 				&mut a as *mut _,
@@ -629,7 +638,7 @@ impl StorageApi for () {
 				&mut f,
 				&mut g as *mut _,
 				&mut h,
-			) {
+			) == 1 {
 				Some(ChildTrie::unsafe_from_ptr_child_trie((a, b, c, d, e, f, g, h)))
 			} else {
 				None
@@ -642,6 +651,7 @@ impl StorageApi for () {
 		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)
+				== 1
 		}
 	}