Adds syntax for marking calls feeless

substrate/bin/node-template/pallets/template/src/lib.rs

@@ -154,6 +154,9 @@ pub mod pallet {
 		/// error if it isn't. Learn more about origins here: <https://docs.substrate.io/build/origins/>
 		#[pallet::call_index(0)]
 		#[pallet::weight(T::WeightInfo::do_something())]
+		#[pallet::feeless_if(|_who: &AccountIdFor<T>, something: &u32| -> bool {
+			*something == 0
+		})]
 		pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResult {
 			// Check that the extrinsic was signed and get the signer.
 			let who = ensure_signed(origin)?;

substrate/bin/node-template/runtime/src/lib.rs

@@ -309,7 +309,7 @@ pub type SignedExtra = (
 	frame_system::CheckEra<Runtime>,
 	frame_system::CheckNonce<Runtime>,
 	frame_system::CheckWeight<Runtime>,
-	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+	SkipCheckIfFeeless<pallet_transaction_payment::ChargeTransactionPayment<Runtime>>,
 );
 
 /// Unchecked extrinsic type as expected by this runtime.

substrate/frame/support/procedural/src/construct_runtime/expand/call.rs

@@ -124,6 +124,18 @@ pub fn expand_outer_dispatch(
 			}
 		}
 
+		impl #scrate::dispatch::CheckIfFeeless for RuntimeCall {
+			type AccountId = #system_path::pallet_prelude::AccountIdFor<#runtime>;
+			fn is_feeless(&self, account_id: &Self::AccountId) -> bool {
+				match self {
+					#(
+						#pallet_attrs
+						#variant_patterns => call.is_feeless(account_id),
+					)*
+				}
+			}
+		}
+
 		impl #scrate::traits::GetCallMetadata for RuntimeCall {
 			fn get_call_metadata(&self) -> #scrate::traits::CallMetadata {
 				use #scrate::traits::GetCallName;
@@ -207,5 +219,61 @@ pub fn expand_outer_dispatch(
 				}
 			}
 		)*
+
+		/// SkipCheckIfFeeless
+		#[derive(
+			#scrate::RuntimeDebugNoBound,
+			#scrate::CloneNoBound,
+			#scrate::EqNoBound,
+			#scrate::PartialEqNoBound,
+			#scrate::__private::codec::Encode,
+			#scrate::__private::codec::Decode,
+			#scrate::__private::scale_info::TypeInfo,
+		)]
+		pub struct SkipCheckIfFeeless<T: #scrate::sp_runtime::traits::SignedExtension>(T);
+
+		impl<T: #scrate::sp_runtime::traits::SignedExtension> #scrate::sp_runtime::traits::SignedExtension for SkipCheckIfFeeless<T>
+		where
+			T::Call: #scrate::dispatch::CheckIfFeeless<AccountId = T::AccountId>
+		{
+			type AccountId = T::AccountId;
+			type Call = T::Call;
+			type AdditionalSigned = ();
+			type Pre = Option<T::Pre>;
+			const IDENTIFIER: &'static str = "SkipCheckIfFeeless";
+
+			fn additional_signed(&self) -> #scrate::__private::sp_std::result::Result<(), #scrate::sp_runtime::transaction_validity::TransactionValidityError> {
+				Ok(())
+			}
+
+			fn pre_dispatch(
+				self,
+				who: &Self::AccountId,
+				call: &Self::Call,
+				info: &#scrate::sp_runtime::traits::DispatchInfoOf<Self::Call>,
+				len: usize,
+			) -> Result<Self::Pre, #scrate::sp_runtime::transaction_validity::TransactionValidityError> {
+				use #scrate::dispatch::CheckIfFeeless;
+				match call.is_feeless(who) {
+					true => Ok(None),
+					false => Ok(Some(self.0.pre_dispatch(who, call, info, len)?)),
+				}
+			}
+
+			fn post_dispatch(
+				pre: Option<Self::Pre>,
+				info: &#scrate::sp_runtime::traits::DispatchInfoOf<Self::Call>,
+				post_info: &#scrate::sp_runtime::traits::PostDispatchInfoOf<Self::Call>,
+				len: usize,
+				result: &#scrate::dispatch::DispatchResult,
+			) -> Result<(), #scrate::sp_runtime::transaction_validity::TransactionValidityError> {
+				if let Some(pre) = pre {
+					if let Some(pre) = pre {
+						T::post_dispatch(Some(pre), info, post_info, len, result)?;
+					}
+				}
+				Ok(())
+			}
+		}
 	}
 }

substrate/frame/support/procedural/src/pallet/expand/call.rs

@@ -241,6 +241,16 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 		})
 		.collect::<Vec<_>>();
 
