Improvments to runtime configuration

pallets/common/Cargo.toml

@@ -17,17 +17,29 @@ scale-info = { features = ["derive"], workspace = true }
 polkadot-sdk-frame = { workspace = true, default-features = false, features = [
 	"runtime",
 ] }
+pallet-proxy = { workspace = true }
+pallet-sudo = { workspace = true }
+pallet-utility = { workspace = true }
 
 [features]
 default = ["std"]
 runtime-benchmarks = [
+	"pallet-proxy/runtime-benchmarks",
+	"pallet-sudo/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
 	"polkadot-sdk-frame/runtime-benchmarks",
 ]
 std = [
 	"codec/std",
+	"pallet-proxy/std",
+	"pallet-sudo/std",
+	"pallet-utility/std",
 	"polkadot-sdk-frame/std",
 	"scale-info/std",
 ]
 try-runtime = [
+	"pallet-proxy/try-runtime",
+	"pallet-sudo/try-runtime",
+	"pallet-utility/try-runtime",
 	"polkadot-sdk-frame/try-runtime",
 ]

pallets/common/src/lib.rs

@@ -15,6 +15,9 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+extern crate alloc;
+
+use alloc::{vec, vec::Vec};
 use codec::{Decode, Encode};
 use polkadot_sdk_frame::{
 	deps::frame_support,
@@ -324,3 +327,96 @@ impl<AccountId, HoldReason> ReservableCurrency<AccountId> for NoCurrency<Account
 		Zero::zero()
 	}
 }
+
+/// Inspect a utility call for wrapper semantics: returns the inner calls if the call
+/// is a wrapper variant, `None` otherwise.
+pub fn inspect_utility_wrapper<T: pallet_utility::Config>(
+	call: &pallet_utility::Call<T>,
+) -> Option<Vec<&<T as pallet_utility::Config>::RuntimeCall>> {
+	let inner = utility_inner_calls(call);
+	if inner.is_empty() {
+		return None;
+	}
+	Some(inner)
+}
+
+/// Inspect a sudo call for wrapper semantics: returns inner calls.
+pub fn inspect_sudo_wrapper<T: pallet_sudo::Config>(
+	call: &pallet_sudo::Call<T>,
+) -> Option<Vec<&<T as pallet_sudo::Config>::RuntimeCall>> {
+	let inner = sudo_inner_calls(call);
+	if inner.is_empty() {
+		return None;
+	}
+	Some(inner)
+}
+
+/// Inspect a proxy call for wrapper semantics: returns inner calls.
+pub fn inspect_proxy_wrapper<T: pallet_proxy::Config>(
+	call: &pallet_proxy::Call<T>,
+) -> Option<Vec<&<T as pallet_proxy::Config>::RuntimeCall>> {
+	let inner = proxy_inner_calls(call);
+	if inner.is_empty() {
+		return None;
+	}
+	Some(inner)
+}
+
+/// Extract inner calls from a utility call variant.
+pub fn utility_inner_calls<T: pallet_utility::Config>(
+	call: &pallet_utility::Call<T>,
+) -> Vec<&<T as pallet_utility::Config>::RuntimeCall> {
+	match call {
+		pallet_utility::Call::batch { calls } |
+		pallet_utility::Call::batch_all { calls } |
+		pallet_utility::Call::force_batch { calls } => calls.iter().collect(),
+		pallet_utility::Call::as_derivative { call, .. } |
+		pallet_utility::Call::dispatch_as { call, .. } |
+		pallet_utility::Call::with_weight { call, .. } |
+		pallet_utility::Call::dispatch_as_fallible { call, .. } => vec![call.as_ref()],
+		// `if_else` executes only ONE branch (fallback runs only if main fails),
+		// but we return both so that authorization is validated and consumed for
+		// both paths during prepare. This over-charges by one branch's worth of
+		// authorization, but is safe — the alternative of only validating `main`
+		// would leave the `fallback` store unvalidated if it runs.
+		pallet_utility::Call::if_else { main, fallback, .. } =>
+			vec![main.as_ref(), fallback.as_ref()],
+		// __Ignore is a phantom variant generated by FRAME (contains Never so is
+		// unreachable). Listing it explicitly instead of `_` ensures that new
+		// upstream variants cause a compile error, forcing a conscious decision.
+		pallet_utility::Call::__Ignore(..) => vec![],
+	}
+}
+
+/// Extract inner calls from a proxy call variant.
+pub fn proxy_inner_calls<T: pallet_proxy::Config>(
+	call: &pallet_proxy::Call<T>,
+) -> Vec<&<T as pallet_proxy::Config>::RuntimeCall> {
+	match call {
+		pallet_proxy::Call::proxy { call, .. } |
+		pallet_proxy::Call::proxy_announced { call, .. } => vec![call.as_ref()],
+		pallet_proxy::Call::add_proxy { .. } |
+		pallet_proxy::Call::remove_proxy { .. } |
+		pallet_proxy::Call::remove_proxies { .. } |
+		pallet_proxy::Call::create_pure { .. } |
+		pallet_proxy::Call::kill_pure { .. } |
+		pallet_proxy::Call::announce { .. } |
+		pallet_proxy::Call::remove_announcement { .. } |
+		pallet_proxy::Call::reject_announcement { .. } |
+		pallet_proxy::Call::poke_deposit { .. } => vec![],
+		pallet_proxy::Call::__Ignore(..) => vec![],
+	}
+}
+
+/// Extract inner calls from a sudo call variant.
+pub fn sudo_inner_calls<T: pallet_sudo::Config>(
+	call: &pallet_sudo::Call<T>,
+) -> Vec<&<T as pallet_sudo::Config>::RuntimeCall> {
+	match call {
+		pallet_sudo::Call::sudo { call } |
+		pallet_sudo::Call::sudo_as { call, .. } |
+		pallet_sudo::Call::sudo_unchecked_weight { call, .. } => vec![call.as_ref()],
+		pallet_sudo::Call::set_key { .. } | pallet_sudo::Call::remove_key {} => vec![],
+		pallet_sudo::Call::__Ignore(..) => vec![],
+	}
+}