sudo pallet ported as local pallet

Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>

Cargo.toml

@@ -17,7 +17,7 @@ homepage.workspace = true
 [workspace.package]
 license = "GPL-3.0-only"
 authors = ["571nky", "57r37ch", "f4750"]
-version = "0.7.201"
+version = "0.7.202"
 edition = "2021"
 homepage = "https://ghostchain.io"
 repository = "https://git.ghostchain.io/ghostchain/ghost-node"
@@ -229,6 +229,7 @@ ghost-traits = { path = "pallets/traits", default-features = false }
 ghost-networks = { path = "pallets/networks", default-features = false }
 ghost-claims = { path = "pallets/claims", default-features = false }
 ghost-slow-clap = { path = "pallets/slow-clap", default-features = false }
+ghost-sudo = { path = "pallets/sudo", default-features = false }
 ghost-runtime-constants = { package = "ghost-runtime-constants", path = "runtime/ghost/constants", default-features = false }
 casper-runtime = { path = "runtime/casper", default-features = false }
 casper-runtime-constants = { package = "casper-runtime-constants", path = "runtime/casper/constants", default-features = false }
@@ -271,6 +272,7 @@ members = [
     "pallets/networks",
     "pallets/claims",
     "pallets/slow-clap",
+    "pallets/sudo",
     "utils/bags-list",
     "utils/chain-spec-builder",
     "utils/generate-bags",

pallets/sudo/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "ghost-sudo"
+version = "0.0.0"
+description = "Port of the sudo pallet because of dependencies issue"
+license.workspace = true
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[dependencies]
+docify = "0.2.8"
+codec = { workspace = true, features = ["derive"] }
+frame-benchmarking = { workspace = true, optional = true }
+scale-info = { workspace = true, features = ["derive"] }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]

pallets/sudo/src/benchmarking.rs

@@ -0,0 +1,70 @@
+use super::*;
+use crate::Pallet;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+fn assert_last_event<T: Config>(generic_event: crate::Event<T>) {
+	let re: <T as Config>::RuntimeEvent = generic_event.into();
+	frame_system::Pallet::<T>::assert_last_event(re.into());
+}
+
+#[benchmarks(where <T as Config>::RuntimeCall: From<frame_system::Call<T>>)]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn set_key() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(&caller);
+
+		let new_sudoer: T::AccountId = account("sudoer", 0, 0);
+		let new_sudoer_lookup = T::Lookup::unlookup(new_sudoer.clone());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), new_sudoer_lookup);
+
+		assert_last_event::<T>(Event::KeyChanged { old: Some(caller), new: new_sudoer });
+	}
+
+	#[benchmark]
+	fn sudo() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(&caller);
+
+		let call = frame_system::Call::remark { remark: vec![] }.into();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), Box::new(call));
+
+		assert_last_event::<T>(Event::Sudid { sudo_result: Ok(()) })
+	}
+
+	#[benchmark]
+	fn sudo_as() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(caller.clone());
+
+		let call = frame_system::Call::remark { remark: vec![] }.into();
+
+		let who: T::AccountId = account("as", 0, 0);
+		let who_lookup = T::Lookup::unlookup(who);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), who_lookup, Box::new(call));
+
+		assert_last_event::<T>(Event::SudoAsDone { sudo_result: Ok(()) })
+	}
+
+	#[benchmark]
+	fn remove_key() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(&caller);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert_last_event::<T>(Event::KeyRemoved {});
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_bench_ext(), crate::mock::Test);
+}

pallets/sudo/src/extension.rs