+	let feeless_check = methods.iter().map(|method| &method.feeless_check).collect::<Vec<_>>();
+	let feeless_check_result =
+		feeless_check.iter().zip(args_name.iter()).map(|(feeless_check, arg_name)| {
+			if let Some(feeless_check) = feeless_check {
+				quote::quote!(#feeless_check(account_id, #( #arg_name, )*))
+			} else {
+				quote::quote!(false)
+			}
+		});
+
 	quote::quote_spanned!(span =>
 		mod warnings {
 			#(
@@ -347,6 +357,23 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 			}
 		}
 
+		impl<#type_impl_gen> #frame_support::dispatch::CheckIfFeeless for #call_ident<#type_use_gen>
+			#where_clause
+		{
+			type AccountId = #frame_system::pallet_prelude::AccountIdFor<T>;
+			#[allow(unused_variables)]
+			fn is_feeless(&self, account_id: &Self::AccountId) -> bool {
+				match *self {
+					#(
+						Self::#fn_name { #( #args_name_pattern_ref, )* } => {
+							#feeless_check_result
+						},
+					)*
+					Self::__Ignore(_, _) => unreachable!("__Ignore cannot be used"),
+				}
+			}
+		}
+
 		impl<#type_impl_gen> #frame_support::traits::GetCallName for #call_ident<#type_use_gen>
 			#where_clause
 		{

substrate/frame/support/procedural/src/pallet/parse/call.rs

@@ -19,7 +19,7 @@ use super::{helper, InheritedCallWeightAttr};
 use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
 use std::collections::HashMap;
-use syn::spanned::Spanned;
+use syn::{spanned::Spanned, ExprClosure};
 
 /// List of additional token to be used for parsing.
 mod keyword {
@@ -30,6 +30,7 @@ mod keyword {
 	syn::custom_keyword!(compact);
 	syn::custom_keyword!(T);
 	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(feeless_if);
 }
 
 /// Definition of dispatchables typically `impl<T: Config> Pallet<T> { ... }`
@@ -82,13 +83,17 @@ pub struct CallVariantDef {
 	pub docs: Vec<syn::Expr>,
 	/// Attributes annotated at the top of the dispatchable function.
 	pub attrs: Vec<syn::Attribute>,
+	/// The optional `feeless_if` attribute on the `pallet::call`.
+	pub feeless_check: Option<syn::ExprClosure>,
 }
 
 /// Attributes for functions in call impl block.
-/// Parse for `#[pallet::weight(expr)]` or `#[pallet::call_index(expr)]
+/// Parse for `#[pallet::weight(expr)]` or `#[pallet::call_index(expr)] or
+/// `#[pallet::feeless_if(expr)]`
 pub enum FunctionAttr {
 	CallIndex(u8),
 	Weight(syn::Expr),
+	FeelessIf(syn::ExprClosure),
 }
 
 impl syn::parse::Parse for FunctionAttr {
@@ -115,6 +120,11 @@ impl syn::parse::Parse for FunctionAttr {
 				return Err(syn::Error::new(index.span(), msg))
 			}
 			Ok(FunctionAttr::CallIndex(index.base10_parse()?))
+		} else if lookahead.peek(keyword::feeless_if) {
+			content.parse::<keyword::feeless_if>()?;
+			let closure_content;
+			syn::parenthesized!(closure_content in content);
+			Ok(FunctionAttr::FeelessIf(closure_content.parse::<syn::ExprClosure>()?))
 		} else {
 			Err(lookahead.error())
 		}
@@ -227,16 +237,22 @@ impl CallDef {
 					return Err(syn::Error::new(method.sig.span(), msg))
 				}
 
-				let (mut weight_attrs, mut call_idx_attrs): (Vec<FunctionAttr>, Vec<FunctionAttr>) =
-					helper::take_item_pallet_attrs(&mut method.attrs)?.into_iter().partition(
-						|attr| {
-							if let FunctionAttr::Weight(_) = attr {
-								true
-							} else {
-								false
-							}
+				let mut call_idx_attrs = vec![];
+				let mut weight_attrs = vec![];
+				let mut feeless_attrs = vec![];
+				for attr in helper::take_item_pallet_attrs(&mut method.attrs)?.into_iter() {
+					match attr {
+						FunctionAttr::CallIndex(_) => {
+							call_idx_attrs.push(attr);
 						},
-					);
+						FunctionAttr::Weight(_) => {
+							weight_attrs.push(attr);
+						},
+						FunctionAttr::FeelessIf(_) => {
+							feeless_attrs.push(attr);
+						},
+					}
+				}
 
 				if weight_attrs.is_empty() && dev_mode {
 					// inject a default O(1) weight when dev mode is enabled and no weight has
@@ -323,6 +339,16 @@ impl CallDef {
 
 				let docs = get_doc_literals(&method.attrs);
 
+				if feeless_attrs.len() > 1 {
+					let msg = "Invalid pallet::call, too many feeless_if attributes given";
+					return Err(syn::Error::new(method.sig.span(), msg))
+				}
+				let feeless_check: Option<ExprClosure> =
+					feeless_attrs.pop().map(|attr| match attr {
+						FunctionAttr::FeelessIf(closure) => closure,
+						_ => unreachable!("checked during creation of the let binding"),
+					});
+
 				methods.push(CallVariantDef {
 					name: method.sig.ident.clone(),
 					weight,
@@ -331,6 +357,7 @@ impl CallDef {
 					args,
 					docs,
 					attrs: method.attrs.clone(),
+					feeless_check,
 				});
 			} else {
 				let msg = "Invalid pallet::call, only method accepted";

substrate/frame/support/src/dispatch.rs

@@ -54,6 +54,12 @@ pub trait Callable<T> {
 // https://github.com/rust-lang/rust/issues/51331
 pub type CallableCallFor<A, R> = <A as Callable<R>>::RuntimeCall;
 
+pub trait CheckIfFeeless {
+	type AccountId;
+
+	fn is_feeless(&self, account_d: &Self::AccountId) -> bool;
+}
+
 /// Origin for the System pallet.
 #[derive(PartialEq, Eq, Clone, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
 pub enum RawOrigin<AccountId> {

substrate/frame/system/src/lib.rs

@@ -1811,6 +1811,8 @@ pub mod pallet_prelude {
 	/// Type alias for the `Origin` associated type of system config.
 	pub type OriginFor<T> = <T as crate::Config>::RuntimeOrigin;
 
+	pub type AccountIdFor<T> = <T as crate::Config>::AccountId;
+
 	/// Type alias for the `Header`.
 	pub type HeaderFor<T> =
 		<<T as crate::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;