diff --git a/Cargo.lock b/Cargo.lock
index 7fd0122f3cc0f..ed633fcaa8978 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1473,9 +1473,9 @@ dependencies = [
 
 [[package]]
 name = "curve25519-dalek"
-version = "4.0.0-rc.0"
+version = "4.0.0-rc.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da00a7a9a4eb92a0a0f8e75660926d48f0d0f3c537e455c457bcdaa1e16b1ac"
+checksum = "8d4ba9852b42210c7538b75484f9daa0655e9a3ac04f693747bb0f02cf3cfe16"
 dependencies = [
  "cfg-if",
  "fiat-crypto",
@@ -2468,6 +2468,7 @@ dependencies = [
  "derive-syn-parse",
  "frame-support-procedural-tools",
  "itertools",
+ "proc-macro-warning",
  "proc-macro2",
  "quote",
  "syn",
@@ -7511,6 +7512,17 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "proc-macro-warning"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d4f284d87b9cedc2ff57223cbc4e3937cd6063c01e92c8e2a8c080df0013933"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.51"
@@ -8955,6 +8967,7 @@ dependencies = [
  "serde",
  "serde_json",
  "smallvec",
+ "snow",
  "sp-arithmetic",
  "sp-blockchain",
  "sp-consensus",
@@ -10034,14 +10047,14 @@ checksum = "5e9f0ab6ef7eb7353d9119c170a436d1bf248eea575ac42d19d12f4e34130831"
 
 [[package]]
 name = "snow"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12ba5f4d4ff12bdb6a169ed51b7c48c0e0ac4b0b4b31012b2571e97d78d3201d"
+checksum = "5ccba027ba85743e09d15c03296797cad56395089b832b48b5a5217880f57733"
 dependencies = [
  "aes-gcm 0.9.4",
  "blake2",
  "chacha20poly1305",
- "curve25519-dalek 4.0.0-rc.0",
+ "curve25519-dalek 4.0.0-rc.1",
  "rand_core 0.6.4",
  "ring",
  "rustc_version 0.4.0",
diff --git a/bin/node/runtime/src/lib.rs b/bin/node/runtime/src/lib.rs
index 5562dc263ddc8..433ca8e8b839e 100644
--- a/bin/node/runtime/src/lib.rs
+++ b/bin/node/runtime/src/lib.rs
@@ -364,7 +364,10 @@ impl pallet_scheduler::Config for Runtime {
 	type RuntimeCall = RuntimeCall;
 	type MaximumWeight = MaximumSchedulerWeight;
 	type ScheduleOrigin = EnsureRoot<AccountId>;
+	#[cfg(feature = "runtime-benchmarks")]
 	type MaxScheduledPerBlock = ConstU32<512>;
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type MaxScheduledPerBlock = ConstU32<50>;
 	type WeightInfo = pallet_scheduler::weights::SubstrateWeight<Runtime>;
 	type OriginPrivilegeCmp = EqualPrivilegeOnly;
 	type Preimages = Preimage;
diff --git a/client/executor/benches/bench.rs b/client/executor/benches/bench.rs
index 10425ea461c21..f129ebf64de12 100644
--- a/client/executor/benches/bench.rs
+++ b/client/executor/benches/bench.rs
@@ -72,6 +72,10 @@ fn initialize(
 					deterministic_stack_limit: None,
 					canonicalize_nans: false,
 					parallel_compilation: true,
+					wasm_multi_value: false,
+					wasm_bulk_memory: false,
+					wasm_reference_types: false,
+					wasm_simd: false,
 				},
 			};
 
diff --git a/client/executor/src/wasm_runtime.rs b/client/executor/src/wasm_runtime.rs
index 254380dbb3693..fb3dd0f38006c 100644
--- a/client/executor/src/wasm_runtime.rs
+++ b/client/executor/src/wasm_runtime.rs
@@ -326,6 +326,10 @@ where
 						deterministic_stack_limit: None,
 						canonicalize_nans: false,
 						parallel_compilation: true,
+						wasm_multi_value: false,
+						wasm_bulk_memory: false,
+						wasm_reference_types: false,
+						wasm_simd: false,
 					},
 				},
 			)
diff --git a/client/executor/wasmtime/src/runtime.rs b/client/executor/wasmtime/src/runtime.rs
index de7a2ea0e73df..e01a51f6cf2a7 100644
--- a/client/executor/wasmtime/src/runtime.rs
+++ b/client/executor/wasmtime/src/runtime.rs
@@ -325,10 +325,10 @@ fn common_config(semantics: &Semantics) -> std::result::Result<wasmtime::Config,
 
 	// Be clear and specific about the extensions we support. If an update brings new features
 	// they should be introduced here as well.
-	config.wasm_reference_types(false);
-	config.wasm_simd(false);
-	config.wasm_bulk_memory(false);
-	config.wasm_multi_value(false);
+	config.wasm_reference_types(semantics.wasm_reference_types);
+	config.wasm_simd(semantics.wasm_simd);
+	config.wasm_bulk_memory(semantics.wasm_bulk_memory);
+	config.wasm_multi_value(semantics.wasm_multi_value);
 	config.wasm_multi_memory(false);
 	config.wasm_threads(false);
 	config.wasm_memory64(false);
@@ -504,6 +504,18 @@ pub struct Semantics {
 
 	/// The heap allocation strategy to use.
 	pub heap_alloc_strategy: HeapAllocStrategy,
+
+	/// Enables WASM Multi-Value proposal
+	pub wasm_multi_value: bool,
+
+	/// Enables WASM Bulk Memory Operations proposal
+	pub wasm_bulk_memory: bool,
+
+	/// Enables WASM Reference Types proposal
+	pub wasm_reference_types: bool,
+
+	/// Enables WASM Fixed-Width SIMD proposal
+	pub wasm_simd: bool,
 }
 
 #[derive(Clone)]
diff --git a/client/executor/wasmtime/src/tests.rs b/client/executor/wasmtime/src/tests.rs
index 7f222b6cf7c05..0ca6095165572 100644
--- a/client/executor/wasmtime/src/tests.rs
+++ b/client/executor/wasmtime/src/tests.rs
@@ -155,6 +155,10 @@ impl RuntimeBuilder {
 				canonicalize_nans: self.canonicalize_nans,
 				parallel_compilation: true,
 				heap_alloc_strategy: self.heap_pages,
+				wasm_multi_value: false,
+				wasm_bulk_memory: false,
+				wasm_reference_types: false,
+				wasm_simd: false,
 			},
 		};
 
@@ -474,6 +478,10 @@ fn test_instances_without_reuse_are_not_leaked() {
 				canonicalize_nans: false,
 				parallel_compilation: true,
 				heap_alloc_strategy: HeapAllocStrategy::Static { extra_pages: 2048 },
+				wasm_multi_value: false,
+				wasm_bulk_memory: false,
+				wasm_reference_types: false,
+				wasm_simd: false,
 			},
 		},
 	)
diff --git a/client/network/Cargo.toml b/client/network/Cargo.toml
index 90b5ce871ef1a..6fc4131f74e10 100644
--- a/client/network/Cargo.toml
+++ b/client/network/Cargo.toml
@@ -51,6 +51,10 @@ sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
 sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
 sp-core = { version = "7.0.0", path = "../../primitives/core" }
 sp-runtime = { version = "7.0.0", path = "../../primitives/runtime" }
+# Force 0.9.2 as snow release to fix the compilation.
+#
+# When libp2p also enforces this version, we can get rid off this extra dep here.
+snow = "0.9.2"
 
 [dev-dependencies]
 assert_matches = "1.3"
diff --git a/client/rpc-api/src/state/mod.rs b/client/rpc-api/src/state/mod.rs
index ebc1eb9b4ff52..dbc2a505456a5 100644
--- a/client/rpc-api/src/state/mod.rs
+++ b/client/rpc-api/src/state/mod.rs
@@ -33,7 +33,7 @@ pub use self::helpers::ReadProof;
 /// Substrate state API
 #[rpc(client, server)]
 pub trait StateApi<Hash> {
-	/// Call a contract at a block's state.
+	/// Call a method from the runtime API at a block's state.
 	#[method(name = "state_call", aliases = ["state_callAt"], blocking)]
 	fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> RpcResult<Bytes>;
 
@@ -85,8 +85,10 @@ pub trait StateApi<Hash> {
 	/// Query historical storage entries (by key) starting from a block given as the second
 	/// parameter.
 	///
-	/// NOTE This first returned result contains the initial state of storage for all keys.
+	/// NOTE: The first returned result contains the initial state of storage for all keys.
 	/// Subsequent values in the vector represent changes to the previous state (diffs).
+	/// WARNING: The time complexity of this query is O(|keys|*dist(block, hash)), and the
+	/// memory complexity is O(dist(block, hash)) -- use with caution.
 	#[method(name = "state_queryStorage", blocking)]
 	fn query_storage(
 		&self,
@@ -95,7 +97,9 @@ pub trait StateApi<Hash> {
 		hash: Option<Hash>,
 	) -> RpcResult<Vec<StorageChangeSet<Hash>>>;
 
-	/// Query storage entries (by key) starting at block hash given as the second parameter.
+	/// Query storage entries (by key) at a block hash given as the second parameter.
+	/// NOTE: Each StorageChangeSet in the result corresponds to exactly one element --
+	/// the storage value under an input key at the input block hash.
 	#[method(name = "state_queryStorageAt", blocking)]
 	fn query_storage_at(
 		&self,
diff --git a/client/service/src/builder.rs b/client/service/src/builder.rs
index b04228e6bfc34..5d639431f427b 100644
--- a/client/service/src/builder.rs
+++ b/client/service/src/builder.rs
@@ -272,7 +272,6 @@ where
 	let executor = crate::client::LocalCallExecutor::new(
 		backend.clone(),
 		executor,
-		spawn_handle.clone(),
 		config.clone(),
 		execution_extensions,
 	)?;
diff --git a/client/service/src/client/call_executor.rs b/client/service/src/client/call_executor.rs
index 82d3e36ac80ea..4d019be908b86 100644
--- a/client/service/src/client/call_executor.rs
+++ b/client/service/src/client/call_executor.rs
@@ -23,7 +23,7 @@ use sc_client_api::{
 use sc_executor::{RuntimeVersion, RuntimeVersionOf};
 use sp_api::{ProofRecorder, StorageTransactionCache};
 use sp_core::{
-	traits::{CallContext, CodeExecutor, RuntimeCode, SpawnNamed},
+	traits::{CallContext, CodeExecutor, RuntimeCode},
 	ExecutionContext,
 };
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};
@@ -39,7 +39,6 @@ pub struct LocalCallExecutor<Block: BlockT, B, E> {
 	executor: E,
 	wasm_override: Arc<Option<WasmOverride>>,
 	wasm_substitutes: WasmSubstitutes<Block, E, B>,
-	spawn_handle: Box<dyn SpawnNamed>,
 	execution_extensions: Arc<ExecutionExtensions<Block>>,
 }
 
@@ -52,7 +51,6 @@ where
 	pub fn new(
 		backend: Arc<B>,
 		executor: E,
-		spawn_handle: Box<dyn SpawnNamed>,
 		client_config: ClientConfig<Block>,
 		execution_extensions: ExecutionExtensions<Block>,
 	) -> sp_blockchain::Result<Self> {
@@ -72,7 +70,6 @@ where
 			backend,
 			executor,
 			wasm_override: Arc::new(wasm_override),
-			spawn_handle,
 			wasm_substitutes,
 			execution_extensions: Arc::new(execution_extensions),
 		})
@@ -142,7 +139,6 @@ where
 			backend: self.backend.clone(),
 			executor: self.executor.clone(),
 			wasm_override: self.wasm_override.clone(),
-			spawn_handle: self.spawn_handle.clone(),
 			wasm_substitutes: self.wasm_substitutes.clone(),
 			execution_extensions: self.execution_extensions.clone(),
 		}
@@ -196,7 +192,6 @@ where
 			call_data,
 			extensions,
 			&runtime_code,
-			self.spawn_handle.clone(),
 			context,
 		)
 		.set_parent_hash(at_hash);
@@ -256,7 +251,6 @@ where
 					call_data,
 					extensions,
 					&runtime_code,
-					self.spawn_handle.clone(),
 					call_context,
 				)
 				.with_storage_transaction_cache(storage_transaction_cache.as_deref_mut())
@@ -272,7 +266,6 @@ where
 					call_data,
 					extensions,
 					&runtime_code,
-					self.spawn_handle.clone(),
 					call_context,
 				)
 				.with_storage_transaction_cache(storage_transaction_cache.as_deref_mut())
@@ -313,7 +306,6 @@ where
 			trie_backend,
 			&mut Default::default(),
 			&self.executor,
-			self.spawn_handle.clone(),
 			method,
 			call_data,
 			&runtime_code,
