Cleanup of the state-machine crate (#3524)

* Start refactoring state-machine crate

* More improvement to state-machine

* Fix tests compilation on master and remove warnings

* Fix compilation

* Apply suggestions from code review

Co-Authored-By: Sergei Pepyakin <sergei@parity.io>

* Update core/state-machine/src/basic.rs

Co-Authored-By: DemiMarie-parity <48690212+DemiMarie-parity@users.noreply.github.com>

* Line width

* Update core/primitives/src/storage.rs

Co-Authored-By: Benjamin Kampmann <ben.kampmann@googlemail.com>

* Update core/state-machine/src/error.rs

Co-Authored-By: Benjamin Kampmann <ben.kampmann@googlemail.com>

* Review feedback

substrate/core/primitives/src/child_storage_key.rs

@@ -0,0 +1,68 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Provides a wrapper around a child storage key.
+
+use crate::storage::well_known_keys::is_child_trie_key_valid;
+use rstd::{borrow::Cow, vec::Vec};
+
+/// A wrapper around a child storage key.
+///
+/// This wrapper ensures that the child storage key is correct and properly used. It is
+/// impossible to create an instance of this struct without providing a correct `storage_key`.
+pub struct ChildStorageKey<'a> {
+	storage_key: Cow<'a, [u8]>,
+}
+
+impl<'a> ChildStorageKey<'a> {
+	fn new(storage_key: Cow<'a, [u8]>) -> Option<Self> {
+		if is_child_trie_key_valid(&storage_key) {
+			Some(ChildStorageKey { storage_key })
+		} else {
+			None
+		}
+	}
+
+	/// Create a new `ChildStorageKey` from a vector.
+	///
+	/// `storage_key` need to start with `:child_storage:default:`
+	/// See `is_child_trie_key_valid` for more details.
+	pub fn from_vec(key: Vec<u8>) -> Option<Self> {
+		Self::new(Cow::Owned(key))
+	}
+
+	/// Create a new `ChildStorageKey` from a slice.
+	///
+	/// `storage_key` need to start with `:child_storage:default:`
+	/// See `is_child_trie_key_valid` for more details.
+	pub fn from_slice(key: &'a [u8]) -> Option<Self> {
+		Self::new(Cow::Borrowed(key))
+	}
+
+	/// Get access to the byte representation of the storage key.
+	///
+	/// This key is guaranteed to be correct.
+	pub fn as_ref(&self) -> &[u8] {
+		&*self.storage_key
+	}
+
+	/// Destruct this instance into an owned vector that represents the storage key.
+	///
+	/// This key is guaranteed to be correct.
+	pub fn into_owned(self) -> Vec<u8> {
+		self.storage_key.into_owned()
+	}
+}

substrate/core/primitives/src/lib.rs

@@ -54,6 +54,7 @@ pub mod crypto;
 
 pub mod u32_trait;
 
+pub mod child_storage_key;
 pub mod ed25519;
 pub mod sr25519;
 pub mod hash;

substrate/core/primitives/src/offchain.rs

@@ -663,6 +663,112 @@ impl<T: Externalities> Externalities for LimitedExternalities<T> {
 	}
 }
 
