git.delta.rocks / unique-network / refs/commits / 9a601ff5844d

--- /dev/null
+++ b/pallets/maintenance/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "pallet-maintenance"
+version = "0.1.0"
+authors = ["Unique Network <support@uniquenetwork.io>"]
+edition = "2021"
+license = "GPLv3"
+homepage = "https://unique.network"
+repository = "https://github.com/UniqueNetwork/unique-chain"
+description = "Unique Maintenance pallet"
+readme = "README.md"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+frame-support = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" }
+frame-system = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" }
+frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" }
+sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.30" }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"frame-support/std",
+	"frame-system/std",
+	"frame-benchmarking/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+]
+try-runtime = ["frame-support/try-runtime"]

--- /dev/null
+++ b/pallets/maintenance/src/benchmarking.rs
@@ -0,0 +1,37 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use super::*;
+use crate::{Pallet as Maintenance, Config};
+
+use frame_benchmarking::benchmarks;
+use frame_system::RawOrigin;
+use frame_support::ensure;
+
+benchmarks! {
+	enable {
+	}: _(RawOrigin::Root)
+	verify {
+		ensure!(<Enabled<T>>::get(), "didn't enable the MM");
+	}
+
+	disable {
+		Maintenance::<T>::enable(RawOrigin::Root.into())?;
+	}: _(RawOrigin::Root)
+	verify {
+		ensure!(!<Enabled<T>>::get(), "didn't disable the MM");
+	}
+}

--- /dev/null
+++ b/pallets/maintenance/src/lib.rs
@@ -0,0 +1,80 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+
+pub mod weights;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use crate::weights::WeightInfo;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		MaintenanceEnabled,
+		MaintenanceDisabled,
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	#[pallet::getter(fn is_enabled)]
+	pub type Enabled<T> = StorageValue<_, bool, ValueQuery>;
+
+	#[pallet::error]
+	pub enum Error<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(<T as Config>::WeightInfo::enable())]
+		pub fn enable(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+
+			<Enabled<T>>::set(true);
+
+			Self::deposit_event(Event::MaintenanceEnabled);
+
+			Ok(())
+		}
+
+		#[pallet::weight(<T as Config>::WeightInfo::disable())]
+		pub fn disable(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+
+			<Enabled<T>>::set(false);
+
+			Self::deposit_event(Event::MaintenanceDisabled);
+
+			Ok(())
+		}
+	}
+}

--- /dev/null
+++ b/pallets/maintenance/src/weights.rs
@@ -0,0 +1,67 @@
+// Template adopted from https://github.com/paritytech/substrate/blob/master/.maintain/frame-weight-template.hbs
+
+//! Autogenerated weights for pallet_maintenance
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-11-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+
+// Executed Command:
+// target/release/unique-collator
+// benchmark
+// pallet
+// --pallet
+// pallet-maintenance
+// --wasm-execution
+// compiled
+// --extrinsic
+// *
+// --template
+// .maintain/frame-weight-template.hbs
+// --steps=50
+// --repeat=80
+// --heap-pages=4096
+// --output=./pallets/maintenance/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(clippy::unnecessary_cast)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_maintenance.
+pub trait WeightInfo {
+	fn enable() -> Weight;
+	fn disable() -> Weight;
+}
+
+/// Weights for pallet_maintenance using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: Maintenance Enabled (r:0 w:1)
+	fn enable() -> Weight {
+		Weight::from_ref_time(7_367_000)
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	// Storage: Maintenance Enabled (r:0 w:1)
+	fn disable() -> Weight {
+		Weight::from_ref_time(7_273_000)
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: Maintenance Enabled (r:0 w:1)
+	fn enable() -> Weight {
+		Weight::from_ref_time(7_367_000)
+			.saturating_add(RocksDbWeight::get().writes(1))
+	}
+	// Storage: Maintenance Enabled (r:0 w:1)
+	fn disable() -> Weight {
+		Weight::from_ref_time(7_273_000)
+			.saturating_add(RocksDbWeight::get().writes(1))
+	}
+}

--- /dev/null
+++ b/runtime/common/maintenance.rs
@@ -0,0 +1,119 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use scale_info::TypeInfo;
+use codec::{Encode, Decode};
+use up_common::types::AccountId;
+use crate::{RuntimeCall, Maintenance};
+
+use sp_runtime::{
+	traits::{DispatchInfoOf, SignedExtension},
+    transaction_validity::{
+		TransactionValidity, ValidTransaction, InvalidTransaction, TransactionValidityError,
+	},
+};
+
+#[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]
+pub struct CheckMaintenance;
+
+impl SignedExtension for CheckMaintenance {
+	type AccountId = AccountId;
+	type Call = RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+
+	const IDENTIFIER: &'static str = "CheckMaintenance";
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(())
+	}
+
+	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(|_| ())
+	}
+
+	fn validate(
+		&self,
+		_who: &Self::AccountId,
+		call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		if Maintenance::is_enabled() {
+			match call {
+				RuntimeCall::EvmMigration(_)
+				| RuntimeCall::EVM(_)
+				| RuntimeCall::Ethereum(_)
+				| RuntimeCall::Inflation(_)
+				| RuntimeCall::Maintenance(_)
+				| RuntimeCall::Structure(_)
+				| RuntimeCall::Unique(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
+
+                #[cfg(feature = "scheduler")]
+                RuntimeCall::Scheduler(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
+
+				#[cfg(feature = "rmrk")]
+				RuntimeCall::RmrkCore(_) | RuntimeCall::RmrkEquip(_) => {
+					Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+				}
+
+                #[cfg(feature = "app-promotion")]
+                RuntimeCall::AppPromotion(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
+
+                #[cfg(feature = "foreign-assets")]
+                RuntimeCall::ForeignAssets(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
+
+                #[cfg(feature = "pallet-test-utils")]
+                RuntimeCall::TestUtils(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
+
+				_ => Ok(ValidTransaction::default()),
+			}
+		} else {
+			Ok(ValidTransaction::default())
+		}
+	}
+
+	fn pre_dispatch_unsigned(
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<(), TransactionValidityError> {
+		Self::validate_unsigned(call, info, len).map(|_| ())
+	}
+
+	fn validate_unsigned(
+		call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		if Maintenance::is_enabled() {
+			match call {
+				RuntimeCall::EVM(_) | RuntimeCall::Ethereum(_) | RuntimeCall::EvmMigration(_) => {
+					Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+				}
+				_ => Ok(ValidTransaction::default()),
+			}
+		} else {
+			Ok(ValidTransaction::default())
+		}
+	}
+}