BREAKING Overlay transaction support.

.gitlab-ci.yml

@@ -113,9 +113,12 @@ cargo-check-benches:
   <<:                              *docker-env
   script:
     - BUILD_DUMMY_WASM_BINARY=1 time cargo +nightly check --benches --all
+    - cd ./primitives/state-machine/fuzz
+    - time cargo check
     - sccache -s
 
 
+
 cargo-check-subkey:
   stage:                           test
   <<:                              *docker-env

Cargo.toml

@@ -124,6 +124,7 @@ members = [
 	"primitives/api/proc-macro",
 	"primitives/api/test",
 	"primitives/arithmetic",
+	"primitives/historical-data",
 	"primitives/io",
 	"primitives/runtime",
 	"primitives/sandbox",

frame/support/src/storage/mod.rs

@@ -25,6 +25,22 @@ pub mod hashed;
 pub mod child;
 pub mod generator;
 
+/// Execute under a transactional layer.
+///
+/// If the result of execution is an error,
+/// the transactional layer get reverted; otherwhise
+/// it is committed.
+pub fn with_transaction<R, E>(f: impl FnOnce() -> Result<R, E>) -> Result<R, E> {
+	sp_io::storage::start_transaction();
+	let r = f();
+	if r.is_ok() {
+		sp_io::storage::commit_transaction();
+	} else {
+		sp_io::storage::discard_transaction();
+	}
+	r
+}
+
 /// A trait for working with macro-generated storage values under the substrate storage API.
 ///
 /// Details on implementation can be found at

primitives/api/test/tests/runtime_calls.rs

@@ -106,7 +106,6 @@ fn calling_with_both_strategy_and_fail_on_native_should_work() {
 	assert_eq!(runtime_api.fail_on_native(&block_id).unwrap(), 1);
 }
 
-
 #[test]
 fn calling_with_native_else_wasm_and_fail_on_wasm_should_work() {
 	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::NativeElseWasm).build();
@@ -131,6 +130,23 @@ fn use_trie_function() {
 	assert_eq!(runtime_api.use_trie(&block_id).unwrap(), 2);
 }
 
+#[test]
+fn use_history_data() {
+	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::AlwaysWasm).build();
+	let runtime_api = client.runtime_api();
+	let block_id = BlockId::Number(client.info().chain.best_number);
+	assert!(runtime_api.use_history_data(&block_id).is_ok());
+}
+
+#[test]
+fn test_transactions() {
+	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::AlwaysWasm).build();
+	let runtime_api = client.runtime_api();
+	let block_id = BlockId::Number(client.info().chain.best_number);
+	assert_eq!(runtime_api.use_transactions(&block_id).unwrap(), 1);
+}
+
+
 #[test]
 fn initialize_block_works() {
 	let client = TestClientBuilder::new().set_execution_strategy(ExecutionStrategy::Both).build();

primitives/externalities/src/lib.rs

@@ -156,6 +156,16 @@ pub trait Externalities: ExtensionStore {
 	///
 	/// Returns the SCALE encoded hash.
 	fn storage_changes_root(&mut self, parent: &[u8]) -> Result<Option<Vec<u8>>, ()>;
+
+	/// Create a new transactional layer.
+	fn storage_start_transaction(&mut self);
+
+	/// Discard a transactional layer, pending changes of every transaction behind this layer are
+	/// dropped (including committed changes) .
+	fn storage_discard_transaction(&mut self);
+
+	/// Commit a transactional layer. The changes stay attached to parent transaction layer.
+	fn storage_commit_transaction(&mut self);
 }
 
 /// Extension for the [`Externalities`] trait.

primitives/historical-data/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "sp-historical-data"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Data associated with its history"
+edition = "2018"
+
+[dependencies]
+rstd = { package = "sp-std", path = "../std", default-features = false }
+smallvec = { version = "0.6", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+  "rstd/std",
+  "smallvec/std",
+]
+test-helpers = []

primitives/historical-data/README.md

@@ -0,0 +1,18 @@
+## Historical data
+
+Crate with functionality to manage data that stores its own history.
+
+This covers:
+- linear history driven data, eg. transactional layers for overlay.
+- long term storage with multiple branch, eg. offchain storage.
+
+General design is container where query and update requires global
+history context.
+
+History is serialize as a per item basis.
+
+This crates is `no_std` compatible as long as the `std` feature is not enabled.
+
+For more information see <https://crates.io/historical-data>
+
+License: GPL-3.0

primitives/historical-data/src/lib.rs

@@ -0,0 +1,92 @@
+// 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/>.
+
+//! Data storage containing multiple states for a value.
+//! This is used to store historical information for an item.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod synch_linear_transaction;
+
+/// An entry at a given history index.
+#[derive(Debug, Clone, PartialEq)]
+pub struct HistoricalValue<V, I> {
+	/// The stored value.
+	pub value: V,
+	/// The moment in history when the value got set.
+	pub index: I,
+}
+
+impl<V, I> From<(V, I)> for HistoricalValue<V, I> {
+	fn from(input: (V, I)) -> HistoricalValue<V, I> {
+		HistoricalValue { value: input.0, index: input.1 }
+	}
+}
+
+impl<V, I: Clone> HistoricalValue<V, I> {
+	fn as_mut(&mut self) -> HistoricalValue<&mut V, I> {
+		HistoricalValue { value: &mut self.value, index: self.index.clone() }
+	}
+}
+
+#[derive(Debug, PartialEq)]
+/// Results from cleaning a data with history.
+/// It should be used to update from the calling context,
+/// for instance remove this data from a map if it was cleared.
+pub enum CleaningResult {
+	Unchanged,
+	Changed,
+	Cleared,
+}
+
+/// History of value and their state.
+#[derive(Debug, Clone, PartialEq)]
+pub struct History<V, I>(pub(crate) smallvec::SmallVec<[HistoricalValue<V, I>; ALLOCATED_HISTORY]>);
+
+impl<V, I> Default for History<V, I> {
+	fn default() -> Self {
+		History(Default::default())
+	}
+}
+
+/// Size of preallocated history per element.
+/// Currently at two for committed and prospective only.
+/// It means that using transaction in a module got a direct allocation cost.
+const ALLOCATED_HISTORY: usize = 2;
+
+impl<V, I> History<V, I> {
+	#[cfg(any(test, feature = "test-helpers"))]
+	/// Get current number of stored historical values.
+	pub fn len(&self) -> usize {
+		self.0.len()
+	}
+
+	#[cfg(any(test, feature = "test-helpers"))]
+	/// Create an history from an existing history.
+	pub fn from_iter(input: impl IntoIterator<Item = HistoricalValue<V, I>>) -> Self {
+		let mut history = History::default();
+		for v in input {
+			history.push_unchecked(v);
+		}
+		history
+	}
+
+	/// Push a value without checking if it can overwrite the current
+	/// state.
+	pub fn push_unchecked(&mut self, item: HistoricalValue<V, I>) {
+		self.0.push(item);
+	}
+}