Runtime dependent weights (#5064)

* Copy Substrate weights into each runtime

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Define weights per runtime

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Do the same for test-runtime

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix CI

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Generate multiplier tests via macro

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix tests

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix CI

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix imports

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix test

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix imports

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Change rococo tests to use ExtrinsicBaseWeight

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fix imports

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Spellcheck on

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Spellcheck on

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Spellcheck

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Re-Export weight constants in the runtime

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Prepare for cumulus companion

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

* Fmt

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>

polkadot/Cargo.lock

@@ -7674,7 +7674,6 @@ dependencies = [
  "polkadot-parachain",
  "polkadot-primitives",
  "polkadot-rpc",
- "polkadot-runtime-common",
  "polkadot-runtime-parachains",
  "polkadot-service",
  "polkadot-test-runtime",

polkadot/node/test/service/Cargo.toml

@@ -18,7 +18,6 @@ polkadot-overseer = { path = "../../overseer" }
 polkadot-primitives = { path = "../../../primitives" }
 polkadot-parachain = { path = "../../../parachain" }
 polkadot-rpc = { path = "../../../rpc" }
-polkadot-runtime-common = { path = "../../../runtime/common" }
 polkadot-service = { path = "../../service" }
 polkadot-node-subsystem = { path = "../../subsystem" }
 polkadot-node-primitives = { path = "../../primitives" }

polkadot/node/test/service/src/lib.rs

@@ -26,14 +26,13 @@ use polkadot_node_primitives::{CollationGenerationConfig, CollatorFn};
 use polkadot_node_subsystem::messages::{CollationGenerationMessage, CollatorProtocolMessage};
 use polkadot_overseer::Handle;
 use polkadot_primitives::v2::{Balance, CollatorPair, HeadData, Id as ParaId, ValidationCode};
-use polkadot_runtime_common::BlockHashCount;
 use polkadot_runtime_parachains::paras::ParaGenesisArgs;
 use polkadot_service::{
 	ClientHandle, Error, ExecuteWithClient, FullClient, IsCollator, NewFull, PrometheusConfig,
 };
 use polkadot_test_runtime::{
-	ParasSudoWrapperCall, Runtime, SignedExtra, SignedPayload, SudoCall, UncheckedExtrinsic,
+	BlockHashCount, ParasSudoWrapperCall, Runtime, SignedExtra, SignedPayload, SudoCall,
-	VERSION,
+	UncheckedExtrinsic, VERSION,
 };
 use sc_chain_spec::ChainSpec;
 use sc_client_api::execution_extensions::ExecutionStrategies;

polkadot/runtime/common/src/elections.rs

@@ -16,33 +16,35 @@
 
 //! Code for elections.
 
-use super::{BlockExecutionWeight, BlockLength, BlockWeights};
 use frame_election_provider_support::SortedListProvider;
-use frame_support::{
+use sp_std::{boxed::Box, marker::PhantomData};
-	parameter_types,
-	weights::{DispatchClass, Weight},
-};
-use sp_runtime::Perbill;
-use sp_std::{boxed::Box, convert::From, marker::PhantomData};
 
-parameter_types! {
+/// Implements the weight types for the elections module and a specific
-	/// A limit for off-chain phragmen unsigned solution submission.
+/// runtime.
-	///
+/// This macro should not be called directly; use [`impl_runtime_weights`] instead.
-	/// We want to keep it as high as possible, but can't risk having it reject,
+#[macro_export]
-	/// so we always subtract the base block execution weight.
+macro_rules! impl_elections_weights {
-	pub OffchainSolutionWeightLimit: Weight = BlockWeights::get()
+	($runtime:ident) => {
-		.get(DispatchClass::Normal)
+		parameter_types! {
-		.max_extrinsic
+			/// A limit for off-chain phragmen unsigned solution submission.
-		.expect("Normal extrinsics have weight limit configured by default; qed")
+			///
-		.saturating_sub(BlockExecutionWeight::get());
+			/// We want to keep it as high as possible, but can't risk having it reject,
+			/// so we always subtract the base block execution weight.
+			pub OffchainSolutionWeightLimit: Weight = BlockWeights::get()
+				.get(DispatchClass::Normal)
+				.max_extrinsic
+				.expect("Normal extrinsics have weight limit configured by default; qed")
+				.saturating_sub($runtime::weights::BlockExecutionWeight::get());
 
-	/// A limit for off-chain phragmen unsigned solution length.
+			/// A limit for off-chain phragmen unsigned solution length.
-	///
+			///
-	/// We allow up to 90% of the block's size to be consumed by the solution.
+			/// We allow up to 90% of the block's size to be consumed by the solution.
-	pub OffchainSolutionLengthLimit: u32 = Perbill::from_rational(90_u32, 100) *
+			pub OffchainSolutionLengthLimit: u32 = Perbill::from_rational(90_u32, 100) *
-		*BlockLength::get()
+				*BlockLength::get()
-		.max
+				.max
-		.get(DispatchClass::Normal);
+				.get(DispatchClass::Normal);
+		}
+	};
 }
 
 /// The numbers configured here could always be more than the the maximum limits of staking pallet

polkadot/runtime/common/src/lib.rs

@@ -37,21 +37,14 @@ mod integration_tests;
 #[cfg(test)]
 mod mock;
 
-pub use frame_support::weights::constants::{
-	BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight,
-};
 use frame_support::{
-	parameter_types,
 	traits::{ConstU32, Currency, OneSessionHandler},
-	weights::{constants::WEIGHT_PER_SECOND, DispatchClass, Weight},
+	weights::{constants::WEIGHT_PER_SECOND, Weight},
 };
-use frame_system::limits;
+use primitives::v2::{AssignmentId, ValidatorId};
-use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
+use sp_runtime::Perbill;
-use primitives::v2::{AssignmentId, BlockNumber, ValidatorId};
-use sp_runtime::{FixedPointNumber, Perbill, Perquintill};
 use static_assertions::const_assert;
 
-pub use elections::{OffchainSolutionLengthLimit, OffchainSolutionWeightLimit};
 pub use pallet_balances::Call as BalancesCall;
 #[cfg(feature = "std")]
 pub use pallet_staking::StakerStatus;
@@ -71,53 +64,81 @@ pub type NegativeImbalance<T> = <pallet_balances::Pallet<T> as Currency<
 pub const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(1);
 /// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used
 /// by  Operational  extrinsics.
-const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+pub const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
 /// We allow for 2 seconds of compute with a 6 second average block time.
 pub const MAXIMUM_BLOCK_WEIGHT: Weight = 2 * WEIGHT_PER_SECOND;
 
 const_assert!(NORMAL_DISPATCH_RATIO.deconstruct() >= AVERAGE_ON_INITIALIZE_RATIO.deconstruct());
 
-// Common constants used in all runtimes.
+/// Implements the weight types for a runtime.
-parameter_types! {
+/// It expects the passed runtime constants to contain a `weights` module.
-	pub const BlockHashCount: BlockNumber = 2400;
+/// The generated weight types were formerly part of the common
-	/// The portion of the `NORMAL_DISPATCH_RATIO` that we adjust the fees with. Blocks filled less
+/// runtime but are now runtime dependant.
-	/// than this will decrease the weight and more will increase.
+#[macro_export]
-	pub const TargetBlockFullness: Perquintill = Perquintill::from_percent(25);
+macro_rules! impl_runtime_weights {
-	/// The adjustment variable of the runtime. Higher values will cause `TargetBlockFullness` to
+	($runtime:ident) => {
-	/// change the fees more rapidly.
+		use frame_support::weights::{DispatchClass, Weight};
-	pub AdjustmentVariable: Multiplier = Multiplier::saturating_from_rational(3, 100_000);
+		use frame_system::limits;
-	/// Minimum amount of the multiplier. This value cannot be too low. A test case should ensure
+		use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
-	/// that combined with `AdjustmentVariable`, we can recover from the minimum.
+		pub use runtime_common::{
-	/// See `multiplier_can_grow_from_zero`.
+			impl_elections_weights, impl_multiplier_tests, AVERAGE_ON_INITIALIZE_RATIO,
-	pub MinimumMultiplier: Multiplier = Multiplier::saturating_from_rational(1, 1_000_000u128);
+			MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO,
-	/// Maximum length of block. Up to 5MB.
+		};
-	pub BlockLength: limits::BlockLength =
+		use sp_runtime::{FixedPointNumber, Perquintill};
-		limits::BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
-	/// Block weights base values and limits.
-	pub BlockWeights: limits::BlockWeights = limits::BlockWeights::builder()
-		.base_block(BlockExecutionWeight::get())
-		.for_class(DispatchClass::all(), |weights| {
-			weights.base_extrinsic = ExtrinsicBaseWeight::get();
-		})
-		.for_class(DispatchClass::Normal, |weights| {
-			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
-		})
-		.for_class(DispatchClass::Operational, |weights| {
-			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
-			// Operational transactions have an extra reserved space, so that they
-			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
-			weights.reserved = Some(
-				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT,
-			);
-		})
-		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
-		.build_or_panic();
-}
 
-/// Parameterized slow adjusting fee updated based on
+		// Implement the weight types of the elections module.
-/// https://research.web3.foundation/en/latest/polkadot/overview/2-token-economics.html#-2.-slow-adjusting-mechanism
+		impl_elections_weights!($runtime);
-pub type SlowAdjustingFeeUpdate<R> =
+		// Implement tests for the weight multiplier.
-	TargetedFeeAdjustment<R, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier>;
+		impl_multiplier_tests!();
+
+		// Expose the weight from the runtime constants module.
+		pub use $runtime::weights::{
+			BlockExecutionWeight, ExtrinsicBaseWeight, ParityDbWeight, RocksDbWeight,
+		};
+
+		// Common constants used in all runtimes.
+		parameter_types! {
+			pub const BlockHashCount: BlockNumber = 2400;
+			/// The portion of the `NORMAL_DISPATCH_RATIO` that we adjust the fees with. Blocks filled less
+			/// than this will decrease the weight and more will increase.
+			pub const TargetBlockFullness: Perquintill = Perquintill::from_percent(25);
+			/// The adjustment variable of the runtime. Higher values will cause `TargetBlockFullness` to
+			/// change the fees more rapidly.
+			pub AdjustmentVariable: Multiplier = Multiplier::saturating_from_rational(3, 100_000);
+			/// Minimum amount of the multiplier. This value cannot be too low. A test case should ensure
+			/// that combined with `AdjustmentVariable`, we can recover from the minimum.
+			/// See `multiplier_can_grow_from_zero`.
+			pub MinimumMultiplier: Multiplier = Multiplier::saturating_from_rational(1, 1_000_000u128);
+			/// Maximum length of block. Up to 5MB.
+			pub BlockLength: limits::BlockLength =
+			limits::BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
+			/// Block weights base values and limits.
+			pub BlockWeights: limits::BlockWeights = limits::BlockWeights::builder()
+				.base_block($runtime::weights::BlockExecutionWeight::get())
+				.for_class(DispatchClass::all(), |weights| {
+					weights.base_extrinsic = $runtime::weights::ExtrinsicBaseWeight::get();
+				})
+				.for_class(DispatchClass::Normal, |weights| {
+					weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
+				})
+				.for_class(DispatchClass::Operational, |weights| {
+					weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
+					// Operational transactions have an extra reserved space, so that they
+					// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
+					weights.reserved = Some(
+						MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT,
+					);
+				})
+				.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
+				.build_or_panic();
+		}
+
+		/// Parameterized slow adjusting fee updated based on
+		/// https://research.web3.foundation/en/latest/polkadot/overview/2-token-economics.html#-2.-slow-adjusting-mechanism
+		pub type SlowAdjustingFeeUpdate<R> =
+			TargetedFeeAdjustment<R, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier>;
+	};
+}
 
 /// The type used for currency conversion.
 ///
@@ -219,112 +240,119 @@ macro_rules! prod_or_fast {
 	};
 }
 
-#[cfg(test)]
+/// Generates tests that check that the different weight multiplier work together.
-mod multiplier_tests {
+/// Should not be called directly, use [`impl_runtime_weights`] instead.
-	use super::*;
+#[macro_export]
-	use frame_support::{parameter_types, weights::Weight};
+macro_rules! impl_multiplier_tests {
-	use sp_core::H256;
+	() => {
-	use sp_runtime::{
+	#[cfg(test)]
-		testing::Header,
+	mod multiplier_tests {
-		traits::{BlakeTwo256, Convert, IdentityLookup, One},
+		use super::*;
-		Perbill,
+		use frame_support::{parameter_types, weights::Weight};
-	};
+		use sp_core::H256;
+		use sp_runtime::{
+			testing::Header,
+			traits::{BlakeTwo256, One, Convert, IdentityLookup},
+			Perbill,
+		};
 
-	type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Runtime>;
+		type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Runtime>;
-	type Block = frame_system::mocking::MockBlock<Runtime>;
+		type Block = frame_system::mocking::MockBlock<Runtime>;
 
-	frame_support::construct_runtime!(
+		frame_support::construct_runtime!(
-		pub enum Runtime where
+			pub enum Runtime where
-			Block = Block,
+				Block = Block,
-			NodeBlock = Block,
+				NodeBlock = Block,
-			UncheckedExtrinsic = UncheckedExtrinsic,
+				UncheckedExtrinsic = UncheckedExtrinsic,
+			{
+				System: frame_system::{Pallet, Call, Config, Storage, Event<T>}
+			}
+		);
+
+		parameter_types! {
+			pub const BlockHashCount: u64 = 250;
+			pub const AvailableBlockRatio: Perbill = Perbill::one();
+			pub BlockLength: frame_system::limits::BlockLength =
+				frame_system::limits::BlockLength::max(2 * 1024);
+			pub BlockWeights: frame_system::limits::BlockWeights =
+				frame_system::limits::BlockWeights::simple_max(1024);
+		}
+
+		impl frame_system::Config for Runtime {
+			type BaseCallFilter = frame_support::traits::Everything;
+			type BlockWeights = BlockWeights;
+			type BlockLength = ();
+			type DbWeight = ();
+			type Origin = Origin;
+			type Index = u64;
+			type BlockNumber = u64;
+			type Call = Call;
+			type Hash = H256;
+			type Hashing = BlakeTwo256;
+			type AccountId = u64;
+			type Lookup = IdentityLookup<Self::AccountId>;
+			type Header = Header;
+			type Event = Event;
+			type BlockHashCount = BlockHashCount;
+			type Version = ();
+			type PalletInfo = PalletInfo;
+			type AccountData = ();
+			type OnNewAccount = ();
+			type OnKilledAccount = ();
+			type SystemWeightInfo = ();
+			type SS58Prefix = ();
+			type OnSetCode = ();
+			type MaxConsumers = frame_support::traits::ConstU32<16>;
+		}
+
+		fn run_with_system_weight<F>(w: Weight, mut assertions: F)
+		where
+			F: FnMut() -> (),
 		{
-			System: frame_system::{Pallet, Call, Config, Storage, Event<T>}
+			let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::default()
-		}
+				.build_storage::<Runtime>()
-	);
+				.unwrap()
-
+				.into();
-	parameter_types! {
+			t.execute_with(|| {
-		pub const BlockHashCount: u64 = 250;
+				System::set_block_consumed_resources(w, 0);
-		pub const AvailableBlockRatio: Perbill = Perbill::one();
+				assertions()
-		pub BlockLength: frame_system::limits::BlockLength =
-			frame_system::limits::BlockLength::max(2 * 1024);
-		pub BlockWeights: frame_system::limits::BlockWeights =
-			frame_system::limits::BlockWeights::simple_max(1024);
-	}
-
-	impl frame_system::Config for Runtime {
-		type BaseCallFilter = frame_support::traits::Everything;
-		type BlockWeights = BlockWeights;
-		type BlockLength = ();
-		type DbWeight = ();
-		type Origin = Origin;
-		type Index = u64;
-		type BlockNumber = u64;
-		type Call = Call;
-		type Hash = H256;
-		type Hashing = BlakeTwo256;
-		type AccountId = u64;
-		type Lookup = IdentityLookup<Self::AccountId>;
-		type Header = Header;
-		type Event = Event;
-		type BlockHashCount = BlockHashCount;
-		type Version = ();
-		type PalletInfo = PalletInfo;
-		type AccountData = ();
-		type OnNewAccount = ();
-		type OnKilledAccount = ();
-		type SystemWeightInfo = ();
-		type SS58Prefix = ();
-		type OnSetCode = ();
-		type MaxConsumers = frame_support::traits::ConstU32<16>;
-	}
-
-	fn run_with_system_weight<F>(w: Weight, mut assertions: F)
-	where
-		F: FnMut() -> (),
-	{
-		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::default()
-			.build_storage::<Runtime>()
-			.unwrap()
-			.into();
-		t.execute_with(|| {
-			System::set_block_consumed_resources(w, 0);
-			assertions()
-		});
-	}
-
-	#[test]
-	fn multiplier_can_grow_from_zero() {
-		let minimum_multiplier = MinimumMultiplier::get();
-		let target = TargetBlockFullness::get() *
-			BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap();
-		// if the min is too small, then this will not change, and we are doomed forever.
-		// the weight is 1/100th bigger than target.
-		run_with_system_weight(target * 101 / 100, || {
-			let next = SlowAdjustingFeeUpdate::<Runtime>::convert(minimum_multiplier);
-			assert!(next > minimum_multiplier, "{:?} !>= {:?}", next, minimum_multiplier);
-		})
-	}
-
-	#[test]
-	#[ignore]
-	fn multiplier_growth_simulator() {
-		// assume the multiplier is initially set to its minimum. We update it with values twice the
-		//target (target is 25%, thus 50%) and we see at which point it reaches 1.
-		let mut multiplier = MinimumMultiplier::get();
-		let block_weight = TargetBlockFullness::get() *
-			BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap() *
-			2;
-		let mut blocks = 0;
-		while multiplier <= Multiplier::one() {
-			run_with_system_weight(block_weight, || {
-				let next = SlowAdjustingFeeUpdate::<Runtime>::convert(multiplier);
-				// ensure that it is growing as well.
-				assert!(next > multiplier, "{:?} !>= {:?}", next, multiplier);
-				multiplier = next;
 			});
-			blocks += 1;
-			println!("block = {} multiplier {:?}", blocks, multiplier);
 		}
+
+		#[test]
+		fn multiplier_can_grow_from_zero() {
+			let minimum_multiplier = MinimumMultiplier::get();
+			let target = TargetBlockFullness::get() *
+				BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap();
+			// if the min is too small, then this will not change, and we are doomed forever.
+			// the weight is 1/100th bigger than target.
+			run_with_system_weight(target * 101 / 100, || {
+				let next = SlowAdjustingFeeUpdate::<Runtime>::convert(minimum_multiplier);
+				assert!(next > minimum_multiplier, "{:?} !>= {:?}", next, minimum_multiplier);
+			})
+		}
+
+		#[test]
+		#[ignore]
+		fn multiplier_growth_simulator() {
+			// assume the multiplier is initially set to its minimum. We update it with values twice the
+			//target (target is 25%, thus 50%) and we see at which point it reaches 1.
+			let mut multiplier = MinimumMultiplier::get();
+			let block_weight = TargetBlockFullness::get() *
+				BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap() *
+				2;
+			let mut blocks = 0;
+			while multiplier <= Multiplier::one() {
+				run_with_system_weight(block_weight, || {
+					let next = SlowAdjustingFeeUpdate::<Runtime>::convert(multiplier);
+					// ensure that it is growing as well.
+					assert!(next > multiplier, "{:?} !>= {:?}", next, multiplier);
+					multiplier = next;
+				});
+				blocks += 1;
+				println!("block = {} multiplier {:?}", blocks, multiplier);
+			}
+		}
+	}
 	}
 }

polkadot/runtime/kusama/constants/src/lib.rs

@@ -15,6 +15,9 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 #![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod weights;
+
 /// Money matters.
 pub mod currency {
 	use primitives::v2::Balance;
@@ -51,11 +54,11 @@ pub mod time {
 
 /// Fee-related.
 pub mod fee {
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
 	use primitives::v2::Balance;
-	use runtime_common::ExtrinsicBaseWeight;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
@@ -95,8 +98,9 @@ mod tests {
 		currency::{CENTS, MILLICENTS},
 		fee::WeightToFee,
 	};
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::WeightToFeePolynomial;
-	use runtime_common::{ExtrinsicBaseWeight, MAXIMUM_BLOCK_WEIGHT};
+	use runtime_common::MAXIMUM_BLOCK_WEIGHT;
 
 	#[test]
 	// This function tests that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight is correct

polkadot/runtime/kusama/constants/src/weights/block_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Importing a block with 0 Extrinsics.
+		pub const BlockExecutionWeight: Weight = 5_000_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::BlockExecutionWeight::get();
+
+			// At least 100 µs.
+			assert!(w >= 100 * constants::WEIGHT_PER_MICROS, "Weight should be at least 100 µs.");
+			// At most 50 ms.
+			assert!(w <= 50 * constants::WEIGHT_PER_MILLIS, "Weight should be at most 50 ms.");
+		}
+	}
+}

polkadot/runtime/kusama/constants/src/weights/extrinsic_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Executing a NO-OP `System::remarks` Extrinsic.
+		pub const ExtrinsicBaseWeight: Weight = 125_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::ExtrinsicBaseWeight::get();
+
+			// At least 10 µs.
+			assert!(w >= 10 * constants::WEIGHT_PER_MICROS, "Weight should be at least 10 µs.");
+			// At most 1 ms.
+			assert!(w <= constants::WEIGHT_PER_MILLIS, "Weight should be at most 1 ms.");
+		}
+	}
+}

polkadot/runtime/kusama/constants/src/weights/mod.rs

@@ -0,0 +1,28 @@
+// 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.
+
+//! Expose the auto generated weight files.
+
+pub mod block_weights;
+pub mod extrinsic_weights;
+pub mod paritydb_weights;
+pub mod rocksdb_weights;
+
+pub use block_weights::constants::BlockExecutionWeight;
+pub use extrinsic_weights::constants::ExtrinsicBaseWeight;
+pub use paritydb_weights::constants::ParityDbWeight;
+pub use rocksdb_weights::constants::RocksDbWeight;

polkadot/runtime/kusama/constants/src/weights/paritydb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/kusama/constants/src/weights/rocksdb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// By default, Substrate uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/kusama/src/lib.rs

@@ -29,9 +29,8 @@ use primitives::v2::{
 	SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
 };
 use runtime_common::{
-	auctions, claims, crowdloan, impls::DealWithFees, paras_registrar, prod_or_fast, slots,
+	auctions, claims, crowdloan, impl_runtime_weights, impls::DealWithFees, paras_registrar,
-	BlockHashCount, BlockLength, BlockWeights, CurrencyToVote, OffchainSolutionLengthLimit,
+	prod_or_fast, slots, CurrencyToVote,
-	OffchainSolutionWeightLimit, RocksDbWeight, SlowAdjustingFeeUpdate,
 };
 use sp_std::{cmp::Ordering, collections::btree_map::BTreeMap, prelude::*};
 
@@ -52,7 +51,6 @@ use frame_support::{
 		Contains, EnsureOneOf, InstanceFilter, KeyOwnerProofSystem, LockIdentifier,
 		OnRuntimeUpgrade, PrivilegeCmp,
 	},
-	weights::Weight,
 	PalletId, RuntimeDebug,
 };
 use frame_system::EnsureRoot;
@@ -61,7 +59,6 @@ use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
 use pallet_mmr_primitives as mmr;
 use pallet_session::historical as session_historical;
 use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
-use sp_arithmetic::Perquintill;
 use sp_core::OpaqueMetadata;
 use sp_runtime::{
 	create_runtime_str, generic, impl_opaque_keys,
@@ -101,6 +98,8 @@ pub mod xcm_config;
 #[cfg(test)]
 mod tests;
 
+impl_runtime_weights!(kusama_runtime_constants);
+
 // Make the WASM binary available.
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

polkadot/runtime/kusama/src/tests.rs

@@ -79,7 +79,7 @@ fn block_cost() {
 #[test]
 #[ignore]
 fn transfer_cost_min_multiplier() {
-	let min_multiplier = runtime_common::MinimumMultiplier::get();
+	let min_multiplier = MinimumMultiplier::get();
 	let call = pallet_balances::Call::<Runtime>::transfer_keep_alive {
 		dest: Charlie.to_account_id().into(),
 		value: Default::default(),

polkadot/runtime/polkadot/constants/src/lib.rs

@@ -16,6 +16,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+pub mod weights;
+
 pub use self::currency::DOLLARS;
 
 /// Money matters.
@@ -54,11 +56,11 @@ pub mod time {
 
 /// Fee-related.
 pub mod fee {
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
 	use primitives::v2::Balance;
-	use runtime_common::ExtrinsicBaseWeight;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
@@ -98,8 +100,9 @@ mod tests {
 		currency::{CENTS, DOLLARS, MILLICENTS},
 		fee::WeightToFee,
 	};
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::WeightToFeePolynomial;
-	use runtime_common::{ExtrinsicBaseWeight, MAXIMUM_BLOCK_WEIGHT};
+	use runtime_common::MAXIMUM_BLOCK_WEIGHT;
 
 	#[test]
 	// This function tests that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight is correct

polkadot/runtime/polkadot/constants/src/weights/block_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Importing a block with 0 Extrinsics.
+		pub const BlockExecutionWeight: Weight = 5_000_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::BlockExecutionWeight::get();
+
+			// At least 100 µs.
+			assert!(w >= 100 * constants::WEIGHT_PER_MICROS, "Weight should be at least 100 µs.");
+			// At most 50 ms.
+			assert!(w <= 50 * constants::WEIGHT_PER_MILLIS, "Weight should be at most 50 ms.");
+		}
+	}
+}

polkadot/runtime/polkadot/constants/src/weights/extrinsic_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Executing a NO-OP `System::remarks` Extrinsic.
+		pub const ExtrinsicBaseWeight: Weight = 125_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::ExtrinsicBaseWeight::get();
+
+			// At least 10 µs.
+			assert!(w >= 10 * constants::WEIGHT_PER_MICROS, "Weight should be at least 10 µs.");
+			// At most 1 ms.
+			assert!(w <= constants::WEIGHT_PER_MILLIS, "Weight should be at most 1 ms.");
+		}
+	}
+}

polkadot/runtime/polkadot/constants/src/weights/mod.rs

@@ -0,0 +1,28 @@
+// 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.
+
+//! Expose the auto generated weight files.
+
+pub mod block_weights;
+pub mod extrinsic_weights;
+pub mod paritydb_weights;
+pub mod rocksdb_weights;
+
+pub use block_weights::constants::BlockExecutionWeight;
+pub use extrinsic_weights::constants::ExtrinsicBaseWeight;
+pub use paritydb_weights::constants::ParityDbWeight;
+pub use rocksdb_weights::constants::RocksDbWeight;

polkadot/runtime/polkadot/constants/src/weights/paritydb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/polkadot/constants/src/weights/rocksdb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// By default, Substrate uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/polkadot/src/lib.rs

@@ -22,9 +22,8 @@
 
 use pallet_transaction_payment::CurrencyAdapter;
 use runtime_common::{
-	auctions, claims, crowdloan, impls::DealWithFees, paras_registrar, prod_or_fast, slots,
+	auctions, claims, crowdloan, impl_runtime_weights, impls::DealWithFees, paras_registrar,
-	BlockHashCount, BlockLength, BlockWeights, CurrencyToVote, OffchainSolutionLengthLimit,
+	prod_or_fast, slots, CurrencyToVote,
-	OffchainSolutionWeightLimit, RocksDbWeight, SlowAdjustingFeeUpdate,
 };
 
 use runtime_parachains::{
@@ -44,7 +43,6 @@ use frame_support::{
 		Contains, EnsureOneOf, InstanceFilter, KeyOwnerProofSystem, LockIdentifier,
 		OnRuntimeUpgrade, PrivilegeCmp,
 	},
-	weights::Weight,
 	PalletId, RuntimeDebug,
 };
 use frame_system::EnsureRoot;
@@ -97,6 +95,8 @@ mod bag_thresholds;
 
 pub mod xcm_config;
 
+impl_runtime_weights!(polkadot_runtime_constants);
+
 // Make the WASM binary available.
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
@@ -2153,7 +2153,7 @@ mod test_fees {
 	#[test]
 	#[ignore]
 	fn transfer_cost_min_multiplier() {
-		let min_multiplier = runtime_common::MinimumMultiplier::get();
+		let min_multiplier = MinimumMultiplier::get();
 		let call = pallet_balances::Call::<Runtime>::transfer_keep_alive {
 			dest: Charlie.to_account_id().into(),
 			value: Default::default(),

polkadot/runtime/rococo/constants/src/lib.rs

@@ -16,6 +16,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+pub mod weights;
+
 /// Money matters.
 pub mod currency {
 	use primitives::v2::Balance;
@@ -53,11 +55,11 @@ pub mod time {
 
 /// Fee-related.
 pub mod fee {
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
 	use primitives::v2::Balance;
-	use runtime_common::ExtrinsicBaseWeight;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
@@ -97,15 +99,16 @@ mod tests {
 		currency::{CENTS, DOLLARS, MILLICENTS},
 		fee::WeightToFee,
 	};
-	use frame_support::weights::{DispatchClass, WeightToFeePolynomial};
+	use crate::weights::ExtrinsicBaseWeight;
-	use runtime_common::BlockWeights;
+	use frame_support::weights::WeightToFeePolynomial;
+	use runtime_common::MAXIMUM_BLOCK_WEIGHT;
 
 	#[test]
-	// This function tests that the fee for `MaximumBlockWeight` of weight is correct
+	// This function tests that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight is correct
 	fn full_block_fee_is_correct() {
 		// A full block should cost 16 DOLLARS
-		println!("Base: {}", BlockWeights::get().get(DispatchClass::Normal).base_extrinsic);
+		println!("Base: {}", ExtrinsicBaseWeight::get());
-		let x = WeightToFee::calc(&BlockWeights::get().max_block);
+		let x = WeightToFee::calc(&MAXIMUM_BLOCK_WEIGHT);
 		let y = 16 * DOLLARS;
 		assert!(x.max(y) - x.min(y) < MILLICENTS);
 	}
@@ -114,9 +117,8 @@ mod tests {
 	// This function tests that the fee for `ExtrinsicBaseWeight` of weight is correct
 	fn extrinsic_base_fee_is_correct() {
 		// `ExtrinsicBaseWeight` should cost 1/10 of a CENT
-		let base_weight = BlockWeights::get().get(DispatchClass::Normal).base_extrinsic;
+		println!("Base: {}", ExtrinsicBaseWeight::get());
-		println!("Base: {}", base_weight);
+		let x = WeightToFee::calc(&ExtrinsicBaseWeight::get());
-		let x = WeightToFee::calc(&base_weight);
 		let y = CENTS / 10;
 		assert!(x.max(y) - x.min(y) < MILLICENTS);
 	}

polkadot/runtime/rococo/constants/src/weights/block_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Importing a block with 0 Extrinsics.
+		pub const BlockExecutionWeight: Weight = 5_000_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::BlockExecutionWeight::get();
+
+			// At least 100 µs.
+			assert!(w >= 100 * constants::WEIGHT_PER_MICROS, "Weight should be at least 100 µs.");
+			// At most 50 ms.
+			assert!(w <= 50 * constants::WEIGHT_PER_MILLIS, "Weight should be at most 50 ms.");
+		}
+	}
+}

polkadot/runtime/rococo/constants/src/weights/extrinsic_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Executing a NO-OP `System::remarks` Extrinsic.
+		pub const ExtrinsicBaseWeight: Weight = 125_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::ExtrinsicBaseWeight::get();
+
+			// At least 10 µs.
+			assert!(w >= 10 * constants::WEIGHT_PER_MICROS, "Weight should be at least 10 µs.");
+			// At most 1 ms.
+			assert!(w <= constants::WEIGHT_PER_MILLIS, "Weight should be at most 1 ms.");
+		}
+	}
+}

polkadot/runtime/rococo/constants/src/weights/mod.rs

@@ -0,0 +1,28 @@
+// 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.
+
+//! Expose the auto generated weight files.
+
+pub mod block_weights;
+pub mod extrinsic_weights;
+pub mod paritydb_weights;
+pub mod rocksdb_weights;
+
+pub use block_weights::constants::BlockExecutionWeight;
+pub use extrinsic_weights::constants::ExtrinsicBaseWeight;
+pub use paritydb_weights::constants::ParityDbWeight;
+pub use rocksdb_weights::constants::RocksDbWeight;

polkadot/runtime/rococo/constants/src/weights/paritydb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/rococo/constants/src/weights/rocksdb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// By default, Substrate uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/rococo/src/lib.rs

@@ -42,8 +42,8 @@ use primitives::v2::{
 	ValidatorIndex, ValidatorSignature,
 };
 use runtime_common::{
-	assigned_slots, auctions, crowdloan, impls::ToAuthor, paras_registrar, paras_sudo_wrapper,
+	assigned_slots, auctions, crowdloan, impl_runtime_weights, impls::ToAuthor, paras_registrar,
-	slots, BlockHashCount, BlockLength, BlockWeights, RocksDbWeight, SlowAdjustingFeeUpdate,
+	paras_sudo_wrapper, slots,
 };
 use runtime_parachains::{self, runtime_api_impl::v2 as runtime_api_impl};
 use scale_info::TypeInfo;
@@ -89,6 +89,8 @@ mod validator_manager;
 mod weights;
 pub mod xcm_config;
 
+impl_runtime_weights!(rococo_runtime_constants);
+
 // Make the WASM binary available.
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

polkadot/runtime/test-runtime/constants/src/lib.rs

@@ -16,6 +16,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+pub mod weights;
+
 /// Money matters.
 pub mod currency {
 	use primitives::v2::Balance;
@@ -46,11 +48,11 @@ pub mod time {
 
 /// Fee-related.
 pub mod fee {
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
 	use primitives::v2::Balance;
-	use runtime_common::ExtrinsicBaseWeight;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 

polkadot/runtime/test-runtime/constants/src/weights/block_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Importing a block with 0 Extrinsics.
+		pub const BlockExecutionWeight: Weight = 5_000_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::BlockExecutionWeight::get();
+
+			// At least 100 µs.
+			assert!(w >= 100 * constants::WEIGHT_PER_MICROS, "Weight should be at least 100 µs.");
+			// At most 50 ms.
+			assert!(w <= 50 * constants::WEIGHT_PER_MILLIS, "Weight should be at most 50 ms.");
+		}
+	}
+}

polkadot/runtime/test-runtime/constants/src/weights/extrinsic_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Executing a NO-OP `System::remarks` Extrinsic.
+		pub const ExtrinsicBaseWeight: Weight = 125_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::ExtrinsicBaseWeight::get();
+
+			// At least 10 µs.
+			assert!(w >= 10 * constants::WEIGHT_PER_MICROS, "Weight should be at least 10 µs.");
+			// At most 1 ms.
+			assert!(w <= constants::WEIGHT_PER_MILLIS, "Weight should be at most 1 ms.");
+		}
+	}
+}

