Glutton pallet

Cargo.toml

@@ -119,6 +119,7 @@ members = [
 	"frame/node-authorization",
 	"frame/offences",
 	"frame/offences/benchmarking",
+	"frame/pov-limit",
 	"frame/preimage",
 	"frame/proxy",
 	"frame/nomination-pools",

frame/pov-limit/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "pallet-pov-limit"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for nick management"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[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-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "7.0.0", path = "../../primitives/core" }
+sp-io = { version = "7.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[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",
+]
+try-runtime = ["frame-support/try-runtime"]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]

frame/pov-limit/README.md

@@ -0,0 +1,6 @@
+# Pov Limit Pallet
+
+Pallet that controls compute usage and PoV size usage. The parameters for
+the usage are configured by root and are stored as `StorageValue`s.
+
+NOTE: This is only meant to be used for testing.

frame/pov-limit/src/benchmarking.rs

@@ -0,0 +1,35 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+//! Pov-limit pallet benchmarking.
+
+#[cfg(feature = "runtime-benchmarks")]
+use super::*;
+
+use frame_benchmarking::benchmarks;
+
+use crate::Pallet as PovLimit;
+
+benchmarks! {
+	hash_value {
+
+	}: {
+		PovLimit::<T>::hash_value(1u64);
+	}
+
+	impl_benchmark_test_suite!(PovLimit, crate::mock::new_test_ext(), crate::mock::Test);
+}

frame/pov-limit/src/lib.rs

@@ -0,0 +1,150 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+//! # Pov Limit Pallet
+//!
+//! Pallet that controls compute usage and PoV size usage. The parameters for
+//! the usage are configured by root and are stored as `StorageValue`s.
+//!
+//! NOTE: This is only meant to be used for testing.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use frame_support::{pallet_prelude::*, traits::GenesisBuild};
+use sp_core::{Blake2Hasher, Hasher};
+use sp_runtime::Perbill;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The number of times the hash function should be called to fill up
+		/// all the block's weight.
+		#[pallet::constant]
+		type HashesForFull: Get<u32>;
+
+		/// Weight information for this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub(crate) type Compute<T: Config> = StorageValue<_, Perbill, ValueQuery>;
+
+	#[pallet::storage]
+	pub(crate) type Storage<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig {
+		pub compute: Perbill,
+		pub storage: u32,
+	}
+
+	#[cfg(feature = "std")]
+	impl Default for GenesisConfig {
+		fn default() -> Self {
+			Self { compute: Default::default(), storage: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> GenesisBuild<T> for GenesisConfig {
+		fn build(&self) {
+			Compute::<T>::set(self.compute);
+			Storage::<T>::set(self.storage);
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_idle(_: BlockNumberFor<T>, remaining_weight: Weight) -> Weight {
+			let mut weight = T::DbWeight::get().reads(1);
+
+			for i in 0..(Compute::<T>::get().mul_ceil(T::HashesForFull::get())) {
+				weight.saturating_add(T::WeightInfo::hash_value());
+				if remaining_weight.any_lt(weight) {
+					weight = remaining_weight;
+					break
+				}
+				Self::hash_value(i.into());
+			}
+
+			for i in 0..Storage::<T>::get() {
+				weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
+				if remaining_weight.any_lt(weight) {
+					weight = remaining_weight;
+					break
+				}
+
+				storage::unhashed::put(&i.to_le_bytes(), &i.to_le_bytes());
+				let _: Option<Vec<u8>> = storage::unhashed::get(&i.to_le_bytes());
+			}
+
+			weight
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Set the `Compute` storage value that determines how much of the
+		/// block's weight to use during `on_initialize`.
+		///
+		/// Only callable by Root.
+		#[pallet::weight(T::DbWeight::get().writes(1))]
+		pub fn set_compute(origin: OriginFor<T>, compute: Perbill) -> DispatchResult {
+			let _ = ensure_root(origin)?;
+			Compute::<T>::set(compute);
+
+			Ok(())
+		}
+
+		/// Set the `Storage` storage value that determines the PoV size usage
+		/// for each block.
+		///
+		/// Only callable by Root.
+		#[pallet::weight(T::DbWeight::get().writes(1))]
+		pub fn set_storage(origin: OriginFor<T>, storage: u32) -> DispatchResult {
+			let _ = ensure_root(origin)?;
+			Storage::<T>::set(storage);
+
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		pub fn hash_value(value: u64) {
+			Blake2Hasher::hash(&value.to_le_bytes());
+		}
+	}
+}

frame/pov-limit/src/mock.rs

@@ -0,0 +1,84 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+use super::*;
+use crate as pallet_pov_limit;
+
+use frame_support::traits::{ConstU32, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	testing::Header,
+	traits::{BlakeTwo256, IdentityLookup},
+};
+
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test where
+		Block = Block,
+		NodeBlock = Block,
+		UncheckedExtrinsic = UncheckedExtrinsic,
+	{
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		PovLimit: pallet_pov_limit::{Pallet},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Index = u64;
+	type BlockNumber = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	type Hashing = BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Header = Header;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl Config for Test {
+	type HashesForFull = ConstU32<1000000>;
+	type WeightInfo = crate::weights::SubstrateWeight<Test>;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::default().build_storage::<Test>().unwrap();
+
+	let genesis = pallet::GenesisConfig { compute: Perbill::from_percent(50), storage: 10000 };
+
+	GenesisBuild::<Test>::assimilate_storage(&genesis, &mut t).unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}