progress on true call UI types

bin/node/runtime/src/lib.rs

@@ -201,8 +201,8 @@ parameter_types! {
 
 const_assert!(NORMAL_DISPATCH_RATIO.deconstruct() >= AVERAGE_ON_INITIALIZE_RATIO.deconstruct());
 
-pub struct UnpausablePallets;
-impl Contains<pallet_tx_pause::PalletNameOf<Runtime>> for UnpausablePallets {
+pub struct UnpausableCalls; // TODO move to calls, use (..) to match on pallets like ProxyType
+impl Contains<pallet_tx_pause::PalletNameOf<Runtime>> for UnpausableCalls {
 	fn contains(pallet: &pallet_tx_pause::PalletNameOf<Runtime>) -> bool {
 		pallet.as_ref() ==
 			<pallet_safe_mode::Pallet<Runtime> as PalletInfoAccess>::name()
@@ -211,9 +211,17 @@ impl Contains<pallet_tx_pause::PalletNameOf<Runtime>> for UnpausablePallets {
 	}
 }
 
+impl Contains<RuntimeCall> for MockUnpausableCalls {
+	fn contains(call: &RuntimeCall) -> bool {
+		matches!(call,
+			RuntimeCall::TxPause(..) |
+			RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive {..})
+			)
+	}
+}
+
 impl pallet_tx_pause::Config for Runtime {
 	type Event = Event;
-	type UnpausablePallets = UnpausablePallets;
 	type PauseOrigin = EnsureRoot<AccountId>;
 	type UnpauseOrigin = EnsureRoot<AccountId>;
 	type MaxNameLen = ConstU32<256>;
@@ -238,7 +246,7 @@ parameter_types! {
 impl pallet_safe_mode::Config for Runtime {
 	type Event = Event;
 	type Currency = Balances;
-	type SafeModeFilter = Nothing; // TODO add TxPause pallet
+	type UnstoppableCalls = Nothing; // TODO add TxPause pallet
 	type ActivateDuration = ConstU32<{ 2 * DAYS }>;
 	type ExtendDuration = ConstU32<{ 1 * DAYS }>;
 	type EnableOrigin = EnsureRootWithSuccess<AccountId, BlockHeight>;
@@ -251,7 +259,7 @@ impl pallet_safe_mode::Config for Runtime {
 }
 
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = InsideBoth<SafeMode, TxPause>;
+	type BaseCallFilter = TheseExcept<InsideBoth<SafeMode, TxPause>, UnpausableCalls>; // TODO consider Exclude or NotInside... so no config for UnpausableCalls unneeded ( see TheseExcept )
 	type BlockWeights = RuntimeBlockWeights;
 	type BlockLength = RuntimeBlockLength;
 	type DbWeight = RocksDbWeight;
@@ -326,6 +334,11 @@ parameter_types! {
 	MaxEncodedLen,
 	scale_info::TypeInfo,
 )]
+
+pub enum PausePresets {
+	...,
+
+}
 pub enum ProxyType {
 	Any,
 	NonTransfer,

frame/safe-mode/src/lib.rs

@@ -61,8 +61,8 @@ pub mod pallet {
 
 		/// Contains all calls that can be dispatched even when the safe-mode is activated.
 		///
-		/// The `SafeMode` pallet is always included and does not need to be added here.
-		type SafeModeFilter: Contains<Self::RuntimeCall>;
+		/// The `SafeMode` pallet cannot disable it's own calls, and does not need to be explicitly added here.
+		type UnstoppableCalls: Contains<Self::RuntimeCall>;
 
 		/// How long the safe-mode will stay active when activated with [`Pallet::activate`].
 		#[pallet::constant]
@@ -317,7 +317,7 @@ pub mod pallet {
 
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
-		/// Automatically inactivates the safe-mode when the period ran out.
+		/// Automatically inactivates the safe-mode when the period runs out.
 		///
 		/// Bypasses any call filters to avoid getting rejected by them.
 		fn on_initialize(current: T::BlockNumber) -> Weight {
@@ -424,7 +424,7 @@ impl<T: Config> Pallet<T> {
 		}
 
 		if Self::is_activated() {
-			T::SafeModeFilter::contains(call)
+			T::UnstoppableCalls::contains(call)
 		} else {
 			true
 		}

frame/safe-mode/src/mock.rs

@@ -78,8 +78,8 @@ impl pallet_balances::Config for Test {
 }
 
 /// Filter to block balance pallet calls
-pub struct MockSafeModeFilter;
-impl Contains<RuntimeCall> for MockSafeModeFilter {
+pub struct MockUnstoppableCalls;
+impl Contains<RuntimeCall> for MockUnstoppableCalls {
 	fn contains(call: &RuntimeCall) -> bool {
 		match call {
 			RuntimeCall::System(_) | RuntimeCall::SafeMode(_) => true,
@@ -216,7 +216,7 @@ impl SortedMembers<u64> for RepayOrigin {
 impl Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
-	type SafeModeFilter = MockSafeModeFilter;
+	type UnstoppableCalls = MockUnstoppableCalls;
 	type ActivateDuration = ActivateDuration;
 	type ExtendDuration = ExtendDuration;
 	type ActivateStakeAmount = ActivateStakeAmount;

frame/tx-pause/src/lib.rs

@@ -27,10 +27,15 @@ pub mod weights;
 
 use frame_support::{
 	pallet_prelude::*,
-	traits::{CallMetadata, Contains, GetCallMetadata},
+	traits::{CallMetadata, Contains, GetCallMetadata, IsSubType, IsType},
+	dispatch::GetDispatchInfo,
 };
 use frame_system::pallet_prelude::*;
 use sp_std::{convert::TryInto, prelude::*};
+use sp_runtime::{
+	traits::Dispatchable,
+	DispatchResult
+};
 
 pub use pallet::*;
 pub use weights::*;
@@ -51,6 +56,14 @@ pub mod pallet {
 		/// The overarching event type.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+		+ Dispatchable<Origin = Self::Origin>
+		+ GetDispatchInfo
+		+ From<frame_system::Call<Self>>
+		+ IsSubType<Call<Self>>
+		+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
 		/// The only origin that can pause calls.
 		type PauseOrigin: EnsureOrigin<Self::Origin>;
 
@@ -60,7 +73,7 @@ pub mod pallet {
 		/// Pallets that are safe and can never be paused.
 		///
 		/// The tx-pause pallet is always assumed to be safe itself.
-		type UnpausablePallets: Contains<PalletNameOf<Self>>;
+		type UnpausableCalls: Contains<<Self as Config>::RuntimeCall>;
 
 		/// Maximum length for pallet- and function-names.
 		///
@@ -144,33 +157,45 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::pause_call())]
 		pub fn pause_call(
 			origin: OriginFor<T>,
-			pallet: PalletNameOf<T>,
-			call: CallNameOf<T>,
+			call: Box<<T as Config>::RuntimeCall>,
 		) -> DispatchResult {
 			T::PauseOrigin::ensure_origin(origin)?;
 
-			Self::ensure_can_pause(&pallet, &call)?;
-			PausedCalls::<T>::insert((&pallet, &call), ());
-			Self::deposit_event(Event::CallPaused(pallet, call));
+			let CallMetadata { pallet_name, function_name } = call.get_call_metadata();
+
+			Self::ensure_can_pause(&pallet_name, &function_name)?;
+			PausedCalls::<T>::insert((&pallet_name, &function_name), ());
+			Self::deposit_event(Event::CallPaused(pallet_name, function_name));
 
 			Ok(())
 		}
 
+		// TODO add preset pause functionality (set of calls) See proxy and ProyType in node runtime
+		// pub fn pause_preset(
+		// 	origin: OriginFor<T>,
+		// 	preset: PausePresets,
+		// ) {
+		// 	loop
+		// 		do_pause_call() // run over a pre-config vec of calls for each type of PausePreset
+		// 		// we can use the same storage, a vec of all paused calls.
+		// }
+
 		/// Un-pause a call.
 		///
 		/// Can only be called by [`Config::UnpauseOrigin`].
 		/// Emits an [`Event::CallUnpaused`] event on success.
 		#[pallet::weight(T::WeightInfo::unpause_call())]
 		pub fn unpause_call(
 			origin: OriginFor<T>,
-			pallet: PalletNameOf<T>,
-			call: CallNameOf<T>,
+			call: Box<<T as Config>::RuntimeCall>,
 		) -> DispatchResult {
 			T::UnpauseOrigin::ensure_origin(origin)?;
 
-			Self::ensure_can_unpause(&pallet, &call)?;
-			PausedCalls::<T>::remove((&pallet, &call));
-			Self::deposit_event(Event::CallUnpaused(pallet, call));
+			let CallMetadata { pallet_name, function_name } = call.get_call_metadata();
+
+			Self::ensure_can_unpause(&pallet_name, &function_name)?;
+			PausedCalls::<T>::remove((&pallet_name, &function_name));
+			Self::deposit_event(Event::CallUnpaused(pallet_name, function_name));
 
 			Ok(())
 		}
@@ -203,9 +228,10 @@ impl<T: Config> Pallet<T> {
 		if pallet.as_ref() == <Self as PalletInfoAccess>::name().as_bytes().to_vec() {
 			return Err(Error::<T>::IsUnpausable)
 		}
-		if T::UnpausablePallets::contains(&pallet) {
-			return Err(Error::<T>::IsUnpausable)
-		}
+		// TODO need a way to see if any RuntimeCall matches the stringy pallet & call names here
+		// if T::UnpausableCalls::contains(&pallet, &call) {
+		// 	return Err(Error::<T>::IsUnpausable)
+		// }
 		if Self::is_paused(pallet, call) {
 			return Err(Error::<T>::IsPaused)
 		}
@@ -233,6 +259,6 @@ where
 	/// Return whether the call is allowed to be dispatched.
 	fn contains(call: &T::RuntimeCall) -> bool {
 		let CallMetadata { pallet_name, function_name } = call.get_call_metadata();
-		!Pallet::<T>::is_paused_unbound(pallet_name.into(), function_name.into())
+			!Pallet::<T>::is_paused_unbound(pallet_name.into(), function_name.into())
 	}
-}
+}

frame/tx-pause/src/mock.rs

@@ -84,16 +84,17 @@ parameter_types! {
   pub const PauseTooLongNames: bool = false;
 }
 
-pub struct MockUnpausablePallets;
-
-impl Contains<PalletNameOf<Test>> for MockUnpausablePallets {
-	fn contains(pallet: &PalletNameOf<Test>) -> bool {
-		let unpausables: Vec<PalletNameOf<Test>> =
-			vec![b"UnpausablePallet".to_vec().try_into().unwrap()];
-
-		unpausables.iter().any(|i| i == pallet)
+pub struct MockUnpausableCalls;
+
+impl Contains<RuntimeCall> for MockUnpausableCalls {
+	fn contains(call: &RuntimeCall) -> bool {
+		matches!(call,
+			RuntimeCall::TxPause(..) |
+			RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive {..})
+			)
 	}
 }
+
 // Required impl to use some <Configured Origin>::get() in tests
 impl SortedMembers<u64> for PauseOrigin {
 	fn sorted_members() -> Vec<u64> {
@@ -114,7 +115,7 @@ impl Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type PauseOrigin = EnsureSignedBy<PauseOrigin, Self::AccountId>;
 	type UnpauseOrigin = EnsureSignedBy<UnpauseOrigin, Self::AccountId>;
-	type UnpausablePallets = MockUnpausablePallets;
+	type UnpausableCalls = MockUnpausableCalls;
 	type MaxNameLen = MaxNameLen;
 	type PauseTooLongNames = PauseTooLongNames;
 	type WeightInfo = ();