@@ -425,7 +417,6 @@ mod tests {
 			backend: backend.clone(),
 			executor: executor.clone(),
 			wasm_override: Arc::new(Some(overrides)),
-			spawn_handle: Box::new(TaskExecutor::new()),
 			wasm_substitutes: WasmSubstitutes::new(
 				Default::default(),
 				executor.clone(),
diff --git a/client/service/src/client/client.rs b/client/service/src/client/client.rs
index d5212021f2d79..3adb6d8976969 100644
--- a/client/service/src/client/client.rs
+++ b/client/service/src/client/client.rs
@@ -245,13 +245,8 @@ where
 		sc_offchain::OffchainDb::factory_from_backend(&*backend),
 	);
 
-	let call_executor = LocalCallExecutor::new(
-		backend.clone(),
-		executor,
-		spawn_handle.clone(),
-		config.clone(),
-		extensions,
-	)?;
+	let call_executor =
+		LocalCallExecutor::new(backend.clone(), executor, config.clone(), extensions)?;
 
 	Client::new(
 		backend,
diff --git a/client/service/test/src/client/mod.rs b/client/service/test/src/client/mod.rs
index 96a0a8fe2a023..e6545abf1bc73 100644
--- a/client/service/test/src/client/mod.rs
+++ b/client/service/test/src/client/mod.rs
@@ -104,7 +104,6 @@ fn construct_block(
 	let mut overlay = OverlayedChanges::default();
 	let backend_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(backend);
 	let runtime_code = backend_runtime_code.runtime_code().expect("Code is part of the backend");
-	let task_executor = Box::new(TaskExecutor::new());
 
 	StateMachine::new(
 		backend,
@@ -114,7 +113,6 @@ fn construct_block(
 		&header.encode(),
 		Default::default(),
 		&runtime_code,
-		task_executor.clone() as Box<_>,
 		CallContext::Onchain,
 	)
 	.execute(ExecutionStrategy::NativeElseWasm)
@@ -129,7 +127,6 @@ fn construct_block(
 			&tx.encode(),
 			Default::default(),
 			&runtime_code,
-			task_executor.clone() as Box<_>,
 			CallContext::Onchain,
 		)
 		.execute(ExecutionStrategy::NativeElseWasm)
@@ -144,7 +141,6 @@ fn construct_block(
 		&[],
 		Default::default(),
 		&runtime_code,
-		task_executor.clone() as Box<_>,
 		CallContext::Onchain,
 	)
 	.execute(ExecutionStrategy::NativeElseWasm)
@@ -217,7 +213,6 @@ fn construct_genesis_should_work_with_native() {
 		&b1data,
 		Default::default(),
 		&runtime_code,
-		TaskExecutor::new(),
 		CallContext::Onchain,
 	)
 	.execute(ExecutionStrategy::NativeElseWasm)
@@ -251,7 +246,6 @@ fn construct_genesis_should_work_with_wasm() {
 		&b1data,
 		Default::default(),
 		&runtime_code,
-		TaskExecutor::new(),
 		CallContext::Onchain,
 	)
 	.execute(ExecutionStrategy::AlwaysWasm)
@@ -285,7 +279,6 @@ fn construct_genesis_with_bad_transaction_should_panic() {
 		&b1data,
 		Default::default(),
 		&runtime_code,
-		TaskExecutor::new(),
 		CallContext::Onchain,
 	)
 	.execute(ExecutionStrategy::NativeElseWasm);
diff --git a/frame/assets/src/tests.rs b/frame/assets/src/tests.rs
index d4a49ac5a4651..afd224ad66642 100644
--- a/frame/assets/src/tests.rs
+++ b/frame/assets/src/tests.rs
@@ -1162,7 +1162,7 @@ fn set_min_balance_should_work() {
 #[test]
 fn balance_conversion_should_work() {
 	new_test_ext().execute_with(|| {
-		use frame_support::traits::tokens::BalanceConversion;
+		use frame_support::traits::tokens::ConversionToAssetBalance;
 
 		let id = 42;
 		assert_ok!(Assets::force_create(RuntimeOrigin::root(), id, 1, true, 10));
diff --git a/frame/assets/src/types.rs b/frame/assets/src/types.rs
index d50461ba59898..c83e764f4a68d 100644
--- a/frame/assets/src/types.rs
+++ b/frame/assets/src/types.rs
@@ -20,7 +20,7 @@
 use super::*;
 use frame_support::{
 	pallet_prelude::*,
-	traits::{fungible, tokens::BalanceConversion},
+	traits::{fungible, tokens::ConversionToAssetBalance},
 };
 use sp_runtime::{traits::Convert, FixedPointNumber, FixedPointOperand, FixedU128};
 
@@ -228,7 +228,7 @@ type BalanceOf<F, T> = <F as fungible::Inspect<AccountIdOf<T>>>::Balance;
 /// Converts a balance value into an asset balance based on the ratio between the fungible's
 /// minimum balance and the minimum asset balance.
 pub struct BalanceToAssetBalance<F, T, CON, I = ()>(PhantomData<(F, T, CON, I)>);
-impl<F, T, CON, I> BalanceConversion<BalanceOf<F, T>, AssetIdOf<T, I>, AssetBalanceOf<T, I>>
+impl<F, T, CON, I> ConversionToAssetBalance<BalanceOf<F, T>, AssetIdOf<T, I>, AssetBalanceOf<T, I>>
 	for BalanceToAssetBalance<F, T, CON, I>
 where
 	F: fungible::Inspect<AccountIdOf<T>>,
diff --git a/frame/balances/src/lib.rs b/frame/balances/src/lib.rs
index d4be806982dfe..dcf602cd5e0bf 100644
--- a/frame/balances/src/lib.rs
+++ b/frame/balances/src/lib.rs
@@ -786,7 +786,12 @@ pub mod pallet {
 					// Gah!! We have a non-zero reserve balance but no provider refs :(
 					// This shouldn't practically happen, but we need a failsafe anyway: let's give
 					// them enough for an ED.
-					a.free = a.free.min(Self::ed());
+					log::warn!(
+						target: LOG_TARGET,
+						"account with a non-zero reserve balance has no provider refs, account_id: '{:?}'.",
+						who
+					);
+					a.free = a.free.max(Self::ed());
 					system::Pallet::<T>::inc_providers(who);
 				}
 				let _ = system::Pallet::<T>::inc_consumers(who).defensive();
diff --git a/frame/benchmarking/pov/src/lib.rs b/frame/benchmarking/pov/src/lib.rs
index dccfe72d3f243..66000e54151b0 100644
--- a/frame/benchmarking/pov/src/lib.rs
+++ b/frame/benchmarking/pov/src/lib.rs
@@ -120,14 +120,14 @@ pub mod pallet {
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		#[pallet::call_index(0)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn emit_event(_origin: OriginFor<T>) -> DispatchResult {
 			Self::deposit_event(Event::TestEvent);
 			Ok(())
 		}
 
 		#[pallet::call_index(1)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn noop(_origin: OriginFor<T>) -> DispatchResult {
 			Ok(())
 		}
diff --git a/frame/benchmarking/src/tests.rs b/frame/benchmarking/src/tests.rs
index 453e8e125cbb3..80b631bb73668 100644
--- a/frame/benchmarking/src/tests.rs
+++ b/frame/benchmarking/src/tests.rs
@@ -29,7 +29,7 @@ use sp_runtime::{
 use sp_std::prelude::*;
 use std::cell::RefCell;
 
-#[frame_support::pallet]
+#[frame_support::pallet(dev_mode)]
 mod pallet_test {
 	use frame_support::pallet_prelude::*;
 	use frame_system::pallet_prelude::*;
diff --git a/frame/benchmarking/src/tests_instance.rs b/frame/benchmarking/src/tests_instance.rs
index d49d7cc817c6b..92d78b9ecbbe1 100644
--- a/frame/benchmarking/src/tests_instance.rs
+++ b/frame/benchmarking/src/tests_instance.rs
@@ -61,7 +61,7 @@ mod pallet_test {
 		<T as OtherConfig>::OtherEvent: Into<<T as Config<I>>::RuntimeEvent>,
 	{
 		#[pallet::call_index(0)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn set_value(origin: OriginFor<T>, n: u32) -> DispatchResult {
 			let _sender = ensure_signed(origin)?;
 			Value::<T, I>::put(n);
@@ -69,7 +69,7 @@ mod pallet_test {
 		}
 
 		#[pallet::call_index(1)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn dummy(origin: OriginFor<T>, _n: u32) -> DispatchResult {
 			let _sender = ensure_none(origin)?;
 			Ok(())
diff --git a/frame/collective/src/tests.rs b/frame/collective/src/tests.rs
index 79f6cc27fadbd..2550ab3ed2017 100644
--- a/frame/collective/src/tests.rs
+++ b/frame/collective/src/tests.rs
@@ -51,7 +51,7 @@ frame_support::construct_runtime!(
 
 mod mock_democracy {
 	pub use pallet::*;
-	#[frame_support::pallet]
+	#[frame_support::pallet(dev_mode)]
 	pub mod pallet {
 		use frame_support::pallet_prelude::*;
 		use frame_system::pallet_prelude::*;
diff --git a/frame/examples/offchain-worker/src/lib.rs b/frame/examples/offchain-worker/src/lib.rs
index 1a63955c04741..6ce8524174200 100644
--- a/frame/examples/offchain-worker/src/lib.rs
+++ b/frame/examples/offchain-worker/src/lib.rs
@@ -229,7 +229,7 @@ pub mod pallet {
 		/// This example is not focused on correctness of the oracle itself, but rather its
 		/// purpose is to showcase offchain worker capabilities.
 		#[pallet::call_index(0)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn submit_price(origin: OriginFor<T>, price: u32) -> DispatchResultWithPostInfo {
 			// Retrieve sender of the transaction.
 			let who = ensure_signed(origin)?;
@@ -255,7 +255,7 @@ pub mod pallet {
 		/// This example is not focused on correctness of the oracle itself, but rather its
 		/// purpose is to showcase offchain worker capabilities.
 		#[pallet::call_index(1)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn submit_price_unsigned(
 			origin: OriginFor<T>,
 			_block_number: T::BlockNumber,
@@ -272,7 +272,7 @@ pub mod pallet {
 		}
 
 		#[pallet::call_index(2)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn submit_price_unsigned_with_signed_payload(
 			origin: OriginFor<T>,
 			price_payload: PricePayload<T::Public, T::BlockNumber>,
diff --git a/frame/executive/src/lib.rs b/frame/executive/src/lib.rs
index 5003920eadcb5..aad1de11d2c7b 100644
--- a/frame/executive/src/lib.rs
+++ b/frame/executive/src/lib.rs
@@ -480,16 +480,10 @@ where
 			// any initial checks
 			Self::initial_checks(&block);
 
-			let signature_batching = sp_runtime::SignatureBatching::start();
-
 			// execute extrinsics
 			let (header, extrinsics) = block.deconstruct();
 			Self::execute_extrinsics_with_book_keeping(extrinsics, *header.number());
 
-			if !signature_batching.verify() {
-				panic!("Signature verification failed.");
-			}
-
 			// any final checks
 			Self::final_checks(&header);
 		}
@@ -700,7 +694,7 @@ mod tests {
 
 	const TEST_KEY: &[u8] = b":test:key:";
 
-	#[frame_support::pallet]
+	#[frame_support::pallet(dev_mode)]
 	mod custom {
 		use frame_support::pallet_prelude::*;
 		use frame_system::pallet_prelude::*;
diff --git a/frame/membership/src/lib.rs b/frame/membership/src/lib.rs
index 0be33a95613fe..e703b88f3657e 100644
--- a/frame/membership/src/lib.rs
+++ b/frame/membership/src/lib.rs
@@ -168,7 +168,7 @@ pub mod pallet {
 		///
 		/// May only be called from `T::AddOrigin`.
 		#[pallet::call_index(0)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn add_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
 			T::AddOrigin::ensure_origin(origin)?;
 			let who = T::Lookup::lookup(who)?;
@@ -191,7 +191,7 @@ pub mod pallet {
 		///
 		/// May only be called from `T::RemoveOrigin`.
 		#[pallet::call_index(1)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn remove_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
 			T::RemoveOrigin::ensure_origin(origin)?;
 			let who = T::Lookup::lookup(who)?;
@@ -215,7 +215,7 @@ pub mod pallet {
 		///
 		/// Prime membership is *not* passed from `remove` to `add`, if extant.
 		#[pallet::call_index(2)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn swap_member(
 			origin: OriginFor<T>,
 			remove: AccountIdLookupOf<T>,
@@ -249,7 +249,7 @@ pub mod pallet {
 		///
 		/// May only be called from `T::ResetOrigin`.
 		#[pallet::call_index(3)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn reset_members(origin: OriginFor<T>, members: Vec<T::AccountId>) -> DispatchResult {
 			T::ResetOrigin::ensure_origin(origin)?;
 
@@ -272,7 +272,7 @@ pub mod pallet {
 		///
 		/// Prime membership is passed from the origin account to `new`, if extant.
 		#[pallet::call_index(4)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn change_key(origin: OriginFor<T>, new: AccountIdLookupOf<T>) -> DispatchResult {
 			let remove = ensure_signed(origin)?;
 			let new = T::Lookup::lookup(new)?;
@@ -307,7 +307,7 @@ pub mod pallet {
 		///
 		/// May only be called from `T::PrimeOrigin`.
 		#[pallet::call_index(5)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn set_prime(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
 			T::PrimeOrigin::ensure_origin(origin)?;
 			let who = T::Lookup::lookup(who)?;
@@ -321,7 +321,7 @@ pub mod pallet {
 		///
 		/// May only be called from `T::PrimeOrigin`.
 		#[pallet::call_index(6)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn clear_prime(origin: OriginFor<T>) -> DispatchResult {
 			T::PrimeOrigin::ensure_origin(origin)?;
 			Prime::<T, I>::kill();
diff --git a/frame/nicks/src/lib.rs b/frame/nicks/src/lib.rs
index 5f510ce8e4cc0..92865c773d886 100644
--- a/frame/nicks/src/lib.rs
+++ b/frame/nicks/src/lib.rs
@@ -131,7 +131,7 @@ pub mod pallet {
 		/// ## Complexity
 		/// - O(1).
 		#[pallet::call_index(0)]
-		#[pallet::weight(50_000_000)]
+		#[pallet::weight({50_000_000})]
 		pub fn set_name(origin: OriginFor<T>, name: Vec<u8>) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
 
@@ -160,7 +160,7 @@ pub mod pallet {
 		/// ## Complexity
 		/// - O(1).
 		#[pallet::call_index(1)]
-		#[pallet::weight(70_000_000)]
+		#[pallet::weight({70_000_000})]
 		pub fn clear_name(origin: OriginFor<T>) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
 
@@ -183,7 +183,7 @@ pub mod pallet {
 		/// ## Complexity
 		/// - O(1).
 		#[pallet::call_index(2)]
-		#[pallet::weight(70_000_000)]
+		#[pallet::weight({70_000_000})]
 		pub fn kill_name(origin: OriginFor<T>, target: AccountIdLookupOf<T>) -> DispatchResult {
 			T::ForceOrigin::ensure_origin(origin)?;
 
@@ -207,7 +207,7 @@ pub mod pallet {
 		/// ## Complexity
 		/// - O(1).
 		#[pallet::call_index(3)]
-		#[pallet::weight(70_000_000)]
+		#[pallet::weight({70_000_000})]
 		pub fn force_name(
 			origin: OriginFor<T>,
 			target: AccountIdLookupOf<T>,
diff --git a/frame/nis/src/lib.rs b/frame/nis/src/lib.rs
index 0b8d292ec5f45..539011c5149d0 100644
--- a/frame/nis/src/lib.rs
+++ b/frame/nis/src/lib.rs
@@ -480,9 +480,6 @@ pub mod pallet {
 		AlreadyCommunal,
 		/// The receipt is already private.
 		AlreadyPrivate,
-		Release1,
-		Release2,
-		Tah,
 	}
 
 	pub(crate) struct WeightCounter {
@@ -724,8 +721,7 @@ pub mod pallet {
 			let dropped = receipt.proportion.is_zero();
 
 			if amount > on_hold {
-				T::Currency::release(&T::HoldReason::get(), &who, on_hold, Exact)
-					.map_err(|_| Error::<T>::Release1)?;
+				T::Currency::release(&T::HoldReason::get(), &who, on_hold, Exact)?;
 				let deficit = amount - on_hold;
 				// Try to transfer deficit from pot to receipt owner.
 				summary.receipts_on_hold.saturating_reduce(on_hold);
@@ -756,8 +752,7 @@ pub mod pallet {
 					)?;
 					summary.receipts_on_hold.saturating_reduce(on_hold);
 				}
-				T::Currency::release(&T::HoldReason::get(), &who, amount, Exact)
-					.map_err(|_| Error::<T>::Release2)?;
+				T::Currency::release(&T::HoldReason::get(), &who, amount, Exact)?;
 			}
 
 			if dropped {
diff --git a/frame/nomination-pools/src/lib.rs b/frame/nomination-pools/src/lib.rs
index e7c99e023289b..78f0c730ce5dd 100644
--- a/frame/nomination-pools/src/lib.rs
+++ b/frame/nomination-pools/src/lib.rs
@@ -2617,7 +2617,7 @@ pub mod pallet {
 		/// commission is paid out and added to total claimed commission`. Total pending commission
 		/// is reset to zero. the current.
 		#[pallet::call_index(20)]
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::claim_commission())]
 		pub fn claim_commission(origin: OriginFor<T>, pool_id: PoolId) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Self::do_claim_commission(who, pool_id)
diff --git a/frame/referenda/src/lib.rs b/frame/referenda/src/lib.rs
index b96cf5a76733d..68837376c5b33 100644
--- a/frame/referenda/src/lib.rs
+++ b/frame/referenda/src/lib.rs
@@ -874,22 +874,21 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		let when = (when.saturating_add(alarm_interval.saturating_sub(One::one())) /
 			alarm_interval)
 			.saturating_mul(alarm_interval);
-		let maybe_result = T::Scheduler::schedule(
+		let result = T::Scheduler::schedule(
 			DispatchTime::At(when),
 			None,
 			128u8,
 			frame_system::RawOrigin::Root.into(),
 			call,
-		)
-		.ok()
-		.map(|x| (when, x));
+		);
 		debug_assert!(
-			maybe_result.is_some(),
-			"Unable to schedule a new alarm at #{:?} (now: #{:?})?!",
+			result.is_ok(),
+			"Unable to schedule a new alarm at #{:?} (now: #{:?}), scheduler error: `{:?}`",
 			when,
-			frame_system::Pallet::<T>::block_number()
+			frame_system::Pallet::<T>::block_number(),
+			result.unwrap_err(),
 		);
-		maybe_result
+		result.ok().map(|x| (when, x))
 	}
 
 	/// Mutate a referendum's `status` into the correct deciding state.
diff --git a/frame/scheduler/src/lib.rs b/frame/scheduler/src/lib.rs
index 09bb3561188f8..8194f286c8323 100644
--- a/frame/scheduler/src/lib.rs
+++ b/frame/scheduler/src/lib.rs
@@ -216,6 +216,10 @@ pub mod pallet {
 		type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;
 
 		/// The maximum number of scheduled calls in the queue for a single block.
+		///
+		/// NOTE:
+		/// + Dependent pallets' benchmarks might require a higher limit for the setting. Set a
+		/// higher limit under `runtime-benchmarks` feature.
 		#[pallet::constant]
 		type MaxScheduledPerBlock: Get<u32>;
 
diff --git a/frame/scored-pool/src/lib.rs b/frame/scored-pool/src/lib.rs
index 336a69a798477..8bd44e2ffac8a 100644
--- a/frame/scored-pool/src/lib.rs
+++ b/frame/scored-pool/src/lib.rs
@@ -70,7 +70,7 @@
 //!
 //! 	#[pallet::call]
 //! 	impl<T: Config> Pallet<T> {
-//! 		#[pallet::weight(0)]
+//! 		#[pallet::weight({0})]
 //! 		pub fn candidate(origin: OriginFor<T>) -> DispatchResult {
 //! 			let who = ensure_signed(origin)?;
 //!
@@ -311,7 +311,7 @@ pub mod pallet {
 		/// The `index` parameter of this function must be set to
 		/// the index of the transactor in the `Pool`.
 		#[pallet::call_index(0)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn submit_candidacy(origin: OriginFor<T>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			ensure!(!<CandidateExists<T, I>>::contains_key(&who), Error::<T, I>::AlreadyInPool);
@@ -341,7 +341,7 @@ pub mod pallet {
 		/// The `index` parameter of this function must be set to
 		/// the index of the transactor in the `Pool`.
 		#[pallet::call_index(1)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn withdraw_candidacy(origin: OriginFor<T>, index: u32) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 
@@ -360,7 +360,7 @@ pub mod pallet {
 		/// The `index` parameter of this function must be set to
 		/// the index of `dest` in the `Pool`.
 		#[pallet::call_index(2)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn kick(
 			origin: OriginFor<T>,
 			dest: AccountIdLookupOf<T>,
@@ -385,7 +385,7 @@ pub mod pallet {
 		/// The `index` parameter of this function must be set to
 		/// the index of the `dest` in the `Pool`.
 		#[pallet::call_index(3)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn score(
 			origin: OriginFor<T>,
 			dest: AccountIdLookupOf<T>,
@@ -425,7 +425,7 @@ pub mod pallet {
 		///
 		/// May only be called from root.
 		#[pallet::call_index(4)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})]
 		pub fn change_member_count(origin: OriginFor<T>, count: u32) -> DispatchResult {
 			ensure_root(origin)?;
 			Self::update_member_count(count).map_err(Into::into)
diff --git a/frame/sudo/src/lib.rs b/frame/sudo/src/lib.rs
index 47309833a0681..1bc206e0063e4 100644
--- a/frame/sudo/src/lib.rs
+++ b/frame/sudo/src/lib.rs
@@ -195,7 +195,7 @@ pub mod pallet {
 		/// ## Complexity
 		/// - O(1).
 		#[pallet::call_index(2)]
-		#[pallet::weight(0)]
+		#[pallet::weight({0})] // FIXME
 		pub fn set_key(
 			origin: OriginFor<T>,
 			new: AccountIdLookupOf<T>,
diff --git a/frame/support/procedural/Cargo.toml b/frame/support/procedural/Cargo.toml
index ee1ca4dff8873..6dbdd3b3a594d 100644
--- a/frame/support/procedural/Cargo.toml
+++ b/frame/support/procedural/Cargo.toml
@@ -23,6 +23,7 @@ proc-macro2 = "1.0.37"
 quote = "1.0.10"
 syn = { version = "1.0.98", features = ["full"] }
 frame-support-procedural-tools = { version = "4.0.0-dev", path = "./tools" }
+proc-macro-warning = { version = "0.2.0", default-features = false }
 
 [features]
 default = ["std"]
diff --git a/frame/support/procedural/src/construct_runtime/expand/freeze_reason.rs b/frame/support/procedural/src/construct_runtime/expand/freeze_reason.rs
new file mode 100644
index 0000000000000..889168bf6c215
--- /dev/null
+++ b/frame/support/procedural/src/construct_runtime/expand/freeze_reason.rs
@@ -0,0 +1,67 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+use crate::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_freeze_reason(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut freeze_reason_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("FreezeReason") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			freeze_reason_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::codec::Encode, #scrate::codec::Decode, #scrate::codec::MaxEncodedLen,
+			#scrate::scale_info::TypeInfo,
+			#scrate::RuntimeDebug,
+		)]
+		pub enum RuntimeFreezeReason {
+			#( #freeze_reason_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::FreezeReason> for RuntimeFreezeReason {
+			fn from(hr: #path::FreezeReason) -> Self {
+				RuntimeFreezeReason::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::FreezeReason),
+	}
+}
diff --git a/frame/support/procedural/src/construct_runtime/expand/hold_reason.rs b/frame/support/procedural/src/construct_runtime/expand/hold_reason.rs
new file mode 100644
index 0000000000000..60fc094a4d5e4
--- /dev/null
+++ b/frame/support/procedural/src/construct_runtime/expand/hold_reason.rs
@@ -0,0 +1,67 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+use crate::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_hold_reason(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut hold_reason_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("HoldReason") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			hold_reason_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::codec::Encode, #scrate::codec::Decode, #scrate::codec::MaxEncodedLen,
+			#scrate::scale_info::TypeInfo,
+			#scrate::RuntimeDebug,
+		)]
+		pub enum RuntimeHoldReason {
+			#( #hold_reason_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::HoldReason> for RuntimeHoldReason {
+			fn from(hr: #path::HoldReason) -> Self {
+				RuntimeHoldReason::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::HoldReason),
+	}
+}
diff --git a/frame/support/procedural/src/construct_runtime/expand/lock_id.rs b/frame/support/procedural/src/construct_runtime/expand/lock_id.rs
new file mode 100644
index 0000000000000..77c6fefa0aabd
--- /dev/null
+++ b/frame/support/procedural/src/construct_runtime/expand/lock_id.rs
@@ -0,0 +1,67 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+use crate::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_lock_id(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut lock_id_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("LockId") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			lock_id_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::codec::Encode, #scrate::codec::Decode, #scrate::codec::MaxEncodedLen,
+			#scrate::scale_info::TypeInfo,
+			#scrate::RuntimeDebug,
+		)]
+		pub enum RuntimeLockId {
+			#( #lock_id_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::LockId> for RuntimeLockId {
+			fn from(hr: #path::LockId) -> Self {
+				RuntimeLockId::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::LockId),
+	}
+}
diff --git a/frame/support/procedural/src/construct_runtime/expand/mod.rs b/frame/support/procedural/src/construct_runtime/expand/mod.rs
index ace0b23bd7f85..0fd98bb4dda13 100644
--- a/frame/support/procedural/src/construct_runtime/expand/mod.rs
+++ b/frame/support/procedural/src/construct_runtime/expand/mod.rs
@@ -18,15 +18,23 @@
 mod call;
 mod config;
 mod event;
+mod freeze_reason;
+mod hold_reason;
 mod inherent;
+mod lock_id;
 mod metadata;
 mod origin;
+mod slash_reason;
 mod unsigned;
 
 pub use call::expand_outer_dispatch;
 pub use config::expand_outer_config;
 pub use event::expand_outer_event;
+pub use freeze_reason::expand_outer_freeze_reason;
+pub use hold_reason::expand_outer_hold_reason;
 pub use inherent::expand_outer_inherent;
+pub use lock_id::expand_outer_lock_id;
 pub use metadata::expand_runtime_metadata;
 pub use origin::expand_outer_origin;
+pub use slash_reason::expand_outer_slash_reason;
 pub use unsigned::expand_outer_validate_unsigned;
diff --git a/frame/support/procedural/src/construct_runtime/expand/slash_reason.rs b/frame/support/procedural/src/construct_runtime/expand/slash_reason.rs
new file mode 100644
index 0000000000000..2bf647aa7c1f4
--- /dev/null
+++ b/frame/support/procedural/src/construct_runtime/expand/slash_reason.rs
@@ -0,0 +1,67 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License
+
+use crate::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_slash_reason(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut slash_reason_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("SlashReason") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			slash_reason_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::codec::Encode, #scrate::codec::Decode, #scrate::codec::MaxEncodedLen,
+			#scrate::scale_info::TypeInfo,
+			#scrate::RuntimeDebug,
+		)]
+		pub enum RuntimeSlashReason {
+			#( #slash_reason_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::SlashReason> for RuntimeSlashReason {
+			fn from(hr: #path::SlashReason) -> Self {
+				RuntimeSlashReason::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::SlashReason),
+	}
+}
diff --git a/frame/support/procedural/src/construct_runtime/mod.rs b/frame/support/procedural/src/construct_runtime/mod.rs
index 9250186dc38e6..a0d414154bfcc 100644
--- a/frame/support/procedural/src/construct_runtime/mod.rs
+++ b/frame/support/procedural/src/construct_runtime/mod.rs
@@ -268,6 +268,10 @@ fn construct_runtime_final_expansion(
 	let inherent =
 		expand::expand_outer_inherent(&name, &block, &unchecked_extrinsic, &pallets, &scrate);
 	let validate_unsigned = expand::expand_outer_validate_unsigned(&name, &pallets, &scrate);
+	let freeze_reason = expand::expand_outer_freeze_reason(&pallets, &scrate);
+	let hold_reason = expand::expand_outer_hold_reason(&pallets, &scrate);
+	let lock_id = expand::expand_outer_lock_id(&pallets, &scrate);
+	let slash_reason = expand::expand_outer_slash_reason(&pallets, &scrate);
 	let integrity_test = decl_integrity_test(&scrate);
 	let static_assertions = decl_static_assertions(&name, &pallets, &scrate);
 
@@ -310,6 +314,14 @@ fn construct_runtime_final_expansion(
 
 		#validate_unsigned
 
+		#freeze_reason
+
+		#hold_reason
+
+		#lock_id
+
+		#slash_reason
+
 		#integrity_test
 
 		#static_assertions
diff --git a/frame/support/procedural/src/construct_runtime/parse.rs b/frame/support/procedural/src/construct_runtime/parse.rs
index b0bebcd9e0f21..5e6979f1d2b3b 100644
--- a/frame/support/procedural/src/construct_runtime/parse.rs
+++ b/frame/support/procedural/src/construct_runtime/parse.rs
@@ -38,6 +38,10 @@ mod keyword {
 	syn::custom_keyword!(Origin);
 	syn::custom_keyword!(Inherent);
 	syn::custom_keyword!(ValidateUnsigned);
+	syn::custom_keyword!(FreezeReason);
+	syn::custom_keyword!(HoldReason);
+	syn::custom_keyword!(LockId);
+	syn::custom_keyword!(SlashReason);
 	syn::custom_keyword!(exclude_parts);
 	syn::custom_keyword!(use_parts);
 }
@@ -370,6 +374,10 @@ pub enum PalletPartKeyword {
 	Origin(keyword::Origin),
 	Inherent(keyword::Inherent),
 	ValidateUnsigned(keyword::ValidateUnsigned),
+	FreezeReason(keyword::FreezeReason),
+	HoldReason(keyword::HoldReason),
+	LockId(keyword::LockId),
+	SlashReason(keyword::SlashReason),
 }
 
 impl Parse for PalletPartKeyword {
@@ -392,6 +400,14 @@ impl Parse for PalletPartKeyword {
 			Ok(Self::Inherent(input.parse()?))
 		} else if lookahead.peek(keyword::ValidateUnsigned) {
 			Ok(Self::ValidateUnsigned(input.parse()?))
+		} else if lookahead.peek(keyword::FreezeReason) {
+			Ok(Self::FreezeReason(input.parse()?))
+		} else if lookahead.peek(keyword::HoldReason) {
+			Ok(Self::HoldReason(input.parse()?))
+		} else if lookahead.peek(keyword::LockId) {
+			Ok(Self::LockId(input.parse()?))
+		} else if lookahead.peek(keyword::SlashReason) {
+			Ok(Self::SlashReason(input.parse()?))
 		} else {
 			Err(lookahead.error())
 		}
@@ -410,6 +426,10 @@ impl PalletPartKeyword {
 			Self::Origin(_) => "Origin",
 			Self::Inherent(_) => "Inherent",
 			Self::ValidateUnsigned(_) => "ValidateUnsigned",
+			Self::FreezeReason(_) => "FreezeReason",
+			Self::HoldReason(_) => "HoldReason",
+			Self::LockId(_) => "LockId",
+			Self::SlashReason(_) => "SlashReason",
 		}
 	}
 
@@ -435,6 +455,10 @@ impl Spanned for PalletPartKeyword {
 			Self::Origin(inner) => inner.span(),
 			Self::Inherent(inner) => inner.span(),
 			Self::ValidateUnsigned(inner) => inner.span(),
+			Self::FreezeReason(inner) => inner.span(),
+			Self::HoldReason(inner) => inner.span(),
+			Self::LockId(inner) => inner.span(),
+			Self::SlashReason(inner) => inner.span(),
 		}
 	}
 }
diff --git a/frame/support/procedural/src/lib.rs b/frame/support/procedural/src/lib.rs
index 45f22202991e8..dea2d4943de00 100644
--- a/frame/support/procedural/src/lib.rs
+++ b/frame/support/procedural/src/lib.rs
@@ -1411,3 +1411,30 @@ pub fn validate_unsigned(_: TokenStream, _: TokenStream) -> TokenStream {
 pub fn origin(_: TokenStream, _: TokenStream) -> TokenStream {
 	pallet_macro_stub()
 }
+
+/// The `#[pallet::composable_enum]` attribute allows you to define an enum that gets composed as an
+/// aggregate enum by `construct_runtime`. This is similar in principle with `#[pallet::event]` and
+/// `#[pallet::error]`.
+///
+/// The attribute currently only supports enum definitions, and identifiers that are named
+/// `FreezeReason`, `HoldReason`, `LockId` or `SlashReason`. Arbitrary identifiers for the enum are
+/// not supported. The aggregate enum generated by `construct_runtime` will have the name of
+/// `RuntimeFreezeReason`, `RuntimeHoldReason`, `RuntimeLockId` and `RuntimeSlashReason`
+/// respectively.
+///
+/// NOTE: The aggregate enum generated by `construct_runtime` generates a conversion function from
+/// the pallet enum to the aggregate enum, and automatically derives the following traits:
+///
+/// ```ignore
+/// Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, TypeInfo,
+/// RuntimeDebug
+/// ```
+///
+/// For ease of usage, when no `#[derive]` attributes are found for the enum under
+/// `#[pallet::composable_enum]`, the aforementioned traits are automatically derived for it. The
+/// inverse is also true: if there are any `#[derive]` attributes found for the enum, then no traits
+/// will automatically be derived for it.
+#[proc_macro_attribute]
+pub fn composable_enum(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
diff --git a/frame/support/procedural/src/pallet/expand/call.rs b/frame/support/procedural/src/pallet/expand/call.rs
index 0fdf4455ae7d0..74075848d9e9b 100644
--- a/frame/support/procedural/src/pallet/expand/call.rs
+++ b/frame/support/procedural/src/pallet/expand/call.rs
@@ -54,30 +54,47 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 		.map(|fn_name| format!("Create a call with the variant `{}`.", fn_name))
 		.collect::<Vec<_>>();
 
-	let mut warning_structs = Vec::new();
-	let mut warning_names = Vec::new();
+	let mut call_index_warnings = Vec::new();
 	// Emit a warning for each call that is missing `call_index` when not in dev-mode.
 	for method in &methods {
 		if method.explicit_call_index || def.dev_mode {
 			continue
 		}
 
-		let name = syn::Ident::new(&format!("{}", method.name), method.name.span());
-		let warning: syn::ItemStruct = syn::parse_quote!(
-			#[deprecated(note = r"
-			Implicit call indices are deprecated in favour of explicit ones.
-			Please ensure that all calls have the `pallet::call_index` attribute or that the
-			`dev-mode` of the pallet is enabled. For more info see:
-			<https://github.com/paritytech/substrate/pull/12891> and
-			<https://github.com/paritytech/substrate/pull/11381>.")]
-			#[allow(non_camel_case_types)]
-			struct #name;
-		);
-		warning_names.push(name);
-		warning_structs.push(warning);
+		let warning = proc_macro_warning::Warning::new_deprecated("ImplicitCallIndex")
+			.index(call_index_warnings.len())
+			.old("use implicit call indices")
+			.new("ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode")
+			.help_links(&[
+				"https://github.com/paritytech/substrate/pull/12891",
+				"https://github.com/paritytech/substrate/pull/11381"
+			])
+			.span(method.name.span())
+			.build();
+		call_index_warnings.push(warning);
 	}
 
 	let fn_weight = methods.iter().map(|method| &method.weight);
+	let mut weight_warnings = Vec::new();
+	for weight in fn_weight.clone() {
+		if def.dev_mode {
+			continue
+		}
+
+		match weight {
+			syn::Expr::Lit(lit) => {
+				let warning = proc_macro_warning::Warning::new_deprecated("ConstantWeight")
+					.index(weight_warnings.len())
+					.old("use hard-coded constant as call weight")
+					.new("benchmark all calls or put the pallet into `dev` mode")
+					.help_link("https://github.com/paritytech/substrate/pull/13798")
+					.span(lit.span())
+					.build();
+				weight_warnings.push(warning);
+			},
+			_ => {},
+		}
+	}
 
 	let fn_doc = methods.iter().map(|method| &method.docs).collect::<Vec<_>>();
 
@@ -203,9 +220,10 @@ pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
 	quote::quote_spanned!(span =>
 		mod warnings {
 			#(
-				#warning_structs
-				// This triggers each deprecated warning once.
-				const _: Option<#warning_names> = None;
+				#call_index_warnings
+			)*
+			#(
+				#weight_warnings
 			)*
 		}
 
diff --git a/frame/support/procedural/src/pallet/expand/tt_default_parts.rs b/frame/support/procedural/src/pallet/expand/tt_default_parts.rs
index 564b526e93536..f36c765f7beb6 100644
--- a/frame/support/procedural/src/pallet/expand/tt_default_parts.rs
+++ b/frame/support/procedural/src/pallet/expand/tt_default_parts.rs
@@ -15,7 +15,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{pallet::Def, COUNTER};
+use crate::{
+	pallet::{CompositeKeyword, Def},
+	COUNTER,
+};
 use syn::spanned::Spanned;
 
 /// Generate the `tt_default_parts` macro.
@@ -48,6 +51,30 @@ pub fn expand_tt_default_parts(def: &mut Def) -> proc_macro2::TokenStream {
 	let validate_unsigned_part =
 		def.validate_unsigned.as_ref().map(|_| quote::quote!(ValidateUnsigned,));
 
+	let freeze_reason_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::FreezeReason(_)))
+		.then_some(quote::quote!(FreezeReason,));
+
+	let hold_reason_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::HoldReason(_)))
+		.then_some(quote::quote!(HoldReason,));
+
+	let lock_id_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::LockId(_)))
+		.then_some(quote::quote!(LockId,));
+
+	let slash_reason_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::SlashReason(_)))
+		.then_some(quote::quote!(SlashReason,));
+
 	quote::quote!(
 		// This macro follows the conventions as laid out by the `tt-call` crate. It does not
 		// accept any arguments and simply returns the pallet parts, separated by commas, then
@@ -70,7 +97,8 @@ pub fn expand_tt_default_parts(def: &mut Def) -> proc_macro2::TokenStream {
 					tokens = [{
 						::{
 							Pallet, #call_part #storage_part #event_part #origin_part #config_part
-							#inherent_part #validate_unsigned_part
+							#inherent_part #validate_unsigned_part #freeze_reason_part
+							#hold_reason_part #lock_id_part #slash_reason_part
 						}
 					}]
 				}
diff --git a/frame/support/procedural/src/pallet/mod.rs b/frame/support/procedural/src/pallet/mod.rs
index 31048841c64e7..3618711051d7f 100644
--- a/frame/support/procedural/src/pallet/mod.rs
+++ b/frame/support/procedural/src/pallet/mod.rs
@@ -28,7 +28,7 @@
 mod expand;
 mod parse;
 
-pub use parse::Def;
+pub use parse::{composite::keyword::CompositeKeyword, Def};
 use syn::spanned::Spanned;
 
 mod keyword {
diff --git a/frame/support/procedural/src/pallet/parse/composite.rs b/frame/support/procedural/src/pallet/parse/composite.rs
new file mode 100644
index 0000000000000..2406f10d50a33
--- /dev/null
+++ b/frame/support/procedural/src/pallet/parse/composite.rs
@@ -0,0 +1,139 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use quote::ToTokens;
+use syn::spanned::Spanned;
+
+pub mod keyword {
+	use super::*;
+
+	syn::custom_keyword!(FreezeReason);
+	syn::custom_keyword!(HoldReason);
+	syn::custom_keyword!(LockId);
+	syn::custom_keyword!(SlashReason);
+	pub enum CompositeKeyword {
+		FreezeReason(FreezeReason),
+		HoldReason(HoldReason),
+		LockId(LockId),
+		SlashReason(SlashReason),
+	}
+
+	impl Spanned for CompositeKeyword {
+		fn span(&self) -> proc_macro2::Span {
+			use CompositeKeyword::*;
+			match self {
+				FreezeReason(inner) => inner.span(),
+				HoldReason(inner) => inner.span(),
+				LockId(inner) => inner.span(),
+				SlashReason(inner) => inner.span(),
+			}
+		}
+	}
+
+	impl syn::parse::Parse for CompositeKeyword {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let lookahead = input.lookahead1();
+			if lookahead.peek(FreezeReason) {
+				Ok(Self::FreezeReason(input.parse()?))
+			} else if lookahead.peek(HoldReason) {
+				Ok(Self::HoldReason(input.parse()?))
+			} else if lookahead.peek(LockId) {
+				Ok(Self::LockId(input.parse()?))
+			} else if lookahead.peek(SlashReason) {
+				Ok(Self::SlashReason(input.parse()?))
+			} else {
+				Err(lookahead.error())
+			}
+		}
+	}
+
+	impl std::fmt::Display for CompositeKeyword {
+		fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+			use CompositeKeyword::*;
+			write!(
+				f,
+				"{}",
+				match self {
+					FreezeReason(_) => "FreezeReason",
+					HoldReason(_) => "HoldReason",
+					LockId(_) => "LockId",
+					SlashReason(_) => "SlashReason",
+				}
+			)
+		}
+	}
+}
+
+pub struct CompositeDef {
+	/// The index of the HoldReason item in the pallet module.
+	pub index: usize,
+	/// The composite keyword used (contains span).
+	pub composite_keyword: keyword::CompositeKeyword,
+	/// The span of the pallet::composite_enum attribute.
+	pub attr_span: proc_macro2::Span,
+}
+
+impl CompositeDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		scrate: &proc_macro2::Ident,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Enum(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(
+				item.span(),
+				"Invalid pallet::composite_enum, expected enum item",
+			))
+		};
+
+		if !matches!(item.vis, syn::Visibility::Public(_)) {
+			let msg = format!("Invalid pallet::composite_enum, `{}` must be public", item.ident);
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		let has_derive_attr = item.attrs.iter().any(|attr| {
+			attr.parse_meta()
+				.ok()
+				.map(|meta| match meta {
+					syn::Meta::List(syn::MetaList { path, .. }) =>
+						path.get_ident().map(|ident| ident == "derive").unwrap_or(false),
+					_ => false,
+				})
+				.unwrap_or(false)
+		});
+
+		if !has_derive_attr {
+			let derive_attr: syn::Attribute = syn::parse_quote! {
+				#[derive(
+					Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+					#scrate::codec::Encode, #scrate::codec::Decode, #scrate::codec::MaxEncodedLen,
+					#scrate::scale_info::TypeInfo,
+					#scrate::RuntimeDebug,
+				)]
+			};
+			item.attrs.push(derive_attr);
+		}
+
+		let composite_keyword =
+			syn::parse2::<keyword::CompositeKeyword>(item.ident.to_token_stream())?;
+
+		Ok(CompositeDef { index, composite_keyword, attr_span })
+	}
+}
diff --git a/frame/support/procedural/src/pallet/parse/event.rs b/frame/support/procedural/src/pallet/parse/event.rs
index 64c3afd557335..0fb8ee4f54977 100644
--- a/frame/support/procedural/src/pallet/parse/event.rs
+++ b/frame/support/procedural/src/pallet/parse/event.rs
@@ -104,7 +104,7 @@ impl EventDef {
 		let item = if let syn::Item::Enum(item) = item {
 			item
 		} else {
-			return Err(syn::Error::new(item.span(), "Invalid pallet::event, expected item enum"))
+			return Err(syn::Error::new(item.span(), "Invalid pallet::event, expected enum item"))
 		};
 
 		let event_attrs: Vec<PalletEventDepositAttr> =
diff --git a/frame/support/procedural/src/pallet/parse/mod.rs b/frame/support/procedural/src/pallet/parse/mod.rs
index 94e6f7a7c2f7d..06b9899d03b97 100644
--- a/frame/support/procedural/src/pallet/parse/mod.rs
+++ b/frame/support/procedural/src/pallet/parse/mod.rs
@@ -20,6 +20,7 @@
 //! Parse the module into `Def` struct through `Def::try_from` function.
 
 pub mod call;
+pub mod composite;
 pub mod config;
 pub mod error;
 pub mod event;
@@ -35,6 +36,7 @@ pub mod storage;
 pub mod type_value;
 pub mod validate_unsigned;
 
+use composite::{keyword::CompositeKeyword, CompositeDef};
 use frame_support_procedural_tools::generate_crate_access_2018;
 use syn::spanned::Spanned;
 
@@ -56,6 +58,7 @@ pub struct Def {
 	pub genesis_build: Option<genesis_build::GenesisBuildDef>,
 	pub validate_unsigned: Option<validate_unsigned::ValidateUnsignedDef>,
 	pub extra_constants: Option<extra_constants::ExtraConstantsDef>,
+	pub composites: Vec<composite::CompositeDef>,
 	pub type_values: Vec<type_value::TypeValueDef>,
 	pub frame_system: syn::Ident,
 	pub frame_support: syn::Ident,
@@ -91,6 +94,7 @@ impl Def {
 		let mut extra_constants = None;
 		let mut storages = vec![];
 		let mut type_values = vec![];
+		let mut composites: Vec<CompositeDef> = vec![];
 
 		for (index, item) in items.iter_mut().enumerate() {
 			let pallet_attr: Option<PalletAttr> = helper::take_first_item_pallet_attr(item)?;
@@ -135,6 +139,32 @@ impl Def {
 				Some(PalletAttr::ExtraConstants(_)) =>
 					extra_constants =
 						Some(extra_constants::ExtraConstantsDef::try_from(index, item)?),
+				Some(PalletAttr::Composite(span)) => {
+					let composite =
+						composite::CompositeDef::try_from(span, index, &frame_support, item)?;
+					if composites.iter().any(|def| {
+						match (&def.composite_keyword, &composite.composite_keyword) {
+							(
+								CompositeKeyword::FreezeReason(_),
+								CompositeKeyword::FreezeReason(_),
+							) |
+							(CompositeKeyword::HoldReason(_), CompositeKeyword::HoldReason(_)) |
+							(CompositeKeyword::LockId(_), CompositeKeyword::LockId(_)) |
+							(
+								CompositeKeyword::SlashReason(_),
+								CompositeKeyword::SlashReason(_),
+							) => true,
+							_ => false,
+						}
+					}) {
+						let msg = format!(
+							"Invalid duplicated `{}` definition",
+							composite.composite_keyword
+						);
+						return Err(syn::Error::new(composite.composite_keyword.span(), &msg))
+					}
+					composites.push(composite);
+				},
 				Some(attr) => {
 					let msg = "Invalid duplicated attribute";
 					return Err(syn::Error::new(attr.span(), msg))
@@ -171,6 +201,7 @@ impl Def {
 			origin,
 			inherent,
 			storages,
+			composites,
 			type_values,
 			frame_system,
 			frame_support,
@@ -385,6 +416,7 @@ mod keyword {
 	syn::custom_keyword!(generate_store);
 	syn::custom_keyword!(Store);
 	syn::custom_keyword!(extra_constants);
+	syn::custom_keyword!(composite_enum);
 }
 
 /// Parse attributes for item in pallet module
@@ -404,6 +436,7 @@ enum PalletAttr {
 	ValidateUnsigned(proc_macro2::Span),
 	TypeValue(proc_macro2::Span),
 	ExtraConstants(proc_macro2::Span),
+	Composite(proc_macro2::Span),
 }
 
 impl PalletAttr {
@@ -423,6 +456,7 @@ impl PalletAttr {
 			Self::ValidateUnsigned(span) => *span,
 			Self::TypeValue(span) => *span,
 			Self::ExtraConstants(span) => *span,
+			Self::Composite(span) => *span,
 		}
 	}
 }
@@ -464,6 +498,8 @@ impl syn::parse::Parse for PalletAttr {
 			Ok(PalletAttr::TypeValue(content.parse::<keyword::type_value>()?.span()))
 		} else if lookahead.peek(keyword::extra_constants) {
 			Ok(PalletAttr::ExtraConstants(content.parse::<keyword::extra_constants>()?.span()))
+		} else if lookahead.peek(keyword::composite_enum) {
+			Ok(PalletAttr::Composite(content.parse::<keyword::composite_enum>()?.span()))
 		} else {
 			Err(lookahead.error())
 		}
diff --git a/frame/support/src/lib.rs b/frame/support/src/lib.rs
index b845828455793..e0ebeb68a3eaf 100644
--- a/frame/support/src/lib.rs
+++ b/frame/support/src/lib.rs
@@ -1552,6 +1552,7 @@ pub mod pallet_prelude {
 /// * [`pallet::inherent`](#inherent-palletinherent-optional)
 /// * [`pallet::validate_unsigned`](#validate-unsigned-palletvalidate_unsigned-optional)
 /// * [`pallet::origin`](#origin-palletorigin-optional)
+/// * [`pallet::composable_enum`](#composable-enum-palletcomposable_enum-optional)
 ///
 /// Note that at compile-time, the `#[pallet]` macro will analyze and expand all of these
 /// attributes, ultimately removing their AST nodes before they can be parsed as real
@@ -2277,6 +2278,29 @@ pub mod pallet_prelude {
 ///
 /// Also see [`pallet::origin`](`frame_support::pallet_macros::origin`)
 ///
+/// # Composable enum `#[pallet::composable_enum]` (optional)
+///
+/// The `#[pallet::composable_enum]` attribute allows you to define an enum on the pallet which
+/// will then instruct `construct_runtime` to amalgamate all similarly-named enums from other
+/// pallets into an aggregate enum. This is similar in principle with how the aggregate enum is
+/// generated for `#[pallet::event]` or `#[pallet::error]`.
+///
+/// The item tagged with `#[pallet::composable_enum]` MUST be an enum declaration, and can ONLY
+/// be the following identifiers: `FreezeReason`, `HoldReason`, `LockId` or `SlashReason`.
+/// Custom identifiers are not supported.
+///
+/// NOTE: For ease of usage, when no `#[derive]` attributes are detected, the
+/// `#[pallet::composable_enum]` attribute will automatically derive the following traits for
+/// the enum:
+///
+/// ```ignore
+/// Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, TypeInfo,
+/// RuntimeDebug
+/// ```
+///
+/// The inverse is also true: if there are any #[derive] attributes present for the enum, then
+/// the attribute will not automatically derive any of the traits described above.
+///
 /// # General notes on instantiable pallets
 ///
 /// An instantiable pallet is one where Config is generic, i.e. `Config<I>`. This allows
@@ -2808,10 +2832,11 @@ pub use frame_support_procedural::pallet;
 /// Contains macro stubs for all of the pallet:: macros
 pub mod pallet_macros {
 	pub use frame_support_procedural::{
-		call_index, compact, config, constant, disable_frame_system_supertrait_check, error, event,
-		extra_constants, generate_deposit, generate_storage_info, generate_store, genesis_build,
-		genesis_config, getter, hooks, inherent, origin, storage, storage_prefix, storage_version,
-		type_value, unbounded, validate_unsigned, weight, whitelist_storage,
+		call_index, compact, composable_enum, config, constant,
+		disable_frame_system_supertrait_check, error, event, extra_constants, generate_deposit,
+		generate_storage_info, generate_store, genesis_build, genesis_config, getter, hooks,
+		inherent, origin, storage, storage_prefix, storage_version, type_value, unbounded,
+		validate_unsigned, weight, whitelist_storage,
 	};
 }
 
diff --git a/frame/support/src/traits/tokens.rs b/frame/support/src/traits/tokens.rs
index d2753caa6a79d..253b49c6671f8 100644
--- a/frame/support/src/traits/tokens.rs
+++ b/frame/support/src/traits/tokens.rs
@@ -29,8 +29,8 @@ pub mod nonfungibles_v2;
 pub use imbalance::Imbalance;
 pub mod pay;
 pub use misc::{
-	AssetId, Balance, BalanceConversion, BalanceStatus, ConvertRank, DepositConsequence,
-	ExistenceRequirement, Fortitude, GetSalary, Locker, Precision, Preservation, Provenance,
-	Restriction, WithdrawConsequence, WithdrawReasons,
+	AssetId, Balance, BalanceStatus, ConversionFromAssetBalance, ConversionToAssetBalance,
+	ConvertRank, DepositConsequence, ExistenceRequirement, Fortitude, GetSalary, Locker, Precision,
+	Preservation, Provenance, Restriction, WithdrawConsequence, WithdrawReasons,
 };
 pub use pay::{Pay, PayFromAccount, PaymentStatus};
diff --git a/frame/support/src/traits/tokens/misc.rs b/frame/support/src/traits/tokens/misc.rs
index 8ad3a9535fd0d..75aef0e04ea65 100644
--- a/frame/support/src/traits/tokens/misc.rs
+++ b/frame/support/src/traits/tokens/misc.rs
@@ -244,9 +244,19 @@ impl<
 }
 
 /// Converts a balance value into an asset balance.
-pub trait BalanceConversion<InBalance, AssetId, OutBalance> {
+pub trait ConversionToAssetBalance<InBalance, AssetId, AssetBalance> {
 	type Error;
-	fn to_asset_balance(balance: InBalance, asset_id: AssetId) -> Result<OutBalance, Self::Error>;
+	fn to_asset_balance(balance: InBalance, asset_id: AssetId)
+		-> Result<AssetBalance, Self::Error>;
+}
+
+/// Converts an asset balance value into balance.
+pub trait ConversionFromAssetBalance<AssetBalance, AssetId, OutBalance> {
+	type Error;
+	fn from_asset_balance(
+		balance: AssetBalance,
+		asset_id: AssetId,
+	) -> Result<OutBalance, Self::Error>;
 }
 
 /// Trait to handle asset locking mechanism to ensure interactions with the asset can be implemented
diff --git a/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr b/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr
index 29df6e4bd8cb5..42f79e96d4473 100644
--- a/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr
+++ b/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr
@@ -1,4 +1,4 @@
-error: expected one of: `Pallet`, `Call`, `Storage`, `Event`, `Config`, `Origin`, `Inherent`, `ValidateUnsigned`
+error: expected one of: `Pallet`, `Call`, `Storage`, `Event`, `Config`, `Origin`, `Inherent`, `ValidateUnsigned`, `FreezeReason`, `HoldReason`, `LockId`, `SlashReason`
  --> $DIR/invalid_module_details_keyword.rs:9:20
   |
 9 |         system: System::{enum},
diff --git a/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr b/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr
index bd3e672dc8b40..6d535ca4335fc 100644
--- a/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr
+++ b/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr
@@ -1,4 +1,4 @@
-error: expected one of: `Pallet`, `Call`, `Storage`, `Event`, `Config`, `Origin`, `Inherent`, `ValidateUnsigned`
+error: expected one of: `Pallet`, `Call`, `Storage`, `Event`, `Config`, `Origin`, `Inherent`, `ValidateUnsigned`, `FreezeReason`, `HoldReason`, `LockId`, `SlashReason`
   --> $DIR/invalid_module_entry.rs:10:23
    |
 10 |         Balance: balances::{Error},
diff --git a/frame/support/test/tests/pallet.rs b/frame/support/test/tests/pallet.rs
index 52acdc5c26e03..37f1219a800f5 100644
--- a/frame/support/test/tests/pallet.rs
+++ b/frame/support/test/tests/pallet.rs
@@ -218,7 +218,7 @@ pub mod pallet {
 
 		/// Doc comment put in metadata
 		#[pallet::call_index(1)]
-		#[pallet::weight(1)]
+		#[pallet::weight({1})]
 		pub fn foo_storage_layer(
 			_origin: OriginFor<T>,
 			#[pallet::compact] foo: u32,
@@ -232,20 +232,20 @@ pub mod pallet {
 		}
 
 		#[pallet::call_index(4)]
-		#[pallet::weight(1)]
+		#[pallet::weight({1})]
 		pub fn foo_index_out_of_order(_origin: OriginFor<T>) -> DispatchResult {
 			Ok(())
 		}
 
 		// Test for DispatchResult return type
 		#[pallet::call_index(2)]
-		#[pallet::weight(1)]
+		#[pallet::weight({1})]
 		pub fn foo_no_post_info(_origin: OriginFor<T>) -> DispatchResult {
 			Ok(())
 		}
 
 		#[pallet::call_index(3)]
-		#[pallet::weight(1)]
+		#[pallet::weight({1})]
 		pub fn check_for_dispatch_context(_origin: OriginFor<T>) -> DispatchResult {
 			with_context::<(), _>(|_| ()).ok_or_else(|| DispatchError::Unavailable)
 		}
@@ -476,6 +476,11 @@ pub mod pallet {
 		}
 	}
 
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		Staking,
+	}
+
 	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
 	#[cfg_attr(feature = "std", derive(codec::Decode))]
 	pub enum InherentError {
@@ -570,6 +575,16 @@ pub mod pallet2 {
 	{
 		fn build(&self) {}
 	}
+
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		Governance,
+	}
+
+	#[pallet::composite_enum]
+	pub enum SlashReason {
+		Equivocation,
+	}
 }
 
 /// Test that the supertrait check works when we pass some parameter to the `frame_system::Config`.
@@ -974,6 +989,17 @@ fn validate_unsigned_expand() {
 	assert_eq!(validity, ValidTransaction::default());
 }
 
+#[test]
+fn composite_expand() {
+	let hold_reason: RuntimeHoldReason = pallet::HoldReason::Staking.into();
+	let hold_reason2: RuntimeHoldReason = pallet2::HoldReason::Governance.into();
+	let slash_reason: RuntimeSlashReason = pallet2::SlashReason::Equivocation.into();
+
+	assert_eq!(hold_reason, RuntimeHoldReason::Example(pallet::HoldReason::Staking));
+	assert_eq!(hold_reason2, RuntimeHoldReason::Example2(pallet2::HoldReason::Governance));
+	assert_eq!(slash_reason, RuntimeSlashReason::Example2(pallet2::SlashReason::Equivocation));
+}
+
 #[test]
 fn pallet_expand_deposit_event() {
 	TestExternalities::default().execute_with(|| {
diff --git a/frame/support/test/tests/pallet_instance.rs b/frame/support/test/tests/pallet_instance.rs
index 517f920c5ce07..241492a596993 100644
--- a/frame/support/test/tests/pallet_instance.rs
+++ b/frame/support/test/tests/pallet_instance.rs
@@ -27,7 +27,7 @@ use sp_io::{
 };
 use sp_runtime::{DispatchError, ModuleError};
 
-#[frame_support::pallet]
+#[frame_support::pallet(dev_mode)]
 pub mod pallet {
 	use codec::MaxEncodedLen;
 	use frame_support::{pallet_prelude::*, parameter_types, scale_info};
diff --git a/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr b/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr
index aed53b07b5e63..d10bf1359019a 100644
--- a/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr
+++ b/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr
@@ -1,3 +1,16 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_argument_invalid_bound.rs:19:20
+   |
+19 |         #[pallet::weight(0)]
+   |                          ^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
 error[E0277]: `<T as pallet::Config>::Bar` doesn't implement `std::fmt::Debug`
   --> tests/pallet_ui/call_argument_invalid_bound.rs:21:36
    |
diff --git a/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr b/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr
index 476258c03becd..7173cdcd47361 100644
--- a/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr
+++ b/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr
@@ -1,3 +1,16 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:19:20
+   |
+19 |         #[pallet::weight(0)]
+   |                          ^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
 error[E0277]: `<T as pallet::Config>::Bar` doesn't implement `std::fmt::Debug`
   --> tests/pallet_ui/call_argument_invalid_bound_2.rs:21:36
    |
diff --git a/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr b/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr
index 395da09cb0d6d..1b084dd2f76bc 100644
--- a/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr
+++ b/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr
@@ -1,3 +1,16 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_argument_invalid_bound_3.rs:21:20
+   |
+21 |         #[pallet::weight(0)]
+   |                          ^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
 error[E0277]: `Bar` doesn't implement `std::fmt::Debug`
   --> tests/pallet_ui/call_argument_invalid_bound_3.rs:23:36
    |
diff --git a/frame/support/test/tests/pallet_ui/call_missing_index.rs b/frame/support/test/tests/pallet_ui/call_missing_index.rs
index 7e305a573d622..98c49f493e50d 100644
--- a/frame/support/test/tests/pallet_ui/call_missing_index.rs
+++ b/frame/support/test/tests/pallet_ui/call_missing_index.rs
@@ -15,6 +15,11 @@ mod pallet {
 		pub fn foo(_: OriginFor<T>) -> DispatchResult {
 			Ok(())
 		}
+
+		#[pallet::weight(0)]
+		pub fn bar(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
 	}
 }
 
diff --git a/frame/support/test/tests/pallet_ui/call_missing_index.stderr b/frame/support/test/tests/pallet_ui/call_missing_index.stderr
index 9d00204979211..82dbe1d24c28e 100644
--- a/frame/support/test/tests/pallet_ui/call_missing_index.stderr
+++ b/frame/support/test/tests/pallet_ui/call_missing_index.stderr
@@ -1,12 +1,47 @@
-error: use of deprecated struct `pallet::warnings::foo`:
-                   Implicit call indices are deprecated in favour of explicit ones.
-                   Please ensure that all calls have the `pallet::call_index` attribute or that the
-                   `dev-mode` of the pallet is enabled. For more info see:
-                   <https://github.com/paritytech/substrate/pull/12891> and
-                   <https://github.com/paritytech/substrate/pull/11381>.
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_0::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
   --> tests/pallet_ui/call_missing_index.rs:15:10
    |
 15 |         pub fn foo(_: OriginFor<T>) -> DispatchResult {
    |                ^^^
    |
    = note: `-D deprecated` implied by `-D warnings`
+
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_1::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
+  --> tests/pallet_ui/call_missing_index.rs:20:10
+   |
+20 |         pub fn bar(_: OriginFor<T>) -> DispatchResult {
+   |                ^^^
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_missing_index.rs:14:20
+   |
+14 |         #[pallet::weight(0)]
+   |                          ^
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_1::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_missing_index.rs:19:20
+   |
+19 |         #[pallet::weight(0)]
+   |                          ^
diff --git a/frame/support/test/tests/pallet_ui/weight_argument_has_suffix.rs b/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.rs
similarity index 70%
rename from frame/support/test/tests/pallet_ui/weight_argument_has_suffix.rs
rename to frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.rs
index 99195d21be62e..c122877e8a075 100644
--- a/frame/support/test/tests/pallet_ui/weight_argument_has_suffix.rs
+++ b/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.rs
@@ -1,6 +1,6 @@
 #[frame_support::pallet]
 mod pallet {
-	use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+	use frame_support::pallet_prelude::DispatchResult;
 	use frame_system::pallet_prelude::OriginFor;
 
 	#[pallet::config]
@@ -13,7 +13,7 @@ mod pallet {
 	impl<T: Config> Pallet<T> {
 		#[pallet::call_index(0)]
         #[pallet::weight(10_000something)]
-		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo { Ok(().into()) }
+		pub fn foo(_: OriginFor<T>) -> DispatchResult { Ok(()) }
 	}
 }
 
diff --git a/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.stderr b/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.stderr
new file mode 100644
index 0000000000000..0651f003b9e23
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.stderr
@@ -0,0 +1,20 @@
+error: invalid suffix `something` for number literal
+  --> tests/pallet_ui/call_weight_argument_has_suffix.rs:15:26
+   |
+15 |         #[pallet::weight(10_000something)]
+   |                          ^^^^^^^^^^^^^^^ invalid suffix `something`
+   |
+   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_argument_has_suffix.rs:15:26
+   |
+15 |         #[pallet::weight(10_000something)]
+   |                          ^^^^^^^^^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
diff --git a/frame/support/test/tests/pallet_ui/call_weight_const_warning.rs b/frame/support/test/tests/pallet_ui/call_weight_const_warning.rs
new file mode 100644
index 0000000000000..2e5dc2a649e70
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/call_weight_const_warning.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResult;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+        #[pallet::weight(123_u64)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+	}
+}
+
+fn main() {
+}
diff --git a/frame/support/test/tests/pallet_ui/call_weight_const_warning.stderr b/frame/support/test/tests/pallet_ui/call_weight_const_warning.stderr
new file mode 100644
index 0000000000000..b04c3ec395ce6
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/call_weight_const_warning.stderr
@@ -0,0 +1,12 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_const_warning.rs:15:26
+   |
+15 |         #[pallet::weight(123_u64)]
+   |                          ^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
diff --git a/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.rs b/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.rs
new file mode 100644
index 0000000000000..798911dba33d9
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResult;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+        #[pallet::weight(123)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+
+		#[pallet::call_index(1)]
+        #[pallet::weight(123_custom_prefix)]
+		pub fn bar(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+	}
+}
+
+fn main() {
+}
diff --git a/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.stderr b/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.stderr
new file mode 100644
index 0000000000000..c656790207504
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.stderr
@@ -0,0 +1,31 @@
+error: invalid suffix `custom_prefix` for number literal
+  --> tests/pallet_ui/call_weight_const_warning_twice.rs:19:26
+   |
+19 |         #[pallet::weight(123_custom_prefix)]
+   |                          ^^^^^^^^^^^^^^^^^ invalid suffix `custom_prefix`
+   |
+   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_const_warning_twice.rs:15:26
+   |
+15 |         #[pallet::weight(123)]
+   |                          ^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_1::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_const_warning_twice.rs:19:26
+   |
+19 |         #[pallet::weight(123_custom_prefix)]
+   |                          ^^^^^^^^^^^^^^^^^
diff --git a/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.rs b/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.rs
new file mode 100644
index 0000000000000..74692ee94efd2
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.rs
@@ -0,0 +1,13 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+	pub enum HoldReasons {}
+}
+
+fn main() {}
\ No newline at end of file
diff --git a/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.stderr b/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.stderr
new file mode 100644
index 0000000000000..902e8923759b2
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `FreezeReason`, `HoldReason`, `LockId`, `SlashReason`
+  --> tests/pallet_ui/composite_enum_unsupported_identifier.rs:10:11
+   |
+10 |     pub enum HoldReasons {}
+   |              ^^^^^^^^^^^
diff --git a/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr b/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr
index c9de991135082..cf502ac5be475 100644
--- a/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr
+++ b/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr
@@ -1,9 +1,10 @@
-error: use of deprecated struct `pallet::warnings::my_call`:
-                   Implicit call indices are deprecated in favour of explicit ones.
-                   Please ensure that all calls have the `pallet::call_index` attribute or that the
-                   `dev-mode` of the pallet is enabled. For more info see:
-                   <https://github.com/paritytech/substrate/pull/12891> and
-                   <https://github.com/paritytech/substrate/pull/11381>.
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_0::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
   --> tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs:25:10
    |
 25 |         pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
@@ -11,6 +12,17 @@ error: use of deprecated struct `pallet::warnings::my_call`:
    |
    = note: `-D deprecated` implied by `-D warnings`
 
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs:24:20
+   |
+24 |         #[pallet::weight(0)]
+   |                          ^
+
 error[E0277]: the trait bound `Vec<u8>: MaxEncodedLen` is not satisfied
   --> tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs:11:12
    |
diff --git a/frame/support/test/tests/pallet_ui/event_wrong_item.stderr b/frame/support/test/tests/pallet_ui/event_wrong_item.stderr
index 21eb0ed35e936..0ef150dfd62e1 100644
--- a/frame/support/test/tests/pallet_ui/event_wrong_item.stderr
+++ b/frame/support/test/tests/pallet_ui/event_wrong_item.stderr
@@ -1,4 +1,4 @@
-error: Invalid pallet::event, expected item enum
+error: Invalid pallet::event, expected enum item
   --> $DIR/event_wrong_item.rs:19:2
    |
 19 |     pub struct Foo;
diff --git a/frame/support/test/tests/pallet_ui/hold_reason_non_enum.rs b/frame/support/test/tests/pallet_ui/hold_reason_non_enum.rs
new file mode 100644
index 0000000000000..8008c465e61ad
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/hold_reason_non_enum.rs
@@ -0,0 +1,14 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+	pub struct HoldReason;
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/frame/support/test/tests/pallet_ui/hold_reason_non_enum.stderr b/frame/support/test/tests/pallet_ui/hold_reason_non_enum.stderr
new file mode 100644
index 0000000000000..7d86b8d4f1bd5
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/hold_reason_non_enum.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::composite_enum, expected enum item
+  --> tests/pallet_ui/hold_reason_non_enum.rs:10:2
+   |
+10 |     pub struct HoldReason;
+   |     ^^^
diff --git a/frame/support/test/tests/pallet_ui/hold_reason_not_pub.rs b/frame/support/test/tests/pallet_ui/hold_reason_not_pub.rs
new file mode 100644
index 0000000000000..626dad7411319
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/hold_reason_not_pub.rs
@@ -0,0 +1,14 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+    enum HoldReason {}
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/frame/support/test/tests/pallet_ui/hold_reason_not_pub.stderr b/frame/support/test/tests/pallet_ui/hold_reason_not_pub.stderr
new file mode 100644
index 0000000000000..e8b0c14e967dd
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/hold_reason_not_pub.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::composite_enum, `HoldReason` must be public
+  --> tests/pallet_ui/hold_reason_not_pub.rs:10:5
+   |
+10 |     enum HoldReason {}
+   |     ^^^^
diff --git a/frame/support/test/tests/pallet_ui/lock_id_duplicate.rs b/frame/support/test/tests/pallet_ui/lock_id_duplicate.rs
new file mode 100644
index 0000000000000..70418efc41421
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/lock_id_duplicate.rs
@@ -0,0 +1,17 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+    pub enum LockId {}
+
+	#[pallet::composite_enum]
+    pub enum LockId {}
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/frame/support/test/tests/pallet_ui/lock_id_duplicate.stderr b/frame/support/test/tests/pallet_ui/lock_id_duplicate.stderr
new file mode 100644
index 0000000000000..1b7097d0a1095
--- /dev/null
+++ b/frame/support/test/tests/pallet_ui/lock_id_duplicate.stderr
@@ -0,0 +1,5 @@
+error: Invalid duplicated `LockId` definition
+  --> tests/pallet_ui/lock_id_duplicate.rs:13:14
+   |
+13 |     pub enum LockId {}
+   |              ^^^^^^
diff --git a/frame/support/test/tests/pallet_ui/weight_argument_has_suffix.stderr b/frame/support/test/tests/pallet_ui/weight_argument_has_suffix.stderr
deleted file mode 100644
index df9b0798ab93d..0000000000000
--- a/frame/support/test/tests/pallet_ui/weight_argument_has_suffix.stderr
+++ /dev/null
@@ -1,7 +0,0 @@
-error: invalid suffix `something` for number literal
-  --> tests/pallet_ui/weight_argument_has_suffix.rs:15:26
-   |
-15 |         #[pallet::weight(10_000something)]
-   |                          ^^^^^^^^^^^^^^^ invalid suffix `something`
-   |
-   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
diff --git a/frame/support/test/tests/storage_layers.rs b/frame/support/test/tests/storage_layers.rs
index f124aed9aa561..82174bf9d7141 100644
--- a/frame/support/test/tests/storage_layers.rs
+++ b/frame/support/test/tests/storage_layers.rs
@@ -22,7 +22,7 @@ use frame_support::{
 use pallet::*;
 use sp_io::TestExternalities;
 
-#[frame_support::pallet]
+#[frame_support::pallet(dev_mode)]
 pub mod pallet {
 	use frame_support::{ensure, pallet_prelude::*};
 	use frame_system::pallet_prelude::*;
diff --git a/frame/transaction-payment/asset-tx-payment/src/payment.rs b/frame/transaction-payment/asset-tx-payment/src/payment.rs
index f8d6888b9905c..49e78fb8bce01 100644
--- a/frame/transaction-payment/asset-tx-payment/src/payment.rs
+++ b/frame/transaction-payment/asset-tx-payment/src/payment.rs
@@ -22,7 +22,8 @@ use frame_support::{
 	traits::{
 		fungibles::{Balanced, Credit, Inspect},
 		tokens::{
-			Balance, BalanceConversion, Fortitude::Polite, Precision::Exact, Preservation::Protect,
+			Balance, ConversionToAssetBalance, Fortitude::Polite, Precision::Exact,
+			Preservation::Protect,
 		},
 	},
 	unsigned::TransactionValidityError,
@@ -87,7 +88,7 @@ impl<A, B: Balanced<A>> HandleCredit<A, B> for () {
 }
 
 /// Implements the asset transaction for a balance to asset converter (implementing
-/// [`BalanceConversion`]) and a credit handler (implementing [`HandleCredit`]).
+/// [`ConversionToAssetBalance`]) and a credit handler (implementing [`HandleCredit`]).
 ///
 /// The credit handler is given the complete fee in terms of the asset used for the transaction.
 pub struct FungiblesAdapter<CON, HC>(PhantomData<(CON, HC)>);
@@ -97,7 +98,7 @@ pub struct FungiblesAdapter<CON, HC>(PhantomData<(CON, HC)>);
 impl<T, CON, HC> OnChargeAssetTransaction<T> for FungiblesAdapter<CON, HC>
 where
 	T: Config,
-	CON: BalanceConversion<BalanceOf<T>, AssetIdOf<T>, AssetBalanceOf<T>>,
+	CON: ConversionToAssetBalance<BalanceOf<T>, AssetIdOf<T>, AssetBalanceOf<T>>,
 	HC: HandleCredit<T::AccountId, T::Fungibles>,
 	AssetIdOf<T>: FullCodec + Copy + MaybeSerializeDeserialize + Debug + Default + Eq + TypeInfo,
 {
diff --git a/frame/uniques/README.md b/frame/uniques/README.md
index 8a91a558b5b5f..6cdbcf79f1c95 100644
--- a/frame/uniques/README.md
+++ b/frame/uniques/README.md
@@ -4,67 +4,71 @@ A simple, secure module for dealing with non-fungible assets.
 
 ## Overview
 
-The Uniques module provides functionality for asset management of non-fungible asset classes, including:
+The Uniques module provides functionality for non-fungible tokens' management, including:
 
-* Asset Issuance
-* Asset Transfer
-* Asset Destruction
+* Collection Creation
+* Item Minting
+* Item Transfers
+* Item Trading methods
+* Attributes Management
+* Item Burning
 
-To use it in your runtime, you need to implement the assets [`uniques::Config`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/trait.Config.html).
+To use it in your runtime, you need to implement [`uniques::Config`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/trait.Config.html).
 
 The supported dispatchable functions are documented in the [`uniques::Call`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/enum.Call.html) enum.
 
 ### Terminology
 
-* **Asset issuance:** The creation of a new asset instance.
-* **Asset transfer:** The action of transferring an asset instance from one account to another.
-* **Asset burning:** The destruction of an asset instance.
-* **Non-fungible asset:** An asset for which each unit has unique characteristics. There is exactly
-  one instance of such an asset in existence and there is exactly one owning account.
+* **Collection creation:** The creation of a new collection.
+* **Item minting:** The action of creating a new item within a collection.
+* **Item transfer:** The action of sending an item from one account to another.
+* **Item burning:** The destruction of an item.
+* **Non-fungible token (NFT):** An item for which each unit has unique characteristics. There is exactly
+  one instance of such an item in existence and there is exactly one owning account.
 
 ### Goals
 
 The Uniques pallet in Substrate is designed to make the following possible:
 
-* Allow accounts to permissionlessly create asset classes (collections of asset instances).
-* Allow a named (permissioned) account to mint and burn unique assets within a class.
-* Move asset instances between accounts permissionlessly.
-* Allow a named (permissioned) account to freeze and unfreeze unique assets within a
-  class or the entire class.
-* Allow the owner of an asset instance to delegate the ability to transfer the asset to some
+* Allow accounts to permissionlessly create NFT collections.
+* Allow a named (permissioned) account to mint and burn unique items within a collection.
+* Move items between accounts permissionlessly.
+* Allow a named (permissioned) account to freeze and unfreeze unique items within a
+  collection or the entire collection.
+* Allow the owner of an item to delegate the ability to transfer the item to some
   named third-party.
 
 ## Interface
 
 ### Permissionless dispatchables
-* `create`: Create a new asset class by placing a deposit.
-* `transfer`: Transfer an asset instance to a new owner.
-* `redeposit`: Update the deposit amount of an asset instance, potentially freeing funds.
+* `create`: Create a new collection by placing a deposit.
+* `transfer`: Transfer an item to a new owner.
+* `redeposit`: Update the deposit amount of an item, potentially freeing funds.
 * `approve_transfer`: Name a delegate who may authorise a transfer.
 * `cancel_approval`: Revert the effects of a previous `approve_transfer`.
 
 ### Permissioned dispatchables
-* `destroy`: Destroy an asset class.
-* `mint`: Mint a new asset instance within an asset class.
-* `burn`: Burn an asset instance within an asset class.
-* `freeze`: Prevent an individual asset from being transferred.
+* `destroy`: Destroy a collection.
+* `mint`: Mint a new item within a collection.
+* `burn`: Burn an item within a collection.
+* `freeze`: Prevent an individual item from being transferred.
 * `thaw`: Revert the effects of a previous `freeze`.
-* `freeze_class`: Prevent all asset within a class from being transferred.
-* `thaw_class`: Revert the effects of a previous `freeze_class`.
-* `transfer_ownership`: Alter the owner of an asset class, moving all associated deposits.
-* `set_team`: Alter the permissioned accounts of an asset class.
+* `freeze_collection`: Prevent all items within a collection from being transferred.
+* `thaw_collection`: Revert the effects of a previous `freeze_collection`.
+* `transfer_ownership`: Alter the owner of a collection, moving all associated deposits.
+* `set_team`: Alter the permissioned accounts of a collection.
 
 ### Metadata (permissioned) dispatchables
-* `set_attribute`: Set a metadata attribute of an asset instance or class.
-* `clear_attribute`: Remove a metadata attribute of an asset instance or class.
-* `set_metadata`: Set general metadata of an asset instance.
-* `clear_metadata`: Remove general metadata of an asset instance.
-* `set_class_metadata`: Set general metadata of an asset class.
-* `clear_class_metadata`: Remove general metadata of an asset class.
+* `set_attribute`: Set an attribute of an item or collection.
+* `clear_attribute`: Remove an attribute of an item or collection.
+* `set_metadata`: Set general metadata of an item.
+* `clear_metadata`: Remove general metadata of an item.
+* `set_collection_metadata`: Set general metadata of a collection.
+* `clear_collection_metadata`: Remove general metadata of a collection.
 
 ### Force (i.e. governance) dispatchables
-* `force_create`: Create a new asset class.
-* `force_asset_status`: Alter the underlying characteristics of an asset class.
+* `force_create`: Create a new collection.
+* `force_asset_status`: Alter the underlying characteristics of a collection.
 
 Please refer to the [`Call`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/enum.Call.html) enum
 and its associated variants for documentation on each function.
diff --git a/frame/utility/src/tests.rs b/frame/utility/src/tests.rs
index 04f2728242874..d23c57e69bec5 100644
--- a/frame/utility/src/tests.rs
+++ b/frame/utility/src/tests.rs
@@ -41,7 +41,7 @@ use sp_runtime::{
 type BlockNumber = u64;
 
 // example module to test behaviors.
-#[frame_support::pallet]
+#[frame_support::pallet(dev_mode)]
 pub mod example {
 	use frame_support::{dispatch::WithPostDispatchInfo, pallet_prelude::*};
 	use frame_system::pallet_prelude::*;
@@ -91,7 +91,7 @@ pub mod example {
 
 mod mock_democracy {
 	pub use pallet::*;
-	#[frame_support::pallet]
+	#[frame_support::pallet(dev_mode)]
 	pub mod pallet {
 		use frame_support::pallet_prelude::*;
 		use frame_system::pallet_prelude::*;
diff --git a/primitives/api/test/tests/runtime_calls.rs b/primitives/api/test/tests/runtime_calls.rs
index 69f9a88ffadb3..b57793aad1253 100644
--- a/primitives/api/test/tests/runtime_calls.rs
+++ b/primitives/api/test/tests/runtime_calls.rs
@@ -188,7 +188,6 @@ fn record_proof_works() {
 		&backend,
 		&mut overlay,
 		&executor,
-		sp_core::testing::TaskExecutor::new(),
 		"Core_execute_block",
 		&block.encode(),
 		&runtime_code,
diff --git a/primitives/core/src/traits.rs b/primitives/core/src/traits.rs
index 091b1cdb14a34..51327868474a0 100644
--- a/primitives/core/src/traits.rs
+++ b/primitives/core/src/traits.rs
@@ -169,18 +169,6 @@ impl ReadRuntimeVersionExt {
 	}
 }
 
-sp_externalities::decl_extension! {
-	/// Task executor extension.
-	pub struct TaskExecutorExt(Box<dyn SpawnNamed>);
-}
-
-impl TaskExecutorExt {
-	/// New instance of task executor extension.
-	pub fn new(spawn_handle: impl SpawnNamed + Send + 'static) -> Self {
-		Self(Box::new(spawn_handle))
-	}
-}
-
 /// Something that can spawn tasks (blocking and non-blocking) with an assigned name
 /// and optional group.
 #[dyn_clonable::clonable]
diff --git a/primitives/io/src/batch_verifier.rs b/primitives/io/src/batch_verifier.rs
deleted file mode 100644
index e6d8c6131f778..0000000000000
--- a/primitives/io/src/batch_verifier.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: Apache-2.0
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 	http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! Batch/parallel verification.
-
-use futures::{channel::oneshot, future::FutureExt};
-use sp_core::{crypto::Pair, ecdsa, ed25519, sr25519, traits::SpawnNamed};
-use std::sync::{
-	atomic::{AtomicBool, Ordering as AtomicOrdering},
-	Arc,
-};
-
-#[derive(Debug, Clone)]
-struct Sr25519BatchItem {
-	signature: sr25519::Signature,
-	pub_key: sr25519::Public,
-	message: Vec<u8>,
-}
-
-/// Batch verifier.
-///
-/// Used to parallel-verify signatures for runtime host. Provide task executor and
-/// just push (`push_ed25519`, `push_sr25519`) as many signature as you need. At the end,
-/// call `verify_and_clear to get a result. After that, batch verifier is ready for the
-/// next batching job.
-pub struct BatchVerifier {
-	scheduler: Box<dyn SpawnNamed>,
-	sr25519_items: Vec<Sr25519BatchItem>,
-	invalid: Arc<AtomicBool>,
-	pending_tasks: Vec<oneshot::Receiver<()>>,
-}
-
-impl BatchVerifier {
-	pub fn new(scheduler: Box<dyn SpawnNamed>) -> Self {
-		BatchVerifier {
-			scheduler,
-			sr25519_items: Default::default(),
-			invalid: Arc::new(false.into()),
-			pending_tasks: vec![],
-		}
-	}
-
-	/// Spawn a verification task.
-	///
-	/// Returns `false` if there was already an invalid verification or if
-	/// the verification could not be spawned.
-	fn spawn_verification_task(
-		&mut self,
-		f: impl FnOnce() -> bool + Send + 'static,
-		name: &'static str,
-	) -> bool {
-		// there is already invalid transaction encountered
-		if self.invalid.load(AtomicOrdering::Relaxed) {
-			return false
-		}
-
-		let invalid_clone = self.invalid.clone();
-		let (sender, receiver) = oneshot::channel();
-		self.pending_tasks.push(receiver);
-
-		self.scheduler.spawn(
-			name,
-			None,
-			async move {
-				if !f() {
-					invalid_clone.store(true, AtomicOrdering::Relaxed);
-				}
-				if sender.send(()).is_err() {
-					// sanity
-					log::warn!("Verification halted while result was pending");
-					invalid_clone.store(true, AtomicOrdering::Relaxed);
-				}
-			}
-			.boxed(),
-		);
-
-		true
-	}
-
-	/// Push ed25519 signature to verify.
-	///
-	/// Returns false if some of the pushed signatures before already failed the check
-	/// (in this case it won't verify anything else)
-	pub fn push_ed25519(
-		&mut self,
-		signature: ed25519::Signature,
-		pub_key: ed25519::Public,
-		message: Vec<u8>,
-	) -> bool {
-		self.spawn_verification_task(
-			move || ed25519::Pair::verify(&signature, &message, &pub_key),
-			"substrate_ed25519_verify",
-		)
-	}
-
-	/// Push sr25519 signature to verify.
-	///
-	/// Returns false if some of the pushed signatures before already failed the check.
-	/// (in this case it won't verify anything else)
-	pub fn push_sr25519(
-		&mut self,
-		signature: sr25519::Signature,
-		pub_key: sr25519::Public,
-		message: Vec<u8>,
-	) -> bool {
-		if self.invalid.load(AtomicOrdering::Relaxed) {
-			return false
-		}
-		self.sr25519_items.push(Sr25519BatchItem { signature, pub_key, message });
-
-		if self.sr25519_items.len() >= 128 {
-			let items = std::mem::take(&mut self.sr25519_items);
-			self.spawn_verification_task(
-				move || Self::verify_sr25519_batch(items),
-				"substrate_sr25519_verify",
-			)
-		} else {
-			true
-		}
-	}
-
-	/// Push ecdsa signature to verify.
-	///
-	/// Returns false if some of the pushed signatures before already failed the check
-	/// (in this case it won't verify anything else)
-	pub fn push_ecdsa(
-		&mut self,
-		signature: ecdsa::Signature,
-		pub_key: ecdsa::Public,
-		message: Vec<u8>,
-	) -> bool {
-		self.spawn_verification_task(
-			move || ecdsa::Pair::verify(&signature, &message, &pub_key),
-			"substrate_ecdsa_verify",
-		)
-	}
-
-	fn verify_sr25519_batch(items: Vec<Sr25519BatchItem>) -> bool {
-		let messages = items.iter().map(|item| &item.message[..]).collect();
-		let signatures = items.iter().map(|item| &item.signature).collect();
-		let pub_keys = items.iter().map(|item| &item.pub_key).collect();
-
-		sr25519::verify_batch(messages, signatures, pub_keys)
-	}
-
-	/// Verify all previously pushed signatures since last call and return
-	/// aggregated result.
-	#[must_use]
-	pub fn verify_and_clear(&mut self) -> bool {
-		let pending = std::mem::take(&mut self.pending_tasks);
-		let started = std::time::Instant::now();
-
-		log::trace!(
-			target: "runtime",
-			"Batch-verification: {} pending tasks, {} sr25519 signatures",
-			pending.len(),
-			self.sr25519_items.len(),
-		);
-
-		if !Self::verify_sr25519_batch(std::mem::take(&mut self.sr25519_items)) {
-			return false
-		}
-
-		if pending.len() > 0 {
-			let (sender, receiver) = std::sync::mpsc::channel();
-			self.scheduler.spawn(
-				"substrate-batch-verify-join",
-				None,
-				async move {
-					futures::future::join_all(pending).await;
-					sender.send(()).expect(
-						"Channel never panics if receiver is live. \
-								Receiver is always live until received this data; qed. ",
-					);
-				}
-				.boxed(),
-			);
-
-			if receiver.recv().is_err() {
-				log::warn!(
-					target: "runtime",
-					"Haven't received async result from verification task. Returning false.",
-				);
-
-				return false
-			}
-		}
-
-		log::trace!(
-			target: "runtime",
-			"Finalization of batch verification took {} ms",
-			started.elapsed().as_millis(),
-		);
-
-		!self.invalid.swap(false, AtomicOrdering::Relaxed)
-	}
-}
diff --git a/primitives/io/src/lib.rs b/primitives/io/src/lib.rs
index 72300eb102177..750b5d5924637 100644
--- a/primitives/io/src/lib.rs
+++ b/primitives/io/src/lib.rs
@@ -40,7 +40,6 @@ use sp_core::{
 	hexdisplay::HexDisplay,
 	offchain::{OffchainDbExt, OffchainWorkerExt, TransactionPoolExt},
 	storage::ChildInfo,
-	traits::TaskExecutorExt,
 };
 #[cfg(feature = "std")]
 use sp_keystore::KeystoreExt;
@@ -75,12 +74,6 @@ use secp256k1::{
 #[cfg(feature = "std")]
 use sp_externalities::{Externalities, ExternalitiesExt};
 
-#[cfg(feature = "std")]
-mod batch_verifier;
-
-#[cfg(feature = "std")]
-use batch_verifier::BatchVerifier;
-
 pub use sp_externalities::MultiRemovalResults;
 
 #[cfg(feature = "std")]
@@ -801,15 +794,25 @@ pub trait Crypto {
 	/// needs to be called.
 	///
 	/// Returns `true` when the verification is either successful or batched.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
 	fn ed25519_batch_verify(
 		&mut self,
 		sig: &ed25519::Signature,
 		msg: &[u8],
 		pub_key: &ed25519::Public,
 	) -> bool {
-		self.extension::<VerificationExt>()
-			.map(|extension| extension.push_ed25519(sig.clone(), *pub_key, msg.to_vec()))
-			.unwrap_or_else(|| ed25519_verify(sig, msg, pub_key))
+		let res = ed25519_verify(sig, msg, pub_key);
+
+		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {
+			ext.0 &= res;
+		}
+
+		res
 	}
 
 	/// Verify `sr25519` signature.
@@ -828,25 +831,36 @@ pub trait Crypto {
 	/// needs to be called.
 	///
 	/// Returns `true` when the verification is either successful or batched.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
 	fn sr25519_batch_verify(
 		&mut self,
 		sig: &sr25519::Signature,
 		msg: &[u8],
 		pub_key: &sr25519::Public,
 	) -> bool {
-		self.extension::<VerificationExt>()
-			.map(|extension| extension.push_sr25519(sig.clone(), *pub_key, msg.to_vec()))
-			.unwrap_or_else(|| sr25519_verify(sig, msg, pub_key))
+		let res = sr25519_verify(sig, msg, pub_key);
+
+		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {
+			ext.0 &= res;
+		}
+
+		res
 	}
 
 	/// Start verification extension.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
 	fn start_batch_verify(&mut self) {
-		let scheduler = self
-			.extension::<TaskExecutorExt>()
-			.expect("No task executor associated with the current context!")
-			.clone();
-
-		self.register_extension(VerificationExt(BatchVerifier::new(scheduler)))
+		self.register_extension(VerificationExtDeprecated(true))
 			.expect("Failed to register required extension: `VerificationExt`");
 	}
 
@@ -856,13 +870,19 @@ pub trait Crypto {
 	/// deferred by `sr25519_verify`/`ed25519_verify`.
 	///
 	/// Will panic if no `VerificationExt` is registered (`start_batch_verify` was not called).
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
 	fn finish_batch_verify(&mut self) -> bool {
 		let result = self
-			.extension::<VerificationExt>()
+			.extension::<VerificationExtDeprecated>()
 			.expect("`finish_batch_verify` should only be called after `start_batch_verify`")
-			.verify_and_clear();
+			.0;
 
-		self.deregister_extension::<VerificationExt>()
+		self.deregister_extension::<VerificationExtDeprecated>()
 			.expect("No verification extension in current context!");
 
 		result
@@ -1005,15 +1025,25 @@ pub trait Crypto {
 	/// needs to be called.
 	///
 	/// Returns `true` when the verification is either successful or batched.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
 	fn ecdsa_batch_verify(
 		&mut self,
 		sig: &ecdsa::Signature,
 		msg: &[u8],
 		pub_key: &ecdsa::Public,
 	) -> bool {
-		self.extension::<VerificationExt>()
-			.map(|extension| extension.push_ecdsa(sig.clone(), *pub_key, msg.to_vec()))
-			.unwrap_or_else(|| ecdsa_verify(sig, msg, pub_key))
+		let res = ecdsa_verify(sig, msg, pub_key);
+
+		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {
+			ext.0 &= res;
+		}
+
+		res
 	}
 
 	/// Verify and recover a SECP256k1 ECDSA signature.
@@ -1186,8 +1216,10 @@ pub trait OffchainIndex {
 
 #[cfg(feature = "std")]
 sp_externalities::decl_extension! {
-	/// Batch verification extension to register/retrieve from the externalities.
-	pub struct VerificationExt(BatchVerifier);
+	/// Deprecated verification context.
+	///
+	/// Stores the combined result of all verifications that are done in the same context.
+	struct VerificationExtDeprecated(bool);
 }
 
 /// Interface that provides functions to access the offchain functionality.
@@ -1376,7 +1408,7 @@ pub trait Offchain {
 	/// Read all response headers.
 	///
 	/// Returns a vector of pairs `(HeaderKey, HeaderValue)`.
-	/// NOTE response headers have to be read before response body.
+	/// NOTE: response headers have to be read before response body.
 	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
 		self.extension::<OffchainWorkerExt>()
 			.expect("http_response_headers can be called only in the offchain worker context")
@@ -1389,7 +1421,7 @@ pub trait Offchain {
 	/// is reached or server closed the connection.
 	/// If `0` is returned it means that the response has been fully consumed
 	/// and the `request_id` is now invalid.
-	/// NOTE this implies that response headers must be read before draining the body.
+	/// NOTE: this implies that response headers must be read before draining the body.
 	/// Passing `None` as a deadline blocks forever.
 	fn http_response_read_body(
 		&mut self,
@@ -1684,12 +1716,8 @@ pub type SubstrateHostFunctions = (
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sp_core::{
-		crypto::UncheckedInto, map, storage::Storage, testing::TaskExecutor,
-		traits::TaskExecutorExt,
-	};
+	use sp_core::{crypto::UncheckedInto, map, storage::Storage};
 	use sp_state_machine::BasicExternalities;
-	use std::any::TypeId;
 
 	#[test]
 	fn storage_works() {
@@ -1781,54 +1809,6 @@ mod tests {
 		});
 	}
 
-	#[test]
-	fn batch_verify_start_finish_works() {
-		let mut ext = BasicExternalities::default();
-		ext.register_extension(TaskExecutorExt::new(TaskExecutor::new()));
-
-		ext.execute_with(|| {
-			crypto::start_batch_verify();
-		});
-
-		assert!(ext.extensions().get_mut(TypeId::of::<VerificationExt>()).is_some());
-
-		ext.execute_with(|| {
-			assert!(crypto::finish_batch_verify());
-		});
-
-		assert!(ext.extensions().get_mut(TypeId::of::<VerificationExt>()).is_none());
-	}
-
-	#[test]
-	fn long_sr25519_batching() {
-		let mut ext = BasicExternalities::default();
-		ext.register_extension(TaskExecutorExt::new(TaskExecutor::new()));
-		ext.execute_with(|| {
-			let pair = sr25519::Pair::generate_with_phrase(None).0;
-			let pair_unused = sr25519::Pair::generate_with_phrase(None).0;
-			crypto::start_batch_verify();
-			for it in 0..70 {
-				let msg = format!("Schnorrkel {}!", it);
-				let signature = pair.sign(msg.as_bytes());
-				crypto::sr25519_batch_verify(&signature, msg.as_bytes(), &pair.public());
-			}
-
-			// push invalid
-			let msg = b"asdf!";
-			let signature = pair.sign(msg);
-			crypto::sr25519_batch_verify(&signature, msg, &pair_unused.public());
-			assert!(!crypto::finish_batch_verify());
-
-			crypto::start_batch_verify();
-			for it in 0..70 {
-				let msg = format!("Schnorrkel {}!", it);
-				let signature = pair.sign(msg.as_bytes());
-				crypto::sr25519_batch_verify(&signature, msg.as_bytes(), &pair.public());
-			}
-			assert!(crypto::finish_batch_verify());
-		});
-	}
-
 	fn zero_ed_pub() -> ed25519::Public {
 		[0u8; 32].unchecked_into()
 	}
@@ -1837,90 +1817,6 @@ mod tests {
 		ed25519::Signature::from_raw([0u8; 64])
 	}
 
-	fn zero_sr_pub() -> sr25519::Public {
-		[0u8; 32].unchecked_into()
-	}
-
-	fn zero_sr_sig() -> sr25519::Signature {
-		sr25519::Signature::from_raw([0u8; 64])
-	}
-
-	#[test]
-	fn batching_works() {
-		let mut ext = BasicExternalities::default();
-		ext.register_extension(TaskExecutorExt::new(TaskExecutor::new()));
-
-		ext.execute_with(|| {
-			// valid ed25519 signature
-			crypto::start_batch_verify();
-			crypto::ed25519_batch_verify(&zero_ed_sig(), &Vec::new(), &zero_ed_pub());
-			assert!(crypto::finish_batch_verify());
-
-			// 2 valid ed25519 signatures
-			crypto::start_batch_verify();
-
-			let pair = ed25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Important message";
-			let signature = pair.sign(msg);
-			crypto::ed25519_batch_verify(&signature, msg, &pair.public());
-
-			let pair = ed25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Even more important message";
-			let signature = pair.sign(msg);
-			crypto::ed25519_batch_verify(&signature, msg, &pair.public());
-
-			assert!(crypto::finish_batch_verify());
-
-			// 1 valid, 1 invalid ed25519 signature
-			crypto::start_batch_verify();
-
-			let pair1 = ed25519::Pair::generate_with_phrase(None).0;
-			let pair2 = ed25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Important message";
-			let signature = pair1.sign(msg);
-
-			crypto::ed25519_batch_verify(&zero_ed_sig(), &Vec::new(), &zero_ed_pub());
-			crypto::ed25519_batch_verify(&signature, msg, &pair1.public());
-			crypto::ed25519_batch_verify(&signature, msg, &pair2.public());
-
-			assert!(!crypto::finish_batch_verify());
-
-			// 1 valid ed25519, 2 valid sr25519
-			crypto::start_batch_verify();
-
-			let pair = ed25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Ed25519 batching";
-			let signature = pair.sign(msg);
-			crypto::ed25519_batch_verify(&signature, msg, &pair.public());
-
-			let pair = sr25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Schnorrkel rules";
-			let signature = pair.sign(msg);
-			crypto::sr25519_batch_verify(&signature, msg, &pair.public());
-
-			let pair = sr25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Schnorrkel batches!";
-			let signature = pair.sign(msg);
-			crypto::sr25519_batch_verify(&signature, msg, &pair.public());
-
-			assert!(crypto::finish_batch_verify());
-
-			// 1 valid sr25519, 1 invalid sr25519
-			crypto::start_batch_verify();
-
-			let pair1 = sr25519::Pair::generate_with_phrase(None).0;
-			let pair2 = sr25519::Pair::generate_with_phrase(None).0;
-			let msg = b"Schnorrkcel!";
-			let signature = pair1.sign(msg);
-
-			crypto::sr25519_batch_verify(&signature, msg, &pair1.public());
-			crypto::sr25519_batch_verify(&signature, msg, &pair2.public());
-			crypto::sr25519_batch_verify(&zero_sr_sig(), &Vec::new(), &zero_sr_pub());
-
-			assert!(!crypto::finish_batch_verify());
-		});
-	}
-
 	#[test]
 	fn use_dalek_ext_works() {
 		let mut ext = BasicExternalities::default();
diff --git a/primitives/runtime/src/lib.rs b/primitives/runtime/src/lib.rs
index 622eac3d831af..2d959425e0f8e 100644
--- a/primitives/runtime/src/lib.rs
+++ b/primitives/runtime/src/lib.rs
@@ -904,40 +904,6 @@ pub fn print(print: impl traits::Printable) {
 	print.print();
 }
 
-/// Batching session.
-///
-/// To be used in runtime only. Outside of runtime, just construct
-/// `BatchVerifier` directly.
-#[must_use = "`verify()` needs to be called to finish batch signature verification!"]
-pub struct SignatureBatching(bool);
-
-impl SignatureBatching {
-	/// Start new batching session.
-	pub fn start() -> Self {
-		sp_io::crypto::start_batch_verify();
-		SignatureBatching(false)
-	}
-
-	/// Verify all signatures submitted during the batching session.
-	#[must_use]
-	pub fn verify(mut self) -> bool {
-		self.0 = true;
-		sp_io::crypto::finish_batch_verify()
-	}
-}
-
-impl Drop for SignatureBatching {
-	fn drop(&mut self) {
-		// Sanity check. If user forgets to actually call `verify()`.
-		//
-		// We should not panic if the current thread is already panicking,
-		// because Rust otherwise aborts the process.
-		if !self.0 && !sp_std::thread::panicking() {
-			panic!("Signature verification has not been called before `SignatureBatching::drop`")
-		}
-	}
-}
-
 /// Describes on what should happen with a storage transaction.
 pub enum TransactionOutcome<R> {
 	/// Commit the transaction.
@@ -962,7 +928,7 @@ mod tests {
 
 	use super::*;
 	use codec::{Decode, Encode};
-	use sp_core::crypto::{Pair, UncheckedFrom};
+	use sp_core::crypto::Pair;
 	use sp_io::TestExternalities;
 	use sp_state_machine::create_proof_check_backend;
 
@@ -1045,36 +1011,6 @@ mod tests {
 		assert!(multi_sig.verify(msg, &multi_signer.into_account()));
 	}
 
-	#[test]
-	#[should_panic(expected = "Signature verification has not been called")]
-	fn batching_still_finishes_when_not_called_directly() {
-		let mut ext = sp_state_machine::BasicExternalities::default();
-		ext.register_extension(sp_core::traits::TaskExecutorExt::new(
-			sp_core::testing::TaskExecutor::new(),
-		));
-
-		ext.execute_with(|| {
-			let _batching = SignatureBatching::start();
-			let dummy = UncheckedFrom::unchecked_from([1; 32]);
-			let dummy_sig = UncheckedFrom::unchecked_from([1; 64]);
-			sp_io::crypto::sr25519_verify(&dummy_sig, &Vec::new(), &dummy);
-		});
-	}
-
-	#[test]
-	#[should_panic(expected = "Hey, I'm an error")]
-	fn batching_does_not_panic_while_thread_is_already_panicking() {
-		let mut ext = sp_state_machine::BasicExternalities::default();
-		ext.register_extension(sp_core::traits::TaskExecutorExt::new(
-			sp_core::testing::TaskExecutor::new(),
-		));
-
-		ext.execute_with(|| {
-			let _batching = SignatureBatching::start();
-			panic!("Hey, I'm an error");
-		});
-	}
-
 	#[test]
 	fn execute_and_generate_proof_works() {
 		use codec::Encode;
diff --git a/primitives/state-machine/src/lib.rs b/primitives/state-machine/src/lib.rs
index 90ee962dafa9e..c68cf4d004529 100644
--- a/primitives/state-machine/src/lib.rs
+++ b/primitives/state-machine/src/lib.rs
@@ -163,7 +163,7 @@ mod execution {
 	use sp_core::{
 		hexdisplay::HexDisplay,
 		storage::{ChildInfo, ChildType, PrefixedStorageKey},
-		traits::{CallContext, CodeExecutor, ReadRuntimeVersionExt, RuntimeCode, SpawnNamed},
+		traits::{CallContext, CodeExecutor, ReadRuntimeVersionExt, RuntimeCode},
 	};
 	use sp_externalities::Extensions;
 	use std::{
@@ -324,11 +324,9 @@ mod execution {
 			call_data: &'a [u8],
 			mut extensions: Extensions,
 			runtime_code: &'a RuntimeCode,
-			spawn_handle: impl SpawnNamed + Send + 'static,
 			context: CallContext,
 		) -> Self {
 			extensions.register(ReadRuntimeVersionExt::new(exec.clone()));
-			extensions.register(sp_core::traits::TaskExecutorExt::new(spawn_handle));
 
 			Self {
 				backend,
@@ -511,11 +509,10 @@ mod execution {
 	}
 
 	/// Prove execution using the given state backend, overlayed changes, and call executor.
-	pub fn prove_execution<B, H, Exec, Spawn>(
+	pub fn prove_execution<B, H, Exec>(
 		backend: &mut B,
 		overlay: &mut OverlayedChanges,
 		exec: &Exec,
-		spawn_handle: Spawn,
 		method: &str,
 		call_data: &[u8],
 		runtime_code: &RuntimeCode,
@@ -525,14 +522,12 @@ mod execution {
 		H: Hasher,
 		H::Out: Ord + 'static + codec::Codec,
 		Exec: CodeExecutor + Clone + 'static,
-		Spawn: SpawnNamed + Send + 'static,
 	{
 		let trie_backend = backend.as_trie_backend();
-		prove_execution_on_trie_backend::<_, _, _, _>(
+		prove_execution_on_trie_backend::<_, _, _>(
 			trie_backend,
 			overlay,
 			exec,
-			spawn_handle,
 			method,
 			call_data,
 			runtime_code,
@@ -549,11 +544,10 @@ mod execution {
 	///
 	/// Note: changes to code will be in place if this call is made again. For running partial
 	/// blocks (e.g. a transaction at a time), ensure a different method is used.
-	pub fn prove_execution_on_trie_backend<S, H, Exec, Spawn>(
+	pub fn prove_execution_on_trie_backend<S, H, Exec>(
 		trie_backend: &TrieBackend<S, H>,
 		overlay: &mut OverlayedChanges,
 		exec: &Exec,
-		spawn_handle: Spawn,
 		method: &str,
 		call_data: &[u8],
 		runtime_code: &RuntimeCode,
@@ -564,7 +558,6 @@ mod execution {
 		H: Hasher,
 		H::Out: Ord + 'static + codec::Codec,
 		Exec: CodeExecutor + 'static + Clone,
-		Spawn: SpawnNamed + Send + 'static,
 	{
 		let proving_backend =
 			TrieBackendBuilder::wrap(trie_backend).with_recorder(Default::default()).build();
@@ -577,7 +570,6 @@ mod execution {
 			call_data,
 			extensions,
 			runtime_code,
-			spawn_handle,
 			CallContext::Offchain,
 		)
 		.execute_using_consensus_failure_handler::<_>(always_wasm())?;
@@ -590,12 +582,11 @@ mod execution {
 	}
 
 	/// Check execution proof, generated by `prove_execution` call.
-	pub fn execution_proof_check<H, Exec, Spawn>(
+	pub fn execution_proof_check<H, Exec>(
 		root: H::Out,
 		proof: StorageProof,
 		overlay: &mut OverlayedChanges,
 		exec: &Exec,
-		spawn_handle: Spawn,
 		method: &str,
 		call_data: &[u8],
 		runtime_code: &RuntimeCode,
@@ -604,14 +595,12 @@ mod execution {
 		H: Hasher + 'static,
 		Exec: CodeExecutor + Clone + 'static,
 		H::Out: Ord + 'static + codec::Codec,
-		Spawn: SpawnNamed + Send + 'static,
 	{
 		let trie_backend = create_proof_check_backend::<H>(root, proof)?;
-		execution_proof_check_on_trie_backend::<_, _, _>(
+		execution_proof_check_on_trie_backend::<_, _>(
 			&trie_backend,
 			overlay,
 			exec,
-			spawn_handle,
 			method,
 			call_data,
 			runtime_code,
@@ -619,11 +608,10 @@ mod execution {
 	}
 
 	/// Check execution proof on proving backend, generated by `prove_execution` call.
-	pub fn execution_proof_check_on_trie_backend<H, Exec, Spawn>(
+	pub fn execution_proof_check_on_trie_backend<H, Exec>(
 		trie_backend: &TrieBackend<MemoryDB<H>, H>,
 		overlay: &mut OverlayedChanges,
 		exec: &Exec,
-		spawn_handle: Spawn,
 		method: &str,
 		call_data: &[u8],
 		runtime_code: &RuntimeCode,
@@ -632,7 +620,6 @@ mod execution {
 		H: Hasher,
 		H::Out: Ord + 'static + codec::Codec,
 		Exec: CodeExecutor + Clone + 'static,
-		Spawn: SpawnNamed + Send + 'static,
 	{
 		StateMachine::<_, H, Exec>::new(
 			trie_backend,
@@ -642,7 +629,6 @@ mod execution {
 			call_data,
 			Extensions::default(),
 			runtime_code,
-			spawn_handle,
 			CallContext::Offchain,
 		)
 		.execute_using_consensus_failure_handler(always_untrusted_wasm())
@@ -1309,7 +1295,6 @@ mod tests {
 	use sp_core::{
 		map,
 		storage::{ChildInfo, StateVersion},
-		testing::TaskExecutor,
 		traits::{CallContext, CodeExecutor, Externalities, RuntimeCode},
 		H256,
 	};
@@ -1384,7 +1369,6 @@ mod tests {
 			&[],
 			Default::default(),
 			&wasm_code,
-			TaskExecutor::new(),
 			CallContext::Offchain,
 		);
 
@@ -1413,7 +1397,6 @@ mod tests {
 			&[],
 			Default::default(),
 			&wasm_code,
-			TaskExecutor::new(),
 			CallContext::Offchain,
 		);
 
@@ -1443,7 +1426,6 @@ mod tests {
 			&[],
 			Default::default(),
 			&wasm_code,
-			TaskExecutor::new(),
 			CallContext::Offchain,
 		);
 
@@ -1475,7 +1457,6 @@ mod tests {
 			&mut remote_backend,
 			&mut Default::default(),
 			&executor,
-			TaskExecutor::new(),
 			"test",
 			&[],
 			&RuntimeCode::empty(),
@@ -1483,12 +1464,11 @@ mod tests {
 		.unwrap();
 
 		// check proof locally
-		let local_result = execution_proof_check::<BlakeTwo256, _, _>(
+		let local_result = execution_proof_check::<BlakeTwo256, _>(
 			remote_root,
 			remote_proof,
 			&mut Default::default(),
 			&executor,
-			TaskExecutor::new(),
 			"test",
 			&[],
 			&RuntimeCode::empty(),
diff --git a/primitives/state-machine/src/testing.rs b/primitives/state-machine/src/testing.rs
index a9f6399a9a1b5..3a0165fe4588d 100644
--- a/primitives/state-machine/src/testing.rs
+++ b/primitives/state-machine/src/testing.rs
@@ -34,8 +34,6 @@ use sp_core::{
 		well_known_keys::{is_child_storage_key, CODE},
 		StateVersion, Storage,
 	},
-	testing::TaskExecutor,
-	traits::TaskExecutorExt,
 };
 use sp_externalities::{Extension, ExtensionStore, Extensions};
 use sp_trie::StorageProof;
@@ -105,9 +103,6 @@ where
 
 		storage.top.insert(CODE.to_vec(), code.to_vec());
 
-		let mut extensions = Extensions::default();
-		extensions.register(TaskExecutorExt::new(TaskExecutor::new()));
-
 		let offchain_db = TestPersistentOffchainDB::new();
 
 		let backend = (storage, state_version).into();
@@ -115,7 +110,7 @@ where
 		TestExternalities {
 			overlay: OverlayedChanges::default(),
 			offchain_db,
-			extensions,
+			extensions: Default::default(),
 			backend,
 			storage_transaction_cache: Default::default(),
 			state_version,
diff --git a/test-utils/client/src/lib.rs b/test-utils/client/src/lib.rs
index a91aa99929e2f..5e3c9f703fea1 100644
--- a/test-utils/client/src/lib.rs
+++ b/test-utils/client/src/lib.rs
@@ -291,7 +291,6 @@ impl<Block: BlockT, D, Backend, G: GenesisInit>
 		let executor = LocalCallExecutor::new(
 			self.backend.clone(),
 			executor,
-			Box::new(sp_core::testing::TaskExecutor::new()),
 			Default::default(),
 			ExecutionExtensions::new(
 				self.execution_strategies.clone(),
diff --git a/utils/frame/benchmarking-cli/src/pallet/command.rs b/utils/frame/benchmarking-cli/src/pallet/command.rs
index 15ebc668ff4fb..5016d65b89beb 100644
--- a/utils/frame/benchmarking-cli/src/pallet/command.rs
+++ b/utils/frame/benchmarking-cli/src/pallet/command.rs
@@ -238,7 +238,6 @@ impl PalletCmd {
 			&(self.extra).encode(),
 			extensions(),
 			&sp_state_machine::backend::BackendRuntimeCode::new(state).runtime_code()?,
-			sp_core::testing::TaskExecutor::new(),
 			CallContext::Offchain,
 		)
 		.execute(strategy.into())
@@ -376,7 +375,6 @@ impl PalletCmd {
 						extensions(),
 						&sp_state_machine::backend::BackendRuntimeCode::new(state)
 							.runtime_code()?,
-						sp_core::testing::TaskExecutor::new(),
 						CallContext::Offchain,
 					)
 					.execute(strategy.into())
@@ -417,7 +415,6 @@ impl PalletCmd {
 						extensions(),
 						&sp_state_machine::backend::BackendRuntimeCode::new(state)
 							.runtime_code()?,
-						sp_core::testing::TaskExecutor::new(),
 						CallContext::Offchain,
 					)
 					.execute(strategy.into())
@@ -450,7 +447,6 @@ impl PalletCmd {
 						extensions(),
 						&sp_state_machine::backend::BackendRuntimeCode::new(state)
 							.runtime_code()?,
-						sp_core::testing::TaskExecutor::new(),
 						CallContext::Offchain,
 					)
 					.execute(strategy.into())
diff --git a/utils/frame/try-runtime/cli/src/lib.rs b/utils/frame/try-runtime/cli/src/lib.rs
index e1873f6a04abd..733eab7f5a262 100644
--- a/utils/frame/try-runtime/cli/src/lib.rs
+++ b/utils/frame/try-runtime/cli/src/lib.rs
@@ -377,8 +377,7 @@ use sp_core::{
 		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
 	},
 	storage::well_known_keys,
-	testing::TaskExecutor,
-	traits::{CallContext, ReadRuntimeVersion, TaskExecutorExt},
+	traits::{CallContext, ReadRuntimeVersion},
 	twox_128, H256,
 };
 use sp_externalities::Extensions;
@@ -813,7 +812,6 @@ where
 /// Build all extensions that we typically use.
 pub(crate) fn full_extensions() -> Extensions {
 	let mut extensions = Extensions::default();
-	extensions.register(TaskExecutorExt::new(TaskExecutor::new()));
 	let (offchain, _offchain_state) = TestOffchainExt::new();
 	let (pool, _pool_state) = TestTransactionPoolExt::new();
 	let keystore = MemoryKeystore::new();
@@ -875,7 +873,6 @@ pub(crate) fn state_machine_call<Block: BlockT, HostFns: HostFunctions>(
 		data,
 		extensions,
 		&sp_state_machine::backend::BackendRuntimeCode::new(&ext.backend).runtime_code()?,
-		sp_core::testing::TaskExecutor::new(),
 		CallContext::Offchain,
 	)
 	.execute(sp_state_machine::ExecutionStrategy::AlwaysWasm)
@@ -915,7 +912,6 @@ pub(crate) fn state_machine_call_with_proof<Block: BlockT, HostFns: HostFunction
 		data,
 		extensions,
 		&runtime_code,
-		sp_core::testing::TaskExecutor::new(),
 		CallContext::Offchain,
 	)
 	.execute(sp_state_machine::ExecutionStrategy::AlwaysWasm)
diff --git a/utils/wasm-builder/src/wasm_project.rs b/utils/wasm-builder/src/wasm_project.rs
index d25fb4acd2345..c45a40a6b9202 100644
--- a/utils/wasm-builder/src/wasm_project.rs
+++ b/utils/wasm-builder/src/wasm_project.rs
@@ -632,7 +632,7 @@ fn build_project(
 	let mut build_cmd = cargo_cmd.command();
 
 	let rustflags = format!(
-		"-C target-cpu=mvp -C link-arg=--export-table {} {}",
+		"-C target-cpu=mvp -C target-feature=-sign-ext -C link-arg=--export-table {} {}",
 		default_rustflags,
 		env::var(crate::WASM_BUILD_RUSTFLAGS_ENV).unwrap_or_default(),
 	);