+/// An implementation of offchain extensions that should never be triggered.
+pub enum NeverOffchainExt {}
+
+impl NeverOffchainExt {
+	/// Create new offchain extensions.
+	pub fn new<'a>() -> Option<&'a mut Self> {
+		None
+	}
+}
+
+impl Externalities for NeverOffchainExt {
+	fn is_validator(&self) -> bool {
+		unreachable!()
+	}
+
+	fn submit_transaction(&mut self, _extrinsic: Vec<u8>) -> Result<(), ()> {
+		unreachable!()
+	}
+
+	fn network_state(
+		&self,
+	) -> Result<OpaqueNetworkState, ()> {
+		unreachable!()
+	}
+
+	fn timestamp(&mut self) -> Timestamp {
+		unreachable!()
+	}
+
+	fn sleep_until(&mut self, _deadline: Timestamp) {
+		unreachable!()
+	}
+
+	fn random_seed(&mut self) -> [u8; 32] {
+		unreachable!()
+	}
+
+	fn local_storage_set(&mut self, _kind: StorageKind, _key: &[u8], _value: &[u8]) {
+		unreachable!()
+	}
+
+	fn local_storage_compare_and_set(
+		&mut self,
+		_kind: StorageKind,
+		_key: &[u8],
+		_old_value: Option<&[u8]>,
+		_new_value: &[u8],
+	) -> bool {
+		unreachable!()
+	}
+
+	fn local_storage_get(&mut self, _kind: StorageKind, _key: &[u8]) -> Option<Vec<u8>> {
+		unreachable!()
+	}
+
+	fn http_request_start(
+		&mut self,
+		_method: &str,
+		_uri: &str,
+		_meta: &[u8]
+	) -> Result<HttpRequestId, ()> {
+		unreachable!()
+	}
+
+	fn http_request_add_header(
+		&mut self,
+		_request_id: HttpRequestId,
+		_name: &str,
+		_value: &str
+	) -> Result<(), ()> {
+		unreachable!()
+	}
+
+	fn http_request_write_body(
+		&mut self,
+		_request_id: HttpRequestId,
+		_chunk: &[u8],
+		_deadline: Option<Timestamp>
+	) -> Result<(), HttpError> {
+		unreachable!()
+	}
+
+	fn http_response_wait(
+		&mut self,
+		_ids: &[HttpRequestId],
+		_deadline: Option<Timestamp>
+	) -> Vec<HttpRequestStatus> {
+		unreachable!()
+	}
+
+	fn http_response_headers(
+		&mut self,
+		_request_id: HttpRequestId
+	) -> Vec<(Vec<u8>, Vec<u8>)> {
+		unreachable!()
+	}
+
+	fn http_response_read_body(
+		&mut self,
+		_request_id: HttpRequestId,
+		_buffer: &mut [u8],
+		_deadline: Option<Timestamp>
+	) -> Result<usize, HttpError> {
+		unreachable!()
+	}
+}
 
 #[cfg(test)]
 mod tests {

substrate/core/primitives/src/storage.rs

@@ -75,4 +75,22 @@ pub mod well_known_keys {
 		// Other code might depend on this, so be careful changing this.
 		key.starts_with(CHILD_STORAGE_KEY_PREFIX)
 	}
+
+	/// Determine whether a child trie key is valid.
+	///
+	/// For now, the only valid child trie keys are those starting with `:child_storage:default:`.
+	///
+	/// `child_trie_root` and `child_delta_trie_root` can panic if invalid value is provided to them.
+	pub fn is_child_trie_key_valid(storage_key: &[u8]) -> bool {
+		let has_right_prefix = storage_key.starts_with(b":child_storage:default:");
+		if has_right_prefix {
+			// This is an attempt to catch a change of `is_child_storage_key`, which
+			// just checks if the key has prefix `:child_storage:` at the moment of writing.
+			debug_assert!(
+				is_child_storage_key(&storage_key),
+				"`is_child_trie_key_valid` is a subset of `is_child_storage_key`",
+			);
+		}
+		has_right_prefix
+	}
 }

substrate/core/primitives/src/traits.rs

@@ -17,7 +17,11 @@
 //! Shareable Substrate traits.
 
 #[cfg(feature = "std")]
-use crate::{crypto::KeyTypeId, ed25519, sr25519};
+use crate::{crypto::KeyTypeId, ed25519, sr25519, child_storage_key::ChildStorageKey};
+#[cfg(feature = "std")]
+use std::{fmt::{Debug, Display}, panic::UnwindSafe};
+#[cfg(feature = "std")]
+use hash_db::Hasher;
 
 /// Something that generates, stores and provides access to keys.
 #[cfg(feature = "std")]
