Use Storage for Tracking Transactional Layers

frame/contracts/src/exec.rs

@@ -23,7 +23,7 @@ use crate::{
 };
 use frame_support::{
 	dispatch::{DispatchError, DispatchResult, DispatchResultWithPostInfo, Dispatchable},
-	storage::{with_transaction, TransactionOutcome},
+	storage::{execute_with_storage_layer, TransactionOutcome},
 	traits::{Contains, Currency, ExistenceRequirement, OriginTrait, Randomness, Time},
 	weights::Weight,
 };
@@ -721,7 +721,7 @@ where
 		// All changes performed by the contract are executed under a storage transaction.
 		// This allows for roll back on error. Changes to the cached contract_info are
 		// comitted or rolled back when popping the frame.
-		let (success, output) = with_transaction(|| {
+		let (success, output) = execute_with_storage_layer(u8::MAX, || {
 			let output = do_transaction();
 			match &output {
 				Ok(result) if !result.did_revert() => TransactionOutcome::Commit((true, output)),

frame/support/procedural/src/lib.rs

@@ -30,7 +30,7 @@ mod match_and_insert;
 mod pallet;
 mod partial_eq_no_bound;
 mod storage;
-mod transactional;
+mod storage_layer;
 
 use proc_macro::TokenStream;
 use std::{cell::RefCell, str::FromStr};
@@ -413,21 +413,21 @@ pub fn pallet(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// # Example
 ///
 /// ```nocompile
-/// #[transactional]
+/// #[add_storage_layer]
 /// fn value_commits(v: u32) -> result::Result<u32, &'static str> {
 /// 	Value::set(v);
 /// 	Ok(v)
 /// }
 ///
-/// #[transactional]
+/// #[add_storage_layer]
 /// fn value_rollbacks(v: u32) -> result::Result<u32, &'static str> {
 /// 	Value::set(v);
 /// 	Err("nah")
 /// }
 /// ```
 #[proc_macro_attribute]
-pub fn transactional(attr: TokenStream, input: TokenStream) -> TokenStream {
-	transactional::transactional(attr, input).unwrap_or_else(|e| e.to_compile_error().into())
+pub fn add_storage_layer(attr: TokenStream, input: TokenStream) -> TokenStream {
+	storage_layer::add_storage_layer(attr, input).unwrap_or_else(|e| e.to_compile_error().into())
 }
 
 /// Derive [`Clone`] but do not bound any generic. Docs are at `frame_support::CloneNoBound`.
@@ -508,8 +508,8 @@ pub fn derive_default_no_bound(input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro_attribute]
-pub fn require_transactional(attr: TokenStream, input: TokenStream) -> TokenStream {
-	transactional::require_transactional(attr, input)
+pub fn require_storage_layer(attr: TokenStream, input: TokenStream) -> TokenStream {
+	storage_layer::require_storage_layer(attr, input)
 		.unwrap_or_else(|e| e.to_compile_error().into())
 }
 

frame/support/procedural/src/storage_layer.rs

@@ -0,0 +1,103 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse::Parse, ItemFn, LitInt, Result};
+
+struct StorageLayerLimit {
+	limit: u8,
+}
+
+impl Default for StorageLayerLimit {
+	fn default() -> Self {
+		Self { limit: 1 }
+	}
+}
+
+impl Parse for StorageLayerLimit {
+	fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+		let limit: LitInt = input.parse()?;
+		Ok(Self { limit: limit.base10_parse()? })
+	}
+}
+
+pub fn add_storage_layer(attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
+	let limit: StorageLayerLimit = syn::parse(attr).unwrap_or_default();
+	let limit = limit.limit;
+
+	let ItemFn { attrs, vis, sig, block } = syn::parse(input)?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+	let output = quote! {
+		#(#attrs)*
+		#vis #sig {
+			use #crate_::storage::execute_with_storage_layer;
+			// Otherwise, spawn a transaction layer.
+			execute_with_storage_layer(#limit, || {
+				(|| { #block })()
+			})
+		}
+	};
+
+	Ok(output.into())
+}
+
+// Similar to `add_storage_layer` but only spawns at most 1 layer.
+pub fn with_storage_layer(attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
+	let limit: StorageLayerLimit = syn::parse(attr).unwrap_or_default();
+	let limit = limit.limit;
+
+	let ItemFn { attrs, vis, sig, block } = syn::parse(input)?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+	let output = quote! {
+		#(#attrs)*
+		#vis #sig {
+			use #crate_::storage::{execute_with_storage_layer, has_storage_layer};
+			if has_storage_layer() {
+				// We are already in a transaction layer, just execute the block.
+				(|| { #block })()
+			} else {
+				// Otherwise, spawn a transaction layer.
+				execute_with_storage_layer(#limit, || {
+					(|| { #block })()
+				})
+			}
+		}
+	};
+
+	Ok(output.into())
+}
+
+pub fn require_storage_layer(_attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
+	let ItemFn { attrs, vis, sig, block } = syn::parse(input)?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+	let output = quote! {
+		#(#attrs)*
+		#vis #sig {
+			if !#crate_::storage::has_storage_layer(){
+				return Err(#crate_::pallet_prelude::DispatchError::StorageLayersLimit.into())
+			}
+			#block
+		}
+	};
+
+	Ok(output.into())
+}

frame/support/src/dispatch.rs

@@ -180,12 +180,12 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug +
 /// ```
 /// # #[macro_use]
 /// # extern crate frame_support;
-/// # use frame_support::transactional;
+/// # use frame_support::add_storage_layer;
 /// # use frame_system::Config;
 /// decl_module! {
 /// 	pub struct Module<T: Config> for enum Call where origin: T::Origin {
 /// 		#[weight = 0]
-/// 		#[transactional]
+/// 		#[add_storage_layer]
 /// 		fn my_short_function(origin) {
 /// 				// Your implementation
 /// 		}

frame/support/src/lib.rs

@@ -598,7 +598,7 @@ pub fn debug(data: &impl sp_std::fmt::Debug) {
 
 #[doc(inline)]
 pub use frame_support_procedural::{
-	construct_runtime, decl_storage, match_and_insert, transactional, RuntimeDebugNoBound,
+	add_storage_layer, construct_runtime, decl_storage, match_and_insert, RuntimeDebugNoBound,
 };
 
 #[doc(hidden)]
@@ -704,17 +704,17 @@ pub use frame_support_procedural::DefaultNoBound;
 ///
 /// ```
 /// # use frame_support::{
-/// # 	require_transactional, transactional, dispatch::DispatchResult
+/// # 	require_storage_layer, add_storage_layer, dispatch::DispatchResult
 /// # };
 ///
-/// #[require_transactional]
+/// #[require_storage_layer]
 /// fn update_all(value: u32) -> DispatchResult {
 /// 	// Update multiple storages.
 /// 	// Return `Err` to indicate should revert.
 /// 	Ok(())
 /// }
 ///
-/// #[transactional]
+/// #[add_storage_layer]
 /// fn safe_update(value: u32) -> DispatchResult {
 /// 	// This is safe
 /// 	update_all(value)
@@ -725,7 +725,7 @@ pub use frame_support_procedural::DefaultNoBound;
 /// 	update_all(value)
 /// }
 /// ```
-pub use frame_support_procedural::require_transactional;
+pub use frame_support_procedural::require_storage_layer;
 
 /// Convert the current crate version into a [`CrateVersion`](crate::traits::CrateVersion).
 ///