@@ -0,0 +1,82 @@
+use crate::{Config, Key};
+use codec::{Decode, Encode};
+use frame_support::{dispatch::DispatchInfo, ensure};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, SignedExtension},
+	transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,
+		UnknownTransaction, ValidTransaction,
+	},
+};
+use sp_std::{fmt, marker::PhantomData};
+
+#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckOnlySudoAccount<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> Default for CheckOnlySudoAccount<T> {
+	fn default() -> Self {
+		Self(Default::default())
+	}
+}
+
+impl<T: Config + Send + Sync> fmt::Debug for CheckOnlySudoAccount<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "CheckOnlySudoAccount")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> CheckOnlySudoAccount<T> {
+	/// Creates new `SignedExtension` to check sudo key.
+	pub fn new() -> Self {
+		Self::default()
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckOnlySudoAccount<T>
+where
+	<T as Config>::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+{
+	const IDENTIFIER: &'static str = "CheckOnlySudoAccount";
+	type AccountId = T::AccountId;
+	type Call = <T as Config>::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		_call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		let sudo_key: T::AccountId = Key::<T>::get().ok_or(UnknownTransaction::CannotLookup)?;
+		ensure!(*who == sudo_key, InvalidTransaction::BadSigner);
+
+		Ok(ValidTransaction {
+			priority: info.weight.ref_time() as TransactionPriority,
+			..Default::default()
+		})
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		self.validate(who, call, info, len).map(|_| ())
+	}
+}

pallets/sudo/src/lib.rs

@@ -0,0 +1,203 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_runtime::{traits::StaticLookup, DispatchResult};
+use sp_std::prelude::*;
+
+use frame_support::{dispatch::GetDispatchInfo, traits::UnfilteredDispatchable};
+
+mod extension;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod weights;
+pub use weights::WeightInfo;
+
+pub use extension::CheckOnlySudoAccount;
+pub use pallet::*;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::{DispatchResult, *};
+	use frame_support::pallet_prelude::*;
+	use frame_system::{pallet_prelude::*, RawOrigin};
+
+	pub mod config_preludes {
+		use super::*;
+		use frame_support::derive_impl;
+
+		pub struct TestDefaultConfig;
+
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
+		impl frame_system::DefaultConfig for TestDefaultConfig {}
+
+		#[frame_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			type WeightInfo = ();
+			#[inject_runtime_type]
+			type RuntimeEvent = ();
+			#[inject_runtime_type]
+			type RuntimeCall = ();
+		}
+	}
+	#[pallet::config(with_default)]
+	pub trait Config: frame_system::Config {
+		#[pallet::no_default_bounds]
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		#[pallet::no_default_bounds]
+		type RuntimeCall: Parameter
+			+ UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo;
+
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::sudo().saturating_add(dispatch_info.weight),
+				dispatch_info.class
+			)
+		})]
+		pub fn sudo(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			Self::ensure_sudo(origin)?;
+
+			let res = call.dispatch_bypass_filter(RawOrigin::Root.into());
+			Self::deposit_event(Event::Sudid { sudo_result: res.map(|_| ()).map_err(|e| e.error) });
+
+			Ok(Pays::No.into())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight((*weight, call.get_dispatch_info().class))]
+		pub fn sudo_unchecked_weight(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+			weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			Self::ensure_sudo(origin)?;
+			let _ = weight;
+
+			let res = call.dispatch_bypass_filter(RawOrigin::Root.into());
+			Self::deposit_event(Event::Sudid { sudo_result: res.map(|_| ()).map_err(|e| e.error) });
+
+			Ok(Pays::No.into())
+		}
+
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::set_key())]
+		pub fn set_key(
+			origin: OriginFor<T>,
+			new: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			Self::ensure_sudo(origin)?;
+
+			let new = T::Lookup::lookup(new)?;
+			Self::deposit_event(Event::KeyChanged { old: Key::<T>::get(), new: new.clone() });
+			Key::<T>::put(new);
+
+			Ok(Pays::No.into())
+		}
+
+		#[pallet::call_index(3)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::sudo_as().saturating_add(dispatch_info.weight),
+				dispatch_info.class,
+			)
+		})]
+		pub fn sudo_as(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			Self::ensure_sudo(origin)?;
+
+			let who = T::Lookup::lookup(who)?;
+			let res = call.dispatch_bypass_filter(RawOrigin::Signed(who).into());
+			Self::deposit_event(Event::SudoAsDone {
+				sudo_result: res.map(|_| ()).map_err(|e| e.error),
+			});
+
+			Ok(Pays::No.into())
+		}
+
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::remove_key())]
+		pub fn remove_key(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			Self::ensure_sudo(origin)?;
+
+			Self::deposit_event(Event::KeyRemoved {});
+			Key::<T>::kill();
+
+			Ok(Pays::No.into())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		Sudid {
+			sudo_result: DispatchResult,
+		},
+		KeyChanged {
+			old: Option<T::AccountId>,
+			new: T::AccountId,
+		},
+		KeyRemoved,
+		SudoAsDone { sudo_result: DispatchResult },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		RequireSudo,
+	}
+
+	#[pallet::storage]
+	pub(super) type Key<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub key: Option<T::AccountId>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Key::<T>::set(self.key.clone());
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		pub(crate) fn ensure_sudo(origin: OriginFor<T>) -> DispatchResult {
+			let sender = ensure_signed_or_root(origin)?;
+
+			if let Some(sender) = sender {
+				if Key::<T>::get().map_or(false, |k| k == sender) {
+					Ok(())
+				} else {
+					Err(Error::<T>::RequireSudo.into())
+				}
+			} else {
+				Ok(())
+			}
+		}
+	}
+}