@@ -68,3 +72,134 @@ pub trait BareCryptoStore: Send + Sync {
 /// A pointer to the key store.
 #[cfg(feature = "std")]
 pub type BareCryptoStorePtr = std::sync::Arc<parking_lot::RwLock<dyn BareCryptoStore>>;
+
+/// Externalities: pinned to specific active address.
+#[cfg(feature = "std")]
+pub trait Externalities<H: Hasher> {
+	/// Read runtime storage.
+	fn storage(&self, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Get storage value hash. This may be optimized for large values.
+	fn storage_hash(&self, key: &[u8]) -> Option<H::Out> {
+		self.storage(key).map(|v| H::hash(&v))
+	}
+
+	/// Get child storage value hash. This may be optimized for large values.
+	fn child_storage_hash(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<H::Out> {
+		self.child_storage(storage_key, key).map(|v| H::hash(&v))
+	}
+
+	/// Read original runtime storage, ignoring any overlayed changes.
+	fn original_storage(&self, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Read original runtime child storage, ignoring any overlayed changes.
+	fn original_child_storage(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Get original storage value hash, ignoring any overlayed changes.
+	/// This may be optimized for large values.
+	fn original_storage_hash(&self, key: &[u8]) -> Option<H::Out> {
+		self.original_storage(key).map(|v| H::hash(&v))
+	}
+
+	/// Get original child storage value hash, ignoring any overlayed changes.
+	/// This may be optimized for large values.
+	fn original_child_storage_hash(
+		&self,
+		storage_key: ChildStorageKey,
+		key: &[u8],
+	) -> Option<H::Out> {
+		self.original_child_storage(storage_key, key).map(|v| H::hash(&v))
+	}
+
+	/// Read child runtime storage.
+	fn child_storage(&self, storage_key: ChildStorageKey, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// 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 storage entry `key` of current contract being called (effective immediately).
+	fn set_child_storage(&mut self, storage_key: ChildStorageKey, key: Vec<u8>, value: Vec<u8>) {
+		self.place_child_storage(storage_key, key, Some(value))
+	}
+
+	/// Clear a storage entry (`key`) of current contract being called (effective immediately).
+	fn clear_storage(&mut self, key: &[u8]) {
+		self.place_storage(key.to_vec(), None);
+	}
+
+	/// Clear a child storage entry (`key`) of current contract being called (effective immediately).
+	fn clear_child_storage(&mut self, storage_key: ChildStorageKey, key: &[u8]) {
+		self.place_child_storage(storage_key, key.to_vec(), None)
+	}
+
+	/// Whether a storage entry exists.
+	fn exists_storage(&self, key: &[u8]) -> bool {
+		self.storage(key).is_some()
+	}
+
+	/// Whether a child storage entry exists.
+	fn exists_child_storage(&self, storage_key: ChildStorageKey, key: &[u8]) -> bool {
+		self.child_storage(storage_key, key).is_some()
+	}
+
+	/// Clear an entire child storage.
+	fn kill_child_storage(&mut self, storage_key: ChildStorageKey);
+
+	/// Clear storage entries which keys are start with the given prefix.
+	fn clear_prefix(&mut self, prefix: &[u8]);
+
+	/// Clear child storage entries which keys are start with the given prefix.
+	fn clear_child_prefix(&mut self, storage_key: ChildStorageKey, prefix: &[u8]);
+
+	/// Set or clear a storage entry (`key`) of current contract being called (effective immediately).
+	fn place_storage(&mut self, key: Vec<u8>, value: Option<Vec<u8>>);
+
+	/// Set or clear a child storage entry. Return whether the operation succeeds.
+	fn place_child_storage(&mut self, storage_key: ChildStorageKey, key: Vec<u8>, value: Option<Vec<u8>>);
+
+	/// Get the identity of the chain.
+	fn chain_id(&self) -> u64;
+
+	/// Get the trie root of the current storage map. This will also update all child storage keys
+	/// in the top-level storage map.
+	fn storage_root(&mut self) -> H::Out where H::Out: Ord;
+
+	/// Get the trie root of a child storage map. This will also update the value of the child
+	/// storage keys in the top-level storage map.
+	/// If the storage root equals the default hash as defined by the trie, the key in the top-level
+	/// storage map will be removed.
+	fn child_storage_root(&mut self, storage_key: ChildStorageKey) -> Vec<u8>;
+
+	/// Get the change trie root of the current storage overlay at a block with given parent.
+	fn storage_changes_root(&mut self, parent: H::Out) -> Result<Option<H::Out>, ()> where H::Out: Ord;
+
+	/// Returns offchain externalities extension if present.
+	fn offchain(&mut self) -> Option<&mut dyn crate::offchain::Externalities>;
+
+	/// Returns the keystore.
+	fn keystore(&self) -> Option<BareCryptoStorePtr>;
+}
+
+/// Code execution engine.
+#[cfg(feature = "std")]
+pub trait CodeExecutor<H: Hasher>: Sized + Send + Sync {
+	/// Externalities error type.
+	type Error: Display + Debug + Send + 'static;
+
+	/// Call a given method in the runtime. Returns a tuple of the result (either the output data
+	/// or an execution error) together with a `bool`, which is true if native execution was used.
+	fn call<
+		E: Externalities<H>,
+		R: codec::Codec + PartialEq,
+		NC: FnOnce() -> Result<R, &'static str> + UnwindSafe,
+	>(
+		&self,
+		ext: &mut E,
+		method: &str,
+		data: &[u8],
+		use_native: bool,
+		native_call: Option<NC>,
+	) -> (Result<crate::NativeOrEncoded<R>, Self::Error>, bool);
+}