Final tweaks for PoC-2 runtime upgrade

substrate/executor/src/wasm_executor.rs

@@ -28,7 +28,7 @@ use state_machine::{Externalities, CodeExecutor};
 use error::{Error, ErrorKind, Result};
 use wasm_utils::UserError;
 use primitives::{blake2_256, twox_128, twox_256};
-use primitives::hexdisplay::{HexDisplay, ascii_format};
+use primitives::hexdisplay::HexDisplay;
 use primitives::sandbox as sandbox_primitives;
 use triehash::ordered_trie_root;
 use sandbox;
@@ -200,9 +200,9 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		let key = this.memory.get(key_data, key_len as usize).map_err(|_| UserError("Invalid attempt to determine key in ext_set_storage"))?;
 		let value = this.memory.get(value_data, value_len as usize).map_err(|_| UserError("Invalid attempt to determine value in ext_set_storage"))?;
 		if let Some(_preimage) = this.hash_lookup.get(&key) {
-			debug_trace!(target: "wasm-trace", "*** Setting storage: %{} -> {}   [k={}]", ascii_format(&_preimage), HexDisplay::from(&value), HexDisplay::from(&key));
+			debug_trace!(target: "wasm-trace", "*** Setting storage: %{} -> {}   [k={}]", ::primitives::hexdisplay::ascii_format(&_preimage), HexDisplay::from(&value), HexDisplay::from(&key));
 		} else {
-			debug_trace!(target: "wasm-trace", "*** Setting storage:  {} -> {}   [k={}]", ascii_format(&key), HexDisplay::from(&value), HexDisplay::from(&key));
+			debug_trace!(target: "wasm-trace", "*** Setting storage:  {} -> {}   [k={}]", ::primitives::hexdisplay::ascii_format(&key), HexDisplay::from(&value), HexDisplay::from(&key));
 		}
 		this.ext.set_storage(key, value);
 		Ok(())
@@ -211,9 +211,9 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		let key = this.memory.get(key_data, key_len as usize).map_err(|_| UserError("Invalid attempt to determine key in ext_clear_storage"))?;
 		debug_trace!(target: "wasm-trace", "*** Clearing storage: {}   [k={}]", 
 			if let Some(_preimage) = this.hash_lookup.get(&key) {
-				format!("%{}", ascii_format(&_preimage))
+				format!("%{}", ::primitives::hexdisplay::ascii_format(&_preimage))
 			} else {
-				format!(" {}", ascii_format(&key))
+				format!(" {}", ::primitives::hexdisplay::ascii_format(&key))
 			}, HexDisplay::from(&key));
 		this.ext.clear_storage(&key);
 		Ok(())
@@ -234,9 +234,9 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 
 		debug_trace!(target: "wasm-trace", "*** Getting storage: {} == {}   [k={}]", 
 			if let Some(_preimage) = this.hash_lookup.get(&key) {
-				format!("%{}", ascii_format(&_preimage))
+				format!("%{}", ::primitives::hexdisplay::ascii_format(&_preimage))
 			} else {
-				format!(" {}", ascii_format(&key))
+				format!(" {}", ::primitives::hexdisplay::ascii_format(&key))
 			},
 			if let Some(ref b) = maybe_value {
 				format!("{}", HexDisplay::from(b))
@@ -264,9 +264,9 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		let maybe_value = this.ext.storage(&key);
 		debug_trace!(target: "wasm-trace", "*** Getting storage: {} == {}   [k={}]", 
 			if let Some(_preimage) = this.hash_lookup.get(&key) {
-				format!("%{}", ascii_format(&_preimage))
+				format!("%{}", ::primitives::hexdisplay::ascii_format(&_preimage))
 			} else {
-				format!(" {}", ascii_format(&key))
+				format!(" {}", ::primitives::hexdisplay::ascii_format(&key))
 			},
 			if let Some(ref b) = maybe_value {
 				format!("{}", HexDisplay::from(b))

substrate/runtime-io/with_std.rs

@@ -68,11 +68,11 @@ pub fn clear_storage(key: &[u8]) {
 	);
 }
 
-/// Clear the storage of some particular key.
-pub fn exists_storage(key: &[u8]) {
+/// Check whether a given `key` exists in storage.
+pub fn exists_storage(key: &[u8]) -> bool {
 	ext::with(|ext|
 		ext.exists_storage(key)
-	);
+	).unwrap_or(false)
 }
 
 /// Clear the storage entries key of which starts with the given prefix.

substrate/runtime-io/without_std.rs

@@ -101,12 +101,12 @@ pub fn clear_storage(key: &[u8]) {
 	}
 }
 
-/// Clear the storage of some particular key.
-pub fn exists_storage(key: &[u8]) {
+/// Determine whether a particular key exists in storage.
+pub fn exists_storage(key: &[u8]) -> bool {
 	unsafe {
 		ext_exists_storage(
 			key.as_ptr(), key.len() as u32
-		) != 0;
+		) != 0
 	}
 }
 

substrate/runtime-support/src/storage/mod.rs

@@ -39,6 +39,22 @@ impl<'a> Input for IncrementalInput<'a> {
 	}
 }
 
+// TODO: only introduce this wrapper for types where it makes sense, ideally have it within the module declaration.
+
+struct AppendZeroes<'a, I: Input + 'a> {
+	input: &'a mut I,
+}
+
+impl<'a, I: Input + 'a> Input for AppendZeroes<'a, I> {
+	fn read(&mut self, into: &mut [u8]) -> usize {
+		let r = self.input.read(into);
+		for z in &mut into[r..] {
+			*z = 0;
+		};
+		into.len()
+	}
+}
+
  /// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
 pub fn get<T: Codec + Sized>(key: &[u8]) -> Option<T> {
 	let key = twox_128(key);
@@ -47,7 +63,7 @@ pub fn get<T: Codec + Sized>(key: &[u8]) -> Option<T> {
 			key: &key[..],
 			pos: 0,
 		};
-		Decode::decode(&mut input).expect("storage is not null, therefore must be a valid type")
+		Decode::decode(&mut AppendZeroes { input: &mut input } ).expect("storage is not null, therefore must be a valid type")
 	})
 }
 
@@ -103,8 +119,7 @@ pub fn take_or_else<T: Codec + Sized, F: FnOnce() -> T>(key: &[u8], default_valu
 
 /// Check to see if `key` has an explicit entry in storage.
 pub fn exists(key: &[u8]) -> bool {
-	let mut x = [0u8; 0];
-	runtime_io::read_storage(&twox_128(key)[..], &mut x[..], 0).is_some()
+	runtime_io::exists_storage(&twox_128(key)[..])
 }
 
 /// Ensure `key` has no explicit entry in storage.