polkadot/runtime/test-runtime/constants/src/weights/mod.rs

@@ -0,0 +1,28 @@
+// 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.
+
+//! Expose the auto generated weight files.
+
+pub mod block_weights;
+pub mod extrinsic_weights;
+pub mod paritydb_weights;
+pub mod rocksdb_weights;
+
+pub use block_weights::constants::BlockExecutionWeight;
+pub use extrinsic_weights::constants::ExtrinsicBaseWeight;
+pub use paritydb_weights::constants::ParityDbWeight;
+pub use rocksdb_weights::constants::RocksDbWeight;

polkadot/runtime/test-runtime/constants/src/weights/paritydb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/test-runtime/constants/src/weights/rocksdb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// By default, Substrate uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/test-runtime/src/lib.rs

@@ -51,9 +51,7 @@ use primitives::v2::{
 	ScrapedOnChainVotes, SessionInfo as SessionInfoData, Signature, ValidationCode,
 	ValidationCodeHash, ValidatorId, ValidatorIndex,
 };
-use runtime_common::{
+use runtime_common::{claims, impl_runtime_weights, paras_sudo_wrapper};
-	claims, paras_sudo_wrapper, BlockHashCount, BlockLength, BlockWeights, SlowAdjustingFeeUpdate,
-};
 use sp_core::OpaqueMetadata;
 use sp_runtime::{
 	create_runtime_str,
@@ -84,6 +82,8 @@ pub use sp_runtime::BuildStorage;
 use test_runtime_constants::{currency::*, fee::*, time::*};
 pub mod xcm_config;
 
+impl_runtime_weights!(test_runtime_constants);
+
 // Make the WASM binary available.
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

polkadot/runtime/westend/constants/src/lib.rs

@@ -16,6 +16,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+pub mod weights;
+
 /// Money matters.
 pub mod currency {
 	use primitives::v2::Balance;
@@ -53,11 +55,11 @@ pub mod time {
 
 /// Fee-related.
 pub mod fee {
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
 	use primitives::v2::Balance;
-	use runtime_common::ExtrinsicBaseWeight;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
@@ -97,8 +99,9 @@ mod tests {
 		currency::{CENTS, MILLICENTS},
 		fee::WeightToFee,
 	};
+	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::WeightToFeePolynomial;
-	use runtime_common::{ExtrinsicBaseWeight, MAXIMUM_BLOCK_WEIGHT};
+	use runtime_common::MAXIMUM_BLOCK_WEIGHT;
 
 	#[test]
 	// This function tests that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight is correct

polkadot/runtime/westend/constants/src/weights/block_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Importing a block with 0 Extrinsics.
+		pub const BlockExecutionWeight: Weight = 5_000_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::BlockExecutionWeight::get();
+
+			// At least 100 µs.
+			assert!(w >= 100 * constants::WEIGHT_PER_MICROS, "Weight should be at least 100 µs.");
+			// At most 50 ms.
+			assert!(w <= 50 * constants::WEIGHT_PER_MILLIS, "Weight should be at most 50 ms.");
+		}
+	}
+}

polkadot/runtime/westend/constants/src/weights/extrinsic_weights.rs

@@ -0,0 +1,46 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Executing a NO-OP `System::remarks` Extrinsic.
+		pub const ExtrinsicBaseWeight: Weight = 125_000 * constants::WEIGHT_PER_NANOS;
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use frame_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::ExtrinsicBaseWeight::get();
+
+			// At least 10 µs.
+			assert!(w >= 10 * constants::WEIGHT_PER_MICROS, "Weight should be at least 10 µs.");
+			// At most 1 ms.
+			assert!(w <= constants::WEIGHT_PER_MILLIS, "Weight should be at most 1 ms.");
+		}
+	}
+}