pallets/sudo/src/mock.rs

@@ -0,0 +1,109 @@
+use super::*;
+use crate as sudo;
+use frame_support::derive_impl;
+use sp_io;
+use sp_runtime::BuildStorage;
+
+#[frame_support::pallet]
+pub mod logger {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(*weight)]
+		pub fn privileged_i32_log(
+			origin: OriginFor<T>,
+			i: i32,
+			weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			<I32Log<T>>::try_append(i).map_err(|_| "could not append")?;
+			Self::deposit_event(Event::AppendI32 { value: i, weight });
+			Ok(().into())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight(*weight)]
+		pub fn non_privileged_log(
+			origin: OriginFor<T>,
+			i: i32,
+			weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			<I32Log<T>>::try_append(i).map_err(|_| "could not append")?;
+			<AccountLog<T>>::try_append(sender.clone()).map_err(|_| "could not append")?;
+			Self::deposit_event(Event::AppendI32AndAccount { sender, value: i, weight });
+			Ok(().into())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		AppendI32 { value: i32, weight: Weight },
+		AppendI32AndAccount { sender: T::AccountId, value: i32, weight: Weight },
+	}
+
+	#[pallet::storage]
+	#[pallet::getter(fn account_log)]
+	pub(super) type AccountLog<T: Config> =
+		StorageValue<_, BoundedVec<T::AccountId, ConstU32<1_000>>, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn i32_log)]
+	pub(super) type I32Log<T> = StorageValue<_, BoundedVec<i32, ConstU32<1_000>>, ValueQuery>;
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Sudo: sudo,
+		Logger: logger,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+}
+
+impl logger::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type WeightInfo = ();
+}
+
+pub type SudoCall = sudo::Call<Test>;
+pub type LoggerCall = logger::Call<Test>;
+
+pub fn new_test_ext(root_key: u64) -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	sudo::GenesisConfig::<Test> { key: Some(root_key) }
+		.assimilate_storage(&mut t)
+		.unwrap();
+	let mut ext: sp_io::TestExternalities = t.into();
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn new_bench_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}

pallets/sudo/src/tests.rs

