state_machine no_std witness externalities

primitives/arithmetic/src/biguint.rs

@@ -18,7 +18,7 @@
 //! Infinite precision unsigned integer for substrate runtime.
 
 use num_traits::Zero;
-use sp_std::{cmp::Ordering, ops, prelude::*, cell::RefCell, convert::TryFrom};
+use sp_std::{cmp::Ordering, ops, prelude::*, cell::RefCell, convert::TryFrom, vec};
 
 // A sensible value for this would be half of the dword size of the host machine. Since the
 // runtime is compiled to 32bit webassembly, using 32 and 64 for single and double respectively

primitives/externalities/Cargo.toml

@@ -13,7 +13,17 @@ documentation = "https://docs.rs/sp-externalities"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-sp-storage = { version = "2.0.0-rc6", path = "../storage" }
-sp-std = { version = "2.0.0-rc6", path = "../std" }
-environmental = { version = "1.1.1" }
-codec = { package = "parity-scale-codec", version = "1.3.1" }
+sp-storage = { version = "2.0.0-rc6", path = "../storage", default-features = false }
+sp-std = { version = "2.0.0-rc6", path = "../std", default-features = false }
+environmental = { version = "1.1.1", optional = true }
+codec = { package = "parity-scale-codec", version = "1.3.1", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+  "sp-std/std",
+  "sp-storage/std",
+
+	"environmental",
+]

primitives/externalities/src/extensions.rs

@@ -22,7 +22,11 @@
 //!
 //! It is required that each extension implements the [`Extension`] trait.
 
-use std::{collections::HashMap, collections::hash_map::Entry, any::{Any, TypeId}, ops::DerefMut};
+#[cfg(feature = "std")]
+use std::{collections::HashMap as Map, collections::hash_map::Entry};
+#[cfg(not(feature = "std"))]
+use sp_std::collections::btree_map::{BTreeMap as Map, Entry};
+use sp_std::{any::{Any, TypeId}, ops::DerefMut, boxed::Box};
 use crate::Error;
 
 /// Marker trait for types that should be registered as [`Externalities`](crate::Externalities) extension.