polkadot/runtime/westend/constants/src/weights/mod.rs

@@ -0,0 +1,28 @@
+// 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.
+
+//! Expose the auto generated weight files.
+
+pub mod block_weights;
+pub mod extrinsic_weights;
+pub mod paritydb_weights;
+pub mod rocksdb_weights;
+
+pub use block_weights::constants::BlockExecutionWeight;
+pub use extrinsic_weights::constants::ExtrinsicBaseWeight;
+pub use paritydb_weights::constants::ParityDbWeight;
+pub use rocksdb_weights::constants::RocksDbWeight;

polkadot/runtime/westend/constants/src/weights/paritydb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/westend/constants/src/weights/rocksdb_weights.rs

@@ -0,0 +1,63 @@
+// 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.
+
+pub mod constants {
+	use frame_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// By default, Substrate uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use frame_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1) >= constants::WEIGHT_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1) >= constants::WEIGHT_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1) <= constants::WEIGHT_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1) <= constants::WEIGHT_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

polkadot/runtime/westend/src/lib.rs

@@ -29,9 +29,8 @@ use primitives::v2::{
 	SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
 };
 use runtime_common::{
-	assigned_slots, auctions, crowdloan, impls::ToAuthor, paras_registrar, paras_sudo_wrapper,
+	assigned_slots, auctions, crowdloan, impl_runtime_weights, impls::ToAuthor, paras_registrar,
-	slots, BlockHashCount, BlockLength, BlockWeights, CurrencyToVote, OffchainSolutionLengthLimit,
+	paras_sudo_wrapper, slots, CurrencyToVote,
-	OffchainSolutionWeightLimit, RocksDbWeight, SlowAdjustingFeeUpdate,
 };
 use sp_std::{collections::btree_map::BTreeMap, prelude::*};
 
@@ -49,7 +48,6 @@ use beefy_primitives::crypto::AuthorityId as BeefyId;
 use frame_support::{
 	construct_runtime, parameter_types,
 	traits::{Contains, InstanceFilter, KeyOwnerProofSystem, OnRuntimeUpgrade},
-	weights::Weight,
 	PalletId, RuntimeDebug,
 };
 use frame_system::EnsureRoot;
@@ -98,6 +96,8 @@ pub mod xcm_config;
 #[cfg(test)]
 mod tests;
 
+impl_runtime_weights!(westend_runtime_constants);
+
 // Make the WASM binary available.
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));