@@ -0,0 +1,188 @@
+use super::*;
+use frame_support::{assert_noop, assert_ok, weights::Weight};
+use mock::{
+	new_test_ext, Logger, LoggerCall, RuntimeCall, RuntimeEvent as TestEvent, RuntimeOrigin, Sudo,
+	SudoCall, System, Test,
+};
+
+#[test]
+fn test_setup_works() {
+	new_test_ext(1).execute_with(|| {
+		assert_eq!(Key::<Test>::get(), Some(1u64));
+		assert!(Logger::i32_log().is_empty());
+		assert!(Logger::account_log().is_empty());
+	});
+}
+
+#[docify::export]
+#[test]
+fn sudo_basics() {
+	new_test_ext(1).execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_ok!(Sudo::sudo(RuntimeOrigin::signed(1), call));
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_noop!(Sudo::sudo(RuntimeOrigin::signed(2), call), Error::<Test>::RequireSudo);
+	});
+}
+
+#[test]
+fn sudo_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo(RuntimeOrigin::signed(1), call));
+		System::assert_has_event(TestEvent::Sudo(Event::Sudid { sudo_result: Ok(()) }));
+	})
+}
+
+#[test]
+fn sudo_unchecked_weight_basics() {
+	new_test_ext(1).execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_ok!(Sudo::sudo_unchecked_weight(
+			RuntimeOrigin::signed(1),
+			call,
+			Weight::from_parts(1_000, 0)
+		));
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_noop!(
+			Sudo::sudo_unchecked_weight(
+				RuntimeOrigin::signed(2),
+				call,
+				Weight::from_parts(1_000, 0)
+			),
+			Error::<Test>::RequireSudo,
+		);
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		let sudo_unchecked_weight_call =
+			SudoCall::sudo_unchecked_weight { call, weight: Weight::from_parts(1_000, 0) };
+		let info = sudo_unchecked_weight_call.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(1_000, 0));
+	});
+}
+
+#[test]
+fn sudo_unchecked_weight_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo_unchecked_weight(
+			RuntimeOrigin::signed(1),
+			call,
+			Weight::from_parts(1_000, 0)
+		));
+		System::assert_has_event(TestEvent::Sudo(Event::Sudid { sudo_result: Ok(()) }));
+	})
+}
+
+#[docify::export]
+#[test]
+fn set_key_basics() {
+	new_test_ext(1).execute_with(|| {
+		assert_ok!(Sudo::set_key(RuntimeOrigin::signed(1), 2));
+		assert_eq!(Key::<Test>::get(), Some(2u64));
+	});
+
+	new_test_ext(1).execute_with(|| {
+		assert_noop!(Sudo::set_key(RuntimeOrigin::signed(2), 3), Error::<Test>::RequireSudo);
+	});
+}
+
+#[test]
+fn set_key_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		assert_ok!(Sudo::set_key(RuntimeOrigin::signed(1), 2));
+		System::assert_has_event(TestEvent::Sudo(Event::KeyChanged { old: Some(1), new: 2 }));
+		assert_ok!(Sudo::set_key(RuntimeOrigin::signed(2), 4));
+		System::assert_has_event(TestEvent::Sudo(Event::KeyChanged { old: Some(2), new: 4 }));
+	});
+}
+
+#[test]
+fn remove_key_works() {
+	new_test_ext(1).execute_with(|| {
+		assert_ok!(Sudo::remove_key(RuntimeOrigin::signed(1)));
+		assert!(Key::<Test>::get().is_none());
+		System::assert_has_event(TestEvent::Sudo(Event::KeyRemoved {}));
+
+		assert_noop!(Sudo::remove_key(RuntimeOrigin::signed(1)), Error::<Test>::RequireSudo);
+		assert_noop!(Sudo::set_key(RuntimeOrigin::signed(1), 1), Error::<Test>::RequireSudo);
+	});
+}
+
+#[test]
+fn using_root_origin_works() {
+	new_test_ext(1).execute_with(|| {
+		assert_ok!(Sudo::remove_key(RuntimeOrigin::root()));
+		assert!(Key::<Test>::get().is_none());
+		System::assert_has_event(TestEvent::Sudo(Event::KeyRemoved {}));
+
+		assert_ok!(Sudo::set_key(RuntimeOrigin::root(), 1));
+		assert_eq!(Some(1), Key::<Test>::get());
+	});
+}
+
+#[test]
+fn sudo_as_basics() {
+	new_test_ext(1).execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
+		assert!(Logger::i32_log().is_empty());
+		assert!(Logger::account_log().is_empty());
+
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_noop!(Sudo::sudo_as(RuntimeOrigin::signed(3), 2, call), Error::<Test>::RequireSudo);
+
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+		assert_eq!(Logger::account_log(), vec![2]);
+	});
+}
+
+#[docify::export]
+#[test]
+fn sudo_as_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
+		System::assert_has_event(TestEvent::Sudo(Event::SudoAsDone { sudo_result: Ok(()) }));
+	});
+}

pallets/sudo/src/weights.rs

@@ -0,0 +1,151 @@
+// This file is part of Substrate.
+
+// Copyright (C) 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.
+
+//! Autogenerated weights for `pallet_sudo`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2024-04-09, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-anb7yjbi-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
+
+// Executed Command:
+// ./target/production/substrate-node
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_sudo
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./substrate/frame/sudo/src/weights.rs
+// --header=./substrate/HEADER-APACHE2
+// --template=./substrate/.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_sudo`.
+pub trait WeightInfo {
+	fn set_key() -> Weight;
+	fn sudo() -> Weight;
+	fn sudo_as() -> Weight;
+	fn remove_key() -> Weight;
+}
+
+/// Weights for `pallet_sudo` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `Sudo::Key` (r:1 w:1)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn set_key() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 9_486_000 picoseconds.
+		Weight::from_parts(9_663_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Sudo::Key` (r:1 w:0)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn sudo() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 10_501_000 picoseconds.
+		Weight::from_parts(10_729_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Sudo::Key` (r:1 w:0)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn sudo_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 10_742_000 picoseconds.
+		Weight::from_parts(11_003_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Sudo::Key` (r:1 w:1)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn remove_key() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 8_837_000 picoseconds.
+		Weight::from_parts(9_127_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Sudo::Key` (r:1 w:1)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn set_key() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 9_486_000 picoseconds.
+		Weight::from_parts(9_663_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Sudo::Key` (r:1 w:0)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn sudo() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 10_501_000 picoseconds.
+		Weight::from_parts(10_729_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Sudo::Key` (r:1 w:0)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn sudo_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 10_742_000 picoseconds.
+		Weight::from_parts(11_003_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Sudo::Key` (r:1 w:1)
+	/// Proof: `Sudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
+	fn remove_key() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 8_837_000 picoseconds.
+		Weight::from_parts(9_127_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}