@@ -104,9 +108,10 @@ pub trait ExtensionStore {
 /// Stores extensions that should be made available through the externalities.
 #[derive(Default)]
 pub struct Extensions {
-	extensions: HashMap<TypeId, Box<dyn Extension>>,
+	extensions: Map<TypeId, Box<dyn Extension>>,
 }
 
+#[cfg(feature = "std")]
 impl std::fmt::Debug for Extensions {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f, "Extensions: ({})", self.extensions.len())

primitives/externalities/src/lib.rs

@@ -15,6 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#![cfg_attr(not(feature = "std"), no_std)]
+
 //! Substrate externalities abstraction
 //!
 //! The externalities mainly provide access to storage and to registered extensions. Extensions
@@ -23,14 +25,18 @@
 //!
 //! This crate exposes the main [`Externalities`] trait.
 
-use std::any::{Any, TypeId};
+use sp_std::any::{Any, TypeId};
+use sp_std::vec::Vec;
+use sp_std::boxed::Box;
 
 use sp_storage::{ChildInfo, TrackedStorageKey};
 
+#[cfg(feature = "std")]
 pub use scope_limited::{set_and_run_with_externalities, with_externalities};
 pub use extensions::{Extension, Extensions, ExtensionStore};
 
 mod extensions;
+#[cfg(feature = "std")]
 mod scope_limited;
 
 /// Externalities error.

primitives/state-machine/Cargo.toml

@@ -13,25 +13,41 @@ documentation = "https://docs.rs/sp-state-machine"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-log = "0.4.8"
-parking_lot = "0.10.0"
-hash-db = "0.15.2"
-trie-db = "0.22.0"
-trie-root = "0.16.0"
-sp-trie = { version = "2.0.0-rc6", path = "../trie" }
-sp-core = { version = "2.0.0-rc6", path = "../core" }
-sp-panic-handler = { version = "2.0.0-rc6", path = "../panic-handler" }
-codec = { package = "parity-scale-codec", version = "1.3.1" }
-num-traits = "0.2.8"
-rand = "0.7.2"
-sp-externalities = { version = "0.8.0-rc6", path = "../externalities" }
-itertools = "0.9"
+log = { version = "0.4.8", optional = true }
+parking_lot = { version = "0.10.0", optional = true }
+hash-db = { version = "0.15.2", default-features = false }
+trie-db = { version = "0.22.0", default-features = false }
+trie-root = { version = "0.16.0", default-features = false }
+sp-trie = { version = "2.0.0-rc6", path = "../trie", default-features = false }
+sp-core = { version = "2.0.0-rc6", path = "../core", default-features = false }
+sp-panic-handler = { version = "2.0.0-rc6", path = "../panic-handler", optional = true }
+codec = { package = "parity-scale-codec", version = "1.3.1", default-features = false }
+num-traits = { version = "0.2.8", default-features = false }
+rand = { version = "0.7.2", optional = true }
+sp-externalities = { version = "0.8.0-rc6", path = "../externalities", default-features = false }
 smallvec = "1.4.1"
+sp-std = { version = "2.0.0-rc5", default-features = false, path = "../std" }
 
 [dev-dependencies]
 hex-literal = "0.3.1"
 sp-runtime = { version = "2.0.0-rc6", path = "../runtime" }
 pretty_assertions = "0.6.1"
 
 [features]
-default = []
+default = ["std"]
+std = [
+	"codec/std",
+	"hash-db/std",
+	"num-traits/std",
+  "sp-core/std",
+  "sp-externalities/std",
+  "sp-std/std",
+	"sp-trie/std",
+	"trie-db/std",
+	"trie-root/std",
+
+	"log",
+	"parking_lot",
+	"rand",
+  "sp-panic-handler",
+]

primitives/state-machine/src/backend.rs

@@ -20,20 +20,22 @@
 use hash_db::Hasher;
 use codec::{Decode, Encode};
 use sp_core::{
-	traits::RuntimeCode,
 	storage::{ChildInfo, well_known_keys, TrackedStorageKey}
 };
 use crate::{
 	trie_backend::TrieBackend,
 	trie_backend_essence::TrieBackendStorage,
 	UsageInfo, StorageKey, StorageValue, StorageCollection,
 };
+use sp_std::vec::Vec;
+#[cfg(feature = "std")]
+use sp_core::traits::RuntimeCode;
 
 /// A state backend is used to read state data and can have changes committed
 /// to it.
 ///
 /// The clone operation (if implemented) should be cheap.
-pub trait Backend<H: Hasher>: std::fmt::Debug {
+pub trait Backend<H: Hasher>: sp_std::fmt::Debug {
 	/// An error type when fetching data is not possible.
 	type Error: super::Error;
 
@@ -369,11 +371,13 @@ pub(crate) fn insert_into_memory_db<H, I>(mdb: &mut sp_trie::MemoryDB<H>, input:
 }
 
 /// Wrapper to create a [`RuntimeCode`] from a type that implements [`Backend`].
+#[cfg(feature = "std")]
 pub struct BackendRuntimeCode<'a, B, H> {
 	backend: &'a B,
 	_marker: std::marker::PhantomData<H>,
 }
 
+#[cfg(feature = "std")]
 impl<'a, B: Backend<H>, H: Hasher> sp_core::traits::FetchRuntimeCode for
 	BackendRuntimeCode<'a, B, H>
 {
@@ -382,6 +386,7 @@ impl<'a, B: Backend<H>, H: Hasher> sp_core::traits::FetchRuntimeCode for
 	}
 }
 
+#[cfg(feature = "std")]
 impl<'a, B: Backend<H>, H: Hasher> BackendRuntimeCode<'a, B, H> where H::Out: Encode {
 	/// Create a new instance.
 	pub fn new(backend: &'a B) -> Self {

primitives/state-machine/src/changes_trie/build.rs

@@ -25,7 +25,7 @@ use num_traits::One;
 use crate::{
 	StorageKey,
 	backend::Backend,
-	overlayed_changes::{OverlayedChanges, OverlayedValue},
+	overlayed_changes::{OverlayedChanges, OverlayedValue, ChangeTrieOverlay},
 	trie_backend_essence::TrieBackendEssence,
 	changes_trie::{
 		AnchorBlockId, ConfigurationRange, Storage, BlockNumber,
@@ -39,11 +39,11 @@ use sp_core::storage::{ChildInfo, PrefixedStorageKey};
 ///
 /// Returns Err if storage error has occurred OR if storage haven't returned
 /// required data.
-pub(crate) fn prepare_input<'a, B, H, Number>(
+pub(crate) fn prepare_input<'a, B, H, Number, CT>(
 	backend: &'a B,
 	storage: &'a dyn Storage<H, Number>,
 	config: ConfigurationRange<'a, Number>,
-	overlay: &'a OverlayedChanges,
+	overlay: &'a OverlayedChanges<CT>,
 	parent: &'a AnchorBlockId<H::Out, Number>,
 ) -> Result<(
 		impl Iterator<Item=InputPair<Number>> + 'a,
@@ -55,6 +55,7 @@ pub(crate) fn prepare_input<'a, B, H, Number>(
 		H: Hasher + 'a,
 		H::Out: Encode,
 		Number: BlockNumber,
+		CT: ChangeTrieOverlay,
 {
 	let number = parent.number.clone() + One::one();
 	let (extrinsics_input, children_extrinsics_input) = prepare_extrinsics_input(
@@ -93,10 +94,10 @@ pub(crate) fn prepare_input<'a, B, H, Number>(
 	))
 }
 /// Prepare ExtrinsicIndex input pairs.
-fn prepare_extrinsics_input<'a, B, H, Number>(
+fn prepare_extrinsics_input<'a, B, H, Number, CT>(
 	backend: &'a B,
 	block: &Number,
-	overlay: &'a OverlayedChanges,
+	overlay: &'a OverlayedChanges<CT>,
 ) -> Result<(
 		impl Iterator<Item=InputPair<Number>> + 'a,
 		BTreeMap<ChildIndex<Number>, impl Iterator<Item=InputPair<Number>> + 'a>,
@@ -105,6 +106,7 @@ fn prepare_extrinsics_input<'a, B, H, Number>(
 		B: Backend<H>,
 		H: Hasher + 'a,
 		Number: BlockNumber,
+		CT: ChangeTrieOverlay,
 {
 	let mut children_result = BTreeMap::new();
 
@@ -127,55 +129,58 @@ fn prepare_extrinsics_input<'a, B, H, Number>(
 	Ok((top, children_result))
 }
 
-fn prepare_extrinsics_input_inner<'a, B, H, Number>(
+fn prepare_extrinsics_input_inner<'a, B, H, Number, CT>(
 	backend: &'a B,
 	block: &Number,
-	overlay: &'a OverlayedChanges,
+	overlay: &'a OverlayedChanges<CT>,
 	child_info: Option<ChildInfo>,
-	changes: impl Iterator<Item=(&'a StorageKey, &'a OverlayedValue)>
+	mut changes: impl Iterator<Item=(&'a StorageKey, &'a OverlayedValue<CT>)>
 ) -> Result<impl Iterator<Item=InputPair<Number>> + 'a, String>
 	where
 		B: Backend<H>,
 		H: Hasher,
 		Number: BlockNumber,
+		CT: ChangeTrieOverlay,
 {
 	changes
-		.filter(|( _, v)| v.extrinsics().next().is_some())
 		.try_fold(BTreeMap::new(), |mut map: BTreeMap<&[u8], (ExtrinsicIndex<Number>, Vec<u32>)>, (k, v)| {
-			match map.entry(k) {
-				Entry::Vacant(entry) => {
-					// ignore temporary values (values that have null value at the end of operation
-					// AND are not in storage at the beginning of operation
-					if let Some(child_info) = child_info.as_ref() {
-						if !overlay.child_storage(child_info, k).map(|v| v.is_some()).unwrap_or_default() {
-							if !backend.exists_child_storage(&child_info, k)
-								.map_err(|e| format!("{}", e))? {
-								return Ok(map);
+			let extrinsics = v.extrinsics();
+			if !extrinsics.is_empty() {
+				match map.entry(k) {
+					Entry::Vacant(entry) => {
+						// ignore temporary values (values that have null value at the end of operation
+						// AND are not in storage at the beginning of operation
+						if let Some(child_info) = child_info.as_ref() {
+							if !overlay.child_storage(child_info, k).map(|v| v.is_some()).unwrap_or_default() {
+								if !backend.exists_child_storage(&child_info, k)
+									.map_err(|e| format!("{}", e))? {
+									return Ok(map);
+								}
 							}
-						}
-					} else {
-						if !overlay.storage(k).map(|v| v.is_some()).unwrap_or_default() {
-							if !backend.exists_storage(k).map_err(|e| format!("{}", e))? {
-								return Ok(map);
+						} else {
+							if !overlay.storage(k).map(|v| v.is_some()).unwrap_or_default() {
+								if !backend.exists_storage(k).map_err(|e| format!("{}", e))? {
+									return Ok(map);
+								}
 							}
-						}
-					};
-
-					let extrinsics = v.extrinsics().cloned().collect();
-					entry.insert((ExtrinsicIndex {
-						block: block.clone(),
-						key: k.to_vec(),
-					}, extrinsics));
-				},
-				Entry::Occupied(mut entry) => {
-					// we do not need to check for temporary values here, because entry is Occupied
-					// AND we are checking it before insertion
-					let extrinsics = &mut entry.get_mut().1;
-					extrinsics.extend(
-						v.extrinsics().cloned()
-					);
-					extrinsics.sort();
-				},
+						};
+
+						let extrinsics = extrinsics.into_iter().collect();
+						entry.insert((ExtrinsicIndex {
+							block: block.clone(),
+							key: k.to_vec(),
+						}, extrinsics));
+					},
+					Entry::Occupied(mut entry) => {
+						// we do not need to check for temporary values here, because entry is Occupied
+						// AND we are checking it before insertion
+						let entry_extrinsics = &mut entry.get_mut().1;
+						entry_extrinsics.extend(
+							extrinsics.into_iter()
+						);
+						entry_extrinsics.sort();
+					},
+				}
 			}
 
 			Ok(map)