diff --git a/Cargo.lock b/Cargo.lock
index d83080868221faff7eeeb2d39e1a6cb9bc1ca7e3..196f580e0d50c098bd9d91661f343a36b36df7e9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1527,6 +1527,7 @@ checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
  "funty",
  "radium",
+ "serde",
  "tap",
  "wyz",
 ]
diff --git a/cumulus/client/relay-chain-minimal-node/src/blockchain_rpc_client.rs b/cumulus/client/relay-chain-minimal-node/src/blockchain_rpc_client.rs
index 1e78df7115435449e6beb89224f0af32f3b3b988..a473b3bced02b246c412659e5921b6a950b2086b 100644
--- a/cumulus/client/relay-chain-minimal-node/src/blockchain_rpc_client.rs
+++ b/cumulus/client/relay-chain-minimal-node/src/blockchain_rpc_client.rs
@@ -24,6 +24,7 @@ use polkadot_overseer::RuntimeApiSubsystemClient;
 use polkadot_primitives::{
 	async_backing::{AsyncBackingParams, BackingState},
 	slashing,
+	vstaging::NodeFeatures,
 };
 use sc_authority_discovery::{AuthorityDiscovery, Error as AuthorityDiscoveryError};
 use sp_api::{ApiError, RuntimeApiInfo};
@@ -364,6 +365,10 @@ impl RuntimeApiSubsystemClient for BlockChainRpcClient {
 	) -> Result<Option<BackingState>, ApiError> {
 		Ok(self.rpc_client.parachain_host_para_backing_state(at, para_id).await?)
 	}
+
+	async fn node_features(&self, at: Hash) -> Result<NodeFeatures, ApiError> {
+		Ok(self.rpc_client.parachain_host_node_features(at).await?)
+	}
 }
 
 #[async_trait::async_trait]
diff --git a/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs b/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs
index 90af334e1334fe03323f8c4124e6590daa69ba09..cc993c6ff9f6257b77a41e46e175c2fd7f752309 100644
--- a/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs
+++ b/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs
@@ -31,7 +31,9 @@ use parity_scale_codec::{Decode, Encode};
 use cumulus_primitives_core::{
 	relay_chain::{
 		async_backing::{AsyncBackingParams, BackingState},
-		slashing, BlockNumber, CandidateCommitments, CandidateEvent, CandidateHash,
+		slashing,
+		vstaging::NodeFeatures,
+		BlockNumber, CandidateCommitments, CandidateEvent, CandidateHash,
 		CommittedCandidateReceipt, CoreState, DisputeState, ExecutorParams, GroupRotationInfo,
 		Hash as RelayHash, Header as RelayHeader, InboundHrmpMessage, OccupiedCoreAssumption,
 		PvfCheckStatement, ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidationCode,
@@ -597,6 +599,14 @@ impl RelayChainRpcClient {
 			.await
 	}
 
+	pub async fn parachain_host_node_features(
+		&self,
+		at: RelayHash,
+	) -> Result<NodeFeatures, RelayChainError> {
+		self.call_remote_runtime_function("ParachainHost_node_features", at, None::<()>)
+			.await
+	}
+
 	pub async fn parachain_host_disabled_validators(
 		&self,
 		at: RelayHash,
diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs
index f806f4a5d9eb394eb0bba324bd32ee2249301ae1..7ace96147106c34af4e8a9ebfec23f59b8949928 100644
--- a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs
+++ b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs
@@ -24,7 +24,7 @@ use emulated_integration_tests_common::{
 
 // Rococo declaration
 decl_test_relay_chains! {
-	#[api_version(8)]
+	#[api_version(9)]
 	pub struct Rococo {
 		genesis = genesis::genesis(),
 		on_init = (),
diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs
index d4ba1b6cfe72cf463b4e42704ac2643196f9f22b..2ba47250d564e1c487829d4afa034b1bf0770f67 100644
--- a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs
+++ b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs
@@ -24,7 +24,7 @@ use emulated_integration_tests_common::{
 
 // Westend declaration
 decl_test_relay_chains! {
-	#[api_version(8)]
+	#[api_version(9)]
 	pub struct Westend {
 		genesis = genesis::genesis(),
 		on_init = (),
diff --git a/polkadot/node/core/runtime-api/src/cache.rs b/polkadot/node/core/runtime-api/src/cache.rs
index 69eea22b23bda4d8c67543c535c5f80afd81703d..8a7a3dc08b8173e7029158d3a0ca6030d898e3f7 100644
--- a/polkadot/node/core/runtime-api/src/cache.rs
+++ b/polkadot/node/core/runtime-api/src/cache.rs
@@ -20,7 +20,7 @@ use schnellru::{ByLength, LruMap};
 use sp_consensus_babe::Epoch;
 
 use polkadot_primitives::{
-	async_backing, slashing, AuthorityDiscoveryId, BlockNumber, CandidateCommitments,
+	async_backing, slashing, vstaging, AuthorityDiscoveryId, BlockNumber, CandidateCommitments,
 	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState,
 	ExecutorParams, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage,
 	InboundHrmpMessage, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement,
@@ -67,6 +67,7 @@ pub(crate) struct RequestResultCache {
 	disabled_validators: LruMap<Hash, Vec<ValidatorIndex>>,
 	para_backing_state: LruMap<(Hash, ParaId), Option<async_backing::BackingState>>,
 	async_backing_params: LruMap<Hash, async_backing::AsyncBackingParams>,
+	node_features: LruMap<SessionIndex, vstaging::NodeFeatures>,
 }
 
 impl Default for RequestResultCache {
@@ -100,6 +101,7 @@ impl Default for RequestResultCache {
 			disabled_validators: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
 			para_backing_state: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
 			async_backing_params: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
+			node_features: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
 		}
 	}
 }
@@ -446,6 +448,21 @@ impl RequestResultCache {
 		self.minimum_backing_votes.insert(session_index, minimum_backing_votes);
 	}
 
+	pub(crate) fn node_features(
+		&mut self,
+		session_index: SessionIndex,
+	) -> Option<&vstaging::NodeFeatures> {
+		self.node_features.get(&session_index).map(|f| &*f)
+	}
+
+	pub(crate) fn cache_node_features(
+		&mut self,
+		session_index: SessionIndex,
+		features: vstaging::NodeFeatures,
+	) {
+		self.node_features.insert(session_index, features);
+	}
+
 	pub(crate) fn disabled_validators(
 		&mut self,
 		relay_parent: &Hash,
@@ -540,4 +557,5 @@ pub(crate) enum RequestResult {
 	DisabledValidators(Hash, Vec<ValidatorIndex>),
 	ParaBackingState(Hash, ParaId, Option<async_backing::BackingState>),
 	AsyncBackingParams(Hash, async_backing::AsyncBackingParams),
+	NodeFeatures(SessionIndex, vstaging::NodeFeatures),
 }
diff --git a/polkadot/node/core/runtime-api/src/lib.rs b/polkadot/node/core/runtime-api/src/lib.rs
index bdcca08b10dda6fed122e482e5ac015beb2a29bb..8689355c4139af263d393cdd46d62f17abde66c1 100644
--- a/polkadot/node/core/runtime-api/src/lib.rs
+++ b/polkadot/node/core/runtime-api/src/lib.rs
@@ -173,6 +173,8 @@ where
 				.cache_para_backing_state((relay_parent, para_id), constraints),
 			AsyncBackingParams(relay_parent, params) =>
 				self.requests_cache.cache_async_backing_params(relay_parent, params),
+			NodeFeatures(session_index, params) =>
+				self.requests_cache.cache_node_features(session_index, params),
 		}
 	}
 
@@ -313,6 +315,15 @@ where
 					Some(Request::MinimumBackingVotes(index, sender))
 				}
 			},
+			Request::NodeFeatures(index, sender) => {
+				if let Some(value) = self.requests_cache.node_features(index) {
+					self.metrics.on_cached_request();
+					let _ = sender.send(Ok(value.clone()));
+					None
+				} else {
+					Some(Request::NodeFeatures(index, sender))
+				}
+			},
 		}
 	}
 
@@ -408,6 +419,9 @@ where
 
 	macro_rules! query {
 		($req_variant:ident, $api_name:ident ($($param:expr),*), ver = $version:expr, $sender:expr) => {{
+			query!($req_variant, $api_name($($param),*), ver = $version, $sender, result = ( relay_parent $(, $param )* ) )
+		}};
+		($req_variant:ident, $api_name:ident ($($param:expr),*), ver = $version:expr, $sender:expr, result = ( $($results:expr),* ) ) => {{
 			let sender = $sender;
 			let version: u32 = $version;	// enforce type for the version expression
 			let runtime_version = client.api_version_parachain_host(relay_parent).await
@@ -441,7 +455,7 @@ where
 			metrics.on_request(res.is_ok());
 			let _ = sender.send(res.clone());
 
-			res.ok().map(|res| RequestResult::$req_variant(relay_parent, $( $param, )* res))
+			res.ok().map(|res| RequestResult::$req_variant($( $results, )* res))
 		}}
 	}
 
@@ -591,5 +605,12 @@ where
 				sender
 			)
 		},
+		Request::NodeFeatures(index, sender) => query!(
+			NodeFeatures,
+			node_features(),
+			ver = Request::NODE_FEATURES_RUNTIME_REQUIREMENT,
+			sender,
+			result = (index)
+		),
 	}
 }
diff --git a/polkadot/node/core/runtime-api/src/tests.rs b/polkadot/node/core/runtime-api/src/tests.rs
index 979b3587d2692149d0d5927e80fea79f2618b0a0..b939bffb0e7f8c896c35f51d75ffa9e43e60df79 100644
--- a/polkadot/node/core/runtime-api/src/tests.rs
+++ b/polkadot/node/core/runtime-api/src/tests.rs
@@ -20,12 +20,12 @@ use polkadot_node_primitives::{BabeAllowedSlots, BabeEpoch, BabeEpochConfigurati
 use polkadot_node_subsystem::SpawnGlue;
 use polkadot_node_subsystem_test_helpers::make_subsystem_context;
 use polkadot_primitives::{
-	async_backing, slashing, AuthorityDiscoveryId, BlockNumber, CandidateCommitments,
-	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState,
-	ExecutorParams, GroupRotationInfo, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage,
-	OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement, ScrapedOnChainVotes,
-	SessionIndex, SessionInfo, Slot, ValidationCode, ValidationCodeHash, ValidatorId,
-	ValidatorIndex, ValidatorSignature,
+	async_backing, slashing, vstaging::NodeFeatures, AuthorityDiscoveryId, BlockNumber,
+	CandidateCommitments, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState,
+	DisputeState, ExecutorParams, GroupRotationInfo, Id as ParaId, InboundDownwardMessage,
+	InboundHrmpMessage, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement,
+	ScrapedOnChainVotes, SessionIndex, SessionInfo, Slot, ValidationCode, ValidationCodeHash,
+	ValidatorId, ValidatorIndex, ValidatorSignature,
 };
 use sp_api::ApiError;
 use sp_core::testing::TaskExecutor;
@@ -269,6 +269,10 @@ impl RuntimeApiSubsystemClient for MockSubsystemClient {
 		todo!("Not required for tests")
 	}
 
+	async fn node_features(&self, _: Hash) -> Result<NodeFeatures, ApiError> {
+		todo!("Not required for tests")
+	}
+
 	async fn disabled_validators(&self, _: Hash) -> Result<Vec<ValidatorIndex>, ApiError> {
 		todo!("Not required for tests")
 	}
diff --git a/polkadot/node/subsystem-types/src/messages.rs b/polkadot/node/subsystem-types/src/messages.rs
index 4ddffc6dc5e830e056a2cab202c33a0b29f8040b..43456daec302917471b4e1df1aa5234ad993f892 100644
--- a/polkadot/node/subsystem-types/src/messages.rs
+++ b/polkadot/node/subsystem-types/src/messages.rs
@@ -42,12 +42,12 @@ use polkadot_node_primitives::{
 	ValidationResult,
 };
 use polkadot_primitives::{
-	async_backing, slashing, AuthorityDiscoveryId, BackedCandidate, BlockNumber, CandidateEvent,
-	CandidateHash, CandidateIndex, CandidateReceipt, CollatorId, CommittedCandidateReceipt,
-	CoreState, DisputeState, ExecutorParams, GroupIndex, GroupRotationInfo, Hash,
-	Header as BlockHeader, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage,
-	MultiDisputeStatementSet, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement,
-	PvfExecTimeoutKind, SessionIndex, SessionInfo, SignedAvailabilityBitfield,
+	async_backing, slashing, vstaging::NodeFeatures, AuthorityDiscoveryId, BackedCandidate,
+	BlockNumber, CandidateEvent, CandidateHash, CandidateIndex, CandidateReceipt, CollatorId,
+	CommittedCandidateReceipt, CoreState, DisputeState, ExecutorParams, GroupIndex,
+	GroupRotationInfo, Hash, Header as BlockHeader, Id as ParaId, InboundDownwardMessage,
+	InboundHrmpMessage, MultiDisputeStatementSet, OccupiedCoreAssumption, PersistedValidationData,
+	PvfCheckStatement, PvfExecTimeoutKind, SessionIndex, SessionInfo, SignedAvailabilityBitfield,
 	SignedAvailabilityBitfields, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
 	ValidatorSignature,
 };
@@ -718,6 +718,8 @@ pub enum RuntimeApiRequest {
 	///
 	/// If it's not supported by the Runtime, the async backing is said to be disabled.
 	AsyncBackingParams(RuntimeApiSender<async_backing::AsyncBackingParams>),
+	/// Get the node features.
+	NodeFeatures(SessionIndex, RuntimeApiSender<NodeFeatures>),
 }
 
 impl RuntimeApiRequest {
@@ -746,6 +748,9 @@ impl RuntimeApiRequest {
 
 	/// `DisabledValidators`
 	pub const DISABLED_VALIDATORS_RUNTIME_REQUIREMENT: u32 = 8;
+
+	/// `Node features`
+	pub const NODE_FEATURES_RUNTIME_REQUIREMENT: u32 = 9;
 }
 
 /// A message to the Runtime API subsystem.
diff --git a/polkadot/node/subsystem-types/src/runtime_client.rs b/polkadot/node/subsystem-types/src/runtime_client.rs
index f7adcf9862b5d09829cb1d0edbb3f068b9c55713..8369fd215f4f05e7e165e5d0629a187cf0202029 100644
--- a/polkadot/node/subsystem-types/src/runtime_client.rs
+++ b/polkadot/node/subsystem-types/src/runtime_client.rs
@@ -16,12 +16,12 @@
 
 use async_trait::async_trait;
 use polkadot_primitives::{
-	async_backing, runtime_api::ParachainHost, slashing, Block, BlockNumber, CandidateCommitments,
-	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState,
-	ExecutorParams, GroupRotationInfo, Hash, Id, InboundDownwardMessage, InboundHrmpMessage,
-	OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement, ScrapedOnChainVotes,
-	SessionIndex, SessionInfo, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
-	ValidatorSignature,
+	async_backing, runtime_api::ParachainHost, slashing, vstaging, Block, BlockNumber,
+	CandidateCommitments, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState,
+	DisputeState, ExecutorParams, GroupRotationInfo, Hash, Id, InboundDownwardMessage,
+	InboundHrmpMessage, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement,
+	ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidationCode, ValidationCodeHash,
+	ValidatorId, ValidatorIndex, ValidatorSignature,
 };
 use sc_transaction_pool_api::OffchainTransactionPoolFactory;
 use sp_api::{ApiError, ApiExt, ProvideRuntimeApi};
@@ -257,8 +257,14 @@ pub trait RuntimeApiSubsystemClient {
 	) -> Result<Option<async_backing::BackingState>, ApiError>;
 
 	// === v8 ===
+
 	/// Gets the disabled validators at a specific block height
 	async fn disabled_validators(&self, at: Hash) -> Result<Vec<ValidatorIndex>, ApiError>;
+
+	// === v9 ===
+
+	/// Get the node features.
+	async fn node_features(&self, at: Hash) -> Result<vstaging::NodeFeatures, ApiError>;
 }
 
 /// Default implementation of [`RuntimeApiSubsystemClient`] using the client.
@@ -508,6 +514,10 @@ where
 		self.client.runtime_api().async_backing_params(at)
 	}
 
+	async fn node_features(&self, at: Hash) -> Result<vstaging::NodeFeatures, ApiError> {
+		self.client.runtime_api().node_features(at)
+	}
+
 	async fn disabled_validators(&self, at: Hash) -> Result<Vec<ValidatorIndex>, ApiError> {
 		self.client.runtime_api().disabled_validators(at)
 	}
diff --git a/polkadot/node/subsystem-util/src/runtime/mod.rs b/polkadot/node/subsystem-util/src/runtime/mod.rs
index 8d7cef88a70e082779cd6e0892502f27e486c7c6..aada7a5d77abb5470294e220604a7b4e0c523773 100644
--- a/polkadot/node/subsystem-util/src/runtime/mod.rs
+++ b/polkadot/node/subsystem-util/src/runtime/mod.rs
@@ -30,8 +30,8 @@ use polkadot_node_subsystem::{
 };
 use polkadot_node_subsystem_types::UnpinHandle;
 use polkadot_primitives::{
-	slashing, AsyncBackingParams, CandidateEvent, CandidateHash, CoreState, EncodeAs,
-	ExecutorParams, GroupIndex, GroupRotationInfo, Hash, IndexedVec, OccupiedCore,
+	slashing, vstaging::NodeFeatures, AsyncBackingParams, CandidateEvent, CandidateHash, CoreState,
+	EncodeAs, ExecutorParams, GroupIndex, GroupRotationInfo, Hash, IndexedVec, OccupiedCore,
 	ScrapedOnChainVotes, SessionIndex, SessionInfo, Signed, SigningContext, UncheckedSigned,
 	ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, LEGACY_MIN_BACKING_VOTES,
 };
@@ -507,3 +507,32 @@ pub async fn request_min_backing_votes(
 		min_backing_votes_res
 	}
 }
+
+/// Request the node features enabled in the runtime.
+/// Pass in the session index for caching purposes, as it should only change on session boundaries.
+/// Prior to runtime API version 9, just return `None`.
+pub async fn request_node_features(
+	parent: Hash,
+	session_index: SessionIndex,
+	sender: &mut impl overseer::SubsystemSender<RuntimeApiMessage>,
+) -> Result<Option<NodeFeatures>> {
+	let res = recv_runtime(
+		request_from_runtime(parent, sender, |tx| {
+			RuntimeApiRequest::NodeFeatures(session_index, tx)
+		})
+		.await,
+	)
+	.await;
+
+	if let Err(Error::RuntimeRequest(RuntimeApiError::NotSupported { .. })) = res {
+		gum::trace!(
+			target: LOG_TARGET,
+			?parent,
+			"Querying the node features from the runtime is not supported by the current Runtime API",
+		);
+
+		Ok(None)
+	} else {
+		res.map(Some)
+	}
+}
diff --git a/polkadot/primitives/Cargo.toml b/polkadot/primitives/Cargo.toml
index b318c2d4be7ed5df3f1885dda9bc5b94138415c8..316644a372d60519b4568c3f27310bf935f90643 100644
--- a/polkadot/primitives/Cargo.toml
+++ b/polkadot/primitives/Cargo.toml
@@ -7,7 +7,7 @@ license.workspace = true
 description = "Shared primitives used by Polkadot runtime"
 
 [dependencies]
-bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
+bitvec = { version = "1.0.0", default-features = false, features = ["alloc", "serde"] }
 hex-literal = "0.4.1"
 parity-scale-codec = { version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] }
 scale-info = { version = "2.10.0", default-features = false, features = ["bit-vec", "derive", "serde"] }
diff --git a/polkadot/primitives/src/runtime_api.rs b/polkadot/primitives/src/runtime_api.rs
index 5ec897c8cbb40a7b3fe6a36ead8c72d3479b13e2..e4c1d590f4573a676c02630fd83d0c3b46bfafe1 100644
--- a/polkadot/primitives/src/runtime_api.rs
+++ b/polkadot/primitives/src/runtime_api.rs
@@ -114,10 +114,10 @@
 //! separated from the stable primitives.
 
 use crate::{
-	async_backing, slashing, AsyncBackingParams, BlockNumber, CandidateCommitments, CandidateEvent,
-	CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState, ExecutorParams,
-	GroupRotationInfo, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement,
-	ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidatorId, ValidatorIndex,
+	async_backing, slashing, vstaging, AsyncBackingParams, BlockNumber, CandidateCommitments,
+	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState,
+	ExecutorParams, GroupRotationInfo, OccupiedCoreAssumption, PersistedValidationData,
+	PvfCheckStatement, ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidatorId, ValidatorIndex,
 	ValidatorSignature,
 };
 use parity_scale_codec::{Decode, Encode};
@@ -264,5 +264,12 @@ sp_api::decl_runtime_apis! {
 		/// Returns a list of all disabled validators at the given block.
 		#[api_version(8)]
 		fn disabled_validators() -> Vec<ValidatorIndex>;
+
+		/***** Added in v9 *****/
+
+		/// Get node features.
+		/// This is a staging method! Do not use on production runtimes!
+		#[api_version(9)]
+		fn node_features() -> vstaging::NodeFeatures;
 	}
 }
diff --git a/polkadot/primitives/src/vstaging/mod.rs b/polkadot/primitives/src/vstaging/mod.rs
index 1429b0c326aceef4b9088bd4ddef6828f8dcfbd8..083e0f42d56468b4cdc0e8b6adeb656c6a61a1ff 100644
--- a/polkadot/primitives/src/vstaging/mod.rs
+++ b/polkadot/primitives/src/vstaging/mod.rs
@@ -17,3 +17,8 @@
 //! Staging Primitives.
 
 // Put any primitives used by staging APIs functions here
+
+use bitvec::vec::BitVec;
+
+/// Bit indices in the `HostConfiguration.node_features` that correspond to different node features.
+pub type NodeFeatures = BitVec<u8, bitvec::order::Lsb0>;
diff --git a/polkadot/runtime/parachains/src/configuration.rs b/polkadot/runtime/parachains/src/configuration.rs
index d85c267496f425b32702e6f5d9ed4fc8a7275c99..bff9cc34b4fbb84c8e2b4add40d082ca3fcbbe91 100644
--- a/polkadot/runtime/parachains/src/configuration.rs
+++ b/polkadot/runtime/parachains/src/configuration.rs
@@ -26,8 +26,8 @@ use polkadot_parachain_primitives::primitives::{
 	MAX_HORIZONTAL_MESSAGE_NUM, MAX_UPWARD_MESSAGE_NUM,
 };
 use primitives::{
-	AsyncBackingParams, Balance, ExecutorParamError, ExecutorParams, SessionIndex,
-	LEGACY_MIN_BACKING_VOTES, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MAX_POV_SIZE,
+	vstaging::NodeFeatures, AsyncBackingParams, Balance, ExecutorParamError, ExecutorParams,
+	SessionIndex, LEGACY_MIN_BACKING_VOTES, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MAX_POV_SIZE,
 	ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
 };
 use sp_runtime::{traits::Zero, Perbill};
@@ -261,6 +261,8 @@ pub struct HostConfiguration<BlockNumber> {
 	/// The minimum number of valid backing statements required to consider a parachain candidate
 	/// backable.
 	pub minimum_backing_votes: u32,
+	/// Node features enablement.
+	pub node_features: NodeFeatures,
 }
 
 impl<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber> {
@@ -312,6 +314,7 @@ impl<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber
 			on_demand_target_queue_utilization: Perbill::from_percent(25),
 			on_demand_ttl: 5u32.into(),
 			minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
+			node_features: NodeFeatures::EMPTY,
 		}
 	}
 }
@@ -463,6 +466,7 @@ pub trait WeightInfo {
 	fn set_hrmp_open_request_ttl() -> Weight;
 	fn set_config_with_executor_params() -> Weight;
 	fn set_config_with_perbill() -> Weight;
+	fn set_node_feature() -> Weight;
 }
 
 pub struct TestWeightInfo;
@@ -488,6 +492,9 @@ impl WeightInfo for TestWeightInfo {
 	fn set_config_with_perbill() -> Weight {
 		Weight::MAX
 	}
+	fn set_node_feature() -> Weight {
+		Weight::MAX
+	}
 }
 
 #[frame_support::pallet]
@@ -496,18 +503,19 @@ pub mod pallet {
 
 	/// The current storage version.
 	///
-	/// v0-v1: <https://github.com/paritytech/polkadot/pull/3575>
-	/// v1-v2: <https://github.com/paritytech/polkadot/pull/4420>
-	/// v2-v3: <https://github.com/paritytech/polkadot/pull/6091>
-	/// v3-v4: <https://github.com/paritytech/polkadot/pull/6345>
-	/// v4-v5: <https://github.com/paritytech/polkadot/pull/6937>
-	///      + <https://github.com/paritytech/polkadot/pull/6961>
-	///      + <https://github.com/paritytech/polkadot/pull/6934>
-	/// v5-v6: <https://github.com/paritytech/polkadot/pull/6271> (remove UMP dispatch queue)
-	/// v6-v7: <https://github.com/paritytech/polkadot/pull/7396>
-	/// v7-v8: <https://github.com/paritytech/polkadot/pull/6969>
-	/// v8-v9: <https://github.com/paritytech/polkadot/pull/7577>
-	const STORAGE_VERSION: StorageVersion = StorageVersion::new(9);
+	/// v0-v1:  <https://github.com/paritytech/polkadot/pull/3575>
+	/// v1-v2:  <https://github.com/paritytech/polkadot/pull/4420>
+	/// v2-v3:  <https://github.com/paritytech/polkadot/pull/6091>
+	/// v3-v4:  <https://github.com/paritytech/polkadot/pull/6345>
+	/// v4-v5:  <https://github.com/paritytech/polkadot/pull/6937>
+	///       + <https://github.com/paritytech/polkadot/pull/6961>
+	///       + <https://github.com/paritytech/polkadot/pull/6934>
+	/// v5-v6:  <https://github.com/paritytech/polkadot/pull/6271> (remove UMP dispatch queue)
+	/// v6-v7:  <https://github.com/paritytech/polkadot/pull/7396>
+	/// v7-v8:  <https://github.com/paritytech/polkadot/pull/6969>
+	/// v8-v9:  <https://github.com/paritytech/polkadot/pull/7577>
+	/// v9-v10: <https://github.com/paritytech/polkadot-sdk/pull/2177>
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(10);
 
 	#[pallet::pallet]
 	#[pallet::storage_version(STORAGE_VERSION)]
@@ -1195,6 +1203,23 @@ pub mod pallet {
 				config.minimum_backing_votes = new;
 			})
 		}
+		/// Set/Unset a node feature.
+		#[pallet::call_index(53)]
+		#[pallet::weight((
+			T::WeightInfo::set_node_feature(),
+			DispatchClass::Operational
+		))]
+		pub fn set_node_feature(origin: OriginFor<T>, index: u8, value: bool) -> DispatchResult {
+			ensure_root(origin)?;
+
+			Self::schedule_config_update(|config| {
+				let index = usize::from(index);
+				if config.node_features.len() <= index {
+					config.node_features.resize(index + 1, false);
+				}
+				config.node_features.set(index, value);
+			})
+		}
 	}
 
 	#[pallet::hooks]
diff --git a/polkadot/runtime/parachains/src/configuration/benchmarking.rs b/polkadot/runtime/parachains/src/configuration/benchmarking.rs
index d9d11ab56e496980e8090a99ed88452a351e970e..508e0579a09dacbb200f01ccb571340f582b7dcd 100644
--- a/polkadot/runtime/parachains/src/configuration/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/configuration/benchmarking.rs
@@ -49,6 +49,8 @@ benchmarks! {
 
 	set_config_with_perbill {}: set_on_demand_fee_variability(RawOrigin::Root, Perbill::from_percent(100))
 
+	set_node_feature{}: set_node_feature(RawOrigin::Root, 255, true)
+
 	impl_benchmark_test_suite!(
 		Pallet,
 		crate::mock::new_test_ext(Default::default()),
diff --git a/polkadot/runtime/parachains/src/configuration/migration.rs b/polkadot/runtime/parachains/src/configuration/migration.rs
index 26f8a85b496d5a76385c6c85b52f66d719d88c82..db323d3aad93358eeecb133aaf63257d7c973c3a 100644
--- a/polkadot/runtime/parachains/src/configuration/migration.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration.rs
@@ -16,6 +16,7 @@
 
 //! A module that is responsible for migration of storage.
 
+pub mod v10;
 pub mod v6;
 pub mod v7;
 pub mod v8;
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v10.rs b/polkadot/runtime/parachains/src/configuration/migration/v10.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c934082dc1e43095b3729347eafccde032427f1
--- /dev/null
+++ b/polkadot/runtime/parachains/src/configuration/migration/v10.rs
@@ -0,0 +1,277 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{self, Config, Pallet};
+use frame_support::{pallet_prelude::*, traits::Defensive, weights::Weight};
+use frame_system::pallet_prelude::BlockNumberFor;
+use primitives::{vstaging::NodeFeatures, SessionIndex};
+use sp_std::vec::Vec;
+
+use frame_support::traits::OnRuntimeUpgrade;
+
+use super::v9::V9HostConfiguration;
+
+type V10HostConfiguration<BlockNumber> = configuration::HostConfiguration<BlockNumber>;
+
+mod v9 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V9HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V9HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v10 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V10HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V10HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub struct VersionUncheckedMigrateToV10<T>(sp_std::marker::PhantomData<T>);
+impl<T: Config> OnRuntimeUpgrade for VersionUncheckedMigrateToV10<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV10");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		migrate_to_v10::<T>()
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV10");
+		ensure!(
+			Pallet::<T>::on_chain_storage_version() >= StorageVersion::new(10),
+			"Storage version should be >= 10 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+pub type MigrateToV10<T> = frame_support::migrations::VersionedMigration<
+	9,
+	10,
+	VersionUncheckedMigrateToV10<T>,
+	Pallet<T>,
+	<T as frame_system::Config>::DbWeight,
+>;
+
+// Unusual formatting is justified:
+// - make it easier to verify that fields assign what they supposed to assign.
+// - this code is transient and will be removed after all migrations are done.
+// - this code is important enough to optimize for legibility sacrificing consistency.
+#[rustfmt::skip]
+fn translate<T: Config>(pre: V9HostConfiguration<BlockNumberFor<T>>) -> V10HostConfiguration<BlockNumberFor<T>> {
+	V10HostConfiguration {
+		max_code_size                            : pre.max_code_size,
+		max_head_data_size                       : pre.max_head_data_size,
+		max_upward_queue_count                   : pre.max_upward_queue_count,
+		max_upward_queue_size                    : pre.max_upward_queue_size,
+		max_upward_message_size                  : pre.max_upward_message_size,
+		max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+		hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+		validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+		validation_upgrade_delay                 : pre.validation_upgrade_delay,
+		max_pov_size                             : pre.max_pov_size,
+		max_downward_message_size                : pre.max_downward_message_size,
+		hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+		hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+		hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+		hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+		hrmp_max_parachain_inbound_channels      : pre.hrmp_max_parachain_inbound_channels,
+		hrmp_max_parachain_outbound_channels     : pre.hrmp_max_parachain_outbound_channels,
+		hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+		code_retention_period                    : pre.code_retention_period,
+		on_demand_cores                          : pre.on_demand_cores,
+		on_demand_retries                        : pre.on_demand_retries,
+		group_rotation_frequency                 : pre.group_rotation_frequency,
+		paras_availability_period                : pre.paras_availability_period,
+		scheduling_lookahead                     : pre.scheduling_lookahead,
+		max_validators_per_core                  : pre.max_validators_per_core,
+		max_validators                           : pre.max_validators,
+		dispute_period                           : pre.dispute_period,
+		dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+		no_show_slots                            : pre.no_show_slots,
+		n_delay_tranches                         : pre.n_delay_tranches,
+		zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+		needed_approvals                         : pre.needed_approvals,
+		relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+		pvf_voting_ttl                           : pre.pvf_voting_ttl,
+		minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+		async_backing_params                     : pre.async_backing_params,
+		executor_params                          : pre.executor_params,
+		on_demand_queue_max_size                 : pre.on_demand_queue_max_size,
+		on_demand_base_fee                       : pre.on_demand_base_fee,
+		on_demand_fee_variability                : pre.on_demand_fee_variability,
+		on_demand_target_queue_utilization       : pre.on_demand_target_queue_utilization,
+		on_demand_ttl                            : pre.on_demand_ttl,
+		minimum_backing_votes                    : pre.minimum_backing_votes,
+		node_features                            : NodeFeatures::EMPTY
+	}
+}
+
+fn migrate_to_v10<T: Config>() -> Weight {
+	let v9 = v9::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v10 = translate::<T>(v9);
+	v10::ActiveConfig::<T>::set(Some(v10));
+
+	// Allowed to be empty.
+	let pending_v9 = v9::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v10 = Vec::new();
+
+	for (session, v9) in pending_v9.into_iter() {
+		let v10 = translate::<T>(v9);
+		pending_v10.push((session, v10));
+	}
+	v10::PendingConfigs::<T>::set(Some(pending_v10.clone()));
+
+	let num_configs = (pending_v10.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+	use primitives::LEGACY_MIN_BACKING_VOTES;
+
+	#[test]
+	fn v10_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Polkadot.js -> Developer -> Chain state -> Storage: https://polkadot.js.org/apps/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		//        PolkadotRuntimeParachainsConfigurationHostConfiguration
+		//   2.2. blockhash to query at:
+		//        0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
+		//        the block)
+		//   2.3. Note the value of encoded storage key ->
+		//        0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
+		// referenced        block.
+		//   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Polkadot.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config =
+	hex_literal::hex!["
+	0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000000000000000001027000080b2e60e80c3c90180969800000000000000000000000000050000001400000004000000010000000101000000000600000064000000020000001900000000000000020000000200000002000000050000000200000000"
+	];
+
+		let v10 =
+			V10HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v10.max_code_size, 3_145_728);
+		assert_eq!(v10.validation_upgrade_cooldown, 2);
+		assert_eq!(v10.max_pov_size, 5_242_880);
+		assert_eq!(v10.hrmp_channel_max_message_size, 1_048_576);
+		assert_eq!(v10.n_delay_tranches, 25);
+		assert_eq!(v10.minimum_validation_upgrade_delay, 5);
+		assert_eq!(v10.group_rotation_frequency, 20);
+		assert_eq!(v10.on_demand_cores, 0);
+		assert_eq!(v10.on_demand_base_fee, 10_000_000);
+		assert_eq!(v10.minimum_backing_votes, LEGACY_MIN_BACKING_VOTES);
+		assert_eq!(v10.node_features, NodeFeatures::EMPTY);
+	}
+
+	// Test that `migrate_to_v10`` correctly applies the `translate` function to current and pending
+	// configs.
+	#[test]
+	fn test_migrate_to_v10() {
+		// Host configuration has lots of fields. However, in this migration we only add one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v9 = V9HostConfiguration::<primitives::BlockNumber> {
+			needed_approvals: 69,
+			paras_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			minimum_validation_upgrade_delay: 20,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v9.clone()));
+		pending_configs.push((300, v9.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v9 version in the state.
+			v9::ActiveConfig::<Test>::set(Some(v9.clone()));
+			v9::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v10::<Test>();
+
+			let v10 = translate::<Test>(v9);
+			let mut configs_to_check = v10::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v10::ActiveConfig::<Test>::get().unwrap()));
+
+			for (_, config) in configs_to_check {
+				assert_eq!(config, v10);
+				assert_eq!(config.node_features, NodeFeatures::EMPTY);
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there're no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v10_no_pending() {
+		let v9 = V9HostConfiguration::<primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v9 version in the state.
+			v9::ActiveConfig::<Test>::set(Some(v9));
+			// Ensure there're no pending configs.
+			v9::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v10::<Test>();
+		});
+	}
+}
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v9.rs b/polkadot/runtime/parachains/src/configuration/migration/v9.rs
index e37f0b9b0e3d06801cbede3e99b143ee132b6a36..ca4bbd9dacef3fb645c41a060798e0298a0efc27 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v9.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v9.rs
@@ -23,13 +23,116 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{SessionIndex, LEGACY_MIN_BACKING_VOTES};
+use primitives::{
+	AsyncBackingParams, Balance, ExecutorParams, SessionIndex, LEGACY_MIN_BACKING_VOTES,
+	ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+};
+use sp_runtime::Perbill;
 use sp_std::vec::Vec;
 
 use frame_support::traits::OnRuntimeUpgrade;
 
 use super::v8::V8HostConfiguration;
-type V9HostConfiguration<BlockNumber> = configuration::HostConfiguration<BlockNumber>;
+/// All configuration of the runtime with respect to paras.
+#[derive(Clone, Encode, Decode, Debug)]
+pub struct V9HostConfiguration<BlockNumber> {
+	pub max_code_size: u32,
+	pub max_head_data_size: u32,
+	pub max_upward_queue_count: u32,
+	pub max_upward_queue_size: u32,
+	pub max_upward_message_size: u32,
+	pub max_upward_message_num_per_candidate: u32,
+	pub hrmp_max_message_num_per_candidate: u32,
+	pub validation_upgrade_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_parachain_outbound_channels: u32,
+	pub hrmp_sender_deposit: Balance,
+	pub hrmp_recipient_deposit: Balance,
+	pub hrmp_channel_max_capacity: u32,
+	pub hrmp_channel_max_total_size: u32,
+	pub hrmp_max_parachain_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	pub code_retention_period: BlockNumber,
+	pub on_demand_cores: u32,
+	pub on_demand_retries: u32,
+	pub on_demand_queue_max_size: u32,
+	pub on_demand_target_queue_utilization: Perbill,
+	pub on_demand_fee_variability: Perbill,
+	pub on_demand_base_fee: Balance,
+	pub on_demand_ttl: BlockNumber,
+	pub group_rotation_frequency: BlockNumber,
+	pub paras_availability_period: BlockNumber,
+	pub scheduling_lookahead: u32,
+	pub max_validators_per_core: Option<u32>,
+	pub max_validators: Option<u32>,
+	pub dispute_period: SessionIndex,
+	pub dispute_post_conclusion_acceptance_period: BlockNumber,
+	pub no_show_slots: u32,
+	pub n_delay_tranches: u32,
+	pub zeroth_delay_tranche_width: u32,
+	pub needed_approvals: u32,
+	pub relay_vrf_modulo_samples: u32,
+	pub pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+	pub minimum_backing_votes: u32,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V9HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			paras_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			on_demand_cores: Default::default(),
+			on_demand_retries: Default::default(),
+			scheduling_lookahead: 1,
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_parachain_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_parachain_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+			on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+			on_demand_base_fee: 10_000_000u128,
+			on_demand_fee_variability: Perbill::from_percent(3),
+			on_demand_target_queue_utilization: Perbill::from_percent(25),
+			on_demand_ttl: 5u32.into(),
+			minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
+		}
+	}
+}
 
 mod v8 {
 	use super::*;
diff --git a/polkadot/runtime/parachains/src/configuration/tests.rs b/polkadot/runtime/parachains/src/configuration/tests.rs
index ea39628c95876a92b9072bd5adc18584e48df0b5..b62a45355e1dfb486baa3585242bcce1b26fdd12 100644
--- a/polkadot/runtime/parachains/src/configuration/tests.rs
+++ b/polkadot/runtime/parachains/src/configuration/tests.rs
@@ -16,6 +16,7 @@
 
 use super::*;
 use crate::mock::{new_test_ext, Configuration, ParasShared, RuntimeOrigin, Test};
+use bitvec::{bitvec, prelude::Lsb0};
 use frame_support::{assert_err, assert_noop, assert_ok};
 
 fn on_new_session(session_index: SessionIndex) -> (HostConfiguration<u32>, HostConfiguration<u32>) {
@@ -318,6 +319,7 @@ fn setting_pending_config_members() {
 			on_demand_target_queue_utilization: Perbill::from_percent(25),
 			on_demand_ttl: 5u32,
 			minimum_backing_votes: 5,
+			node_features: bitvec![u8, Lsb0; 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
 		};
 
 		Configuration::set_validation_upgrade_cooldown(
@@ -473,6 +475,12 @@ fn setting_pending_config_members() {
 			new_config.minimum_backing_votes,
 		)
 		.unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 1, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 1, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 3, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 10, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 10, false).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 11, true).unwrap();
 
 		assert_eq!(PendingConfigs::<Test>::get(), vec![(shared::SESSION_DELAY, new_config)],);
 	})
diff --git a/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs b/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs
index 24a076f3a44310990d61ad0076db39f4deb8f9e5..200fd57915f9b8ac03fd8241e6b2e69d4194bad0 100644
--- a/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs
+++ b/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs
@@ -16,8 +16,8 @@
 
 //! Put implementations of functions from staging APIs here.
 
-use crate::shared;
-use primitives::ValidatorIndex;
+use crate::{configuration, initializer, shared};
+use primitives::{vstaging::NodeFeatures, ValidatorIndex};
 use sp_std::{collections::btree_map::BTreeMap, prelude::Vec};
 
 /// Implementation for `DisabledValidators`
@@ -42,3 +42,8 @@ where
 		.filter_map(|v| reverse_index.get(v).cloned())
 		.collect()
 }
+
+/// Returns the current state of the node features.
+pub fn node_features<T: initializer::Config>() -> NodeFeatures {
+	<configuration::Pallet<T>>::config().node_features
+}
diff --git a/polkadot/runtime/rococo/src/lib.rs b/polkadot/runtime/rococo/src/lib.rs
index 40ef22107a7c7c6e06fb9bce6afa6d51e0d1ef41..5a1e170862e2dfa5a312bb1831c8f6cfa1aa04b5 100644
--- a/polkadot/runtime/rococo/src/lib.rs
+++ b/polkadot/runtime/rococo/src/lib.rs
@@ -23,11 +23,12 @@
 use pallet_nis::WithMaximumOf;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use primitives::{
-	slashing, AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash,
-	CommittedCandidateReceipt, CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash,
-	Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment, Nonce,
-	OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes, SessionInfo, Signature,
-	ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, PARACHAIN_KEY_TYPE_ID,
+	slashing, vstaging::NodeFeatures, AccountId, AccountIndex, Balance, BlockNumber,
+	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState,
+	ExecutorParams, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage,
+	InboundHrmpMessage, Moment, Nonce, OccupiedCoreAssumption, PersistedValidationData,
+	ScrapedOnChainVotes, SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId,
+	ValidatorIndex, PARACHAIN_KEY_TYPE_ID,
 };
 use runtime_common::{
 	assigned_slots, auctions, claims, crowdloan, impl_runtime_weights,
@@ -1499,6 +1500,7 @@ pub mod migrations {
 		frame_support::migrations::RemovePallet<TipsPalletName, <Runtime as frame_system::Config>::DbWeight>,
 
 		pallet_grandpa::migrations::MigrateV4ToV5<Runtime>,
+		parachains_configuration::migration::v10::MigrateToV10<Runtime>,
 	);
 }
 
@@ -1660,7 +1662,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	#[api_version(8)]
+	#[api_version(9)]
 	impl primitives::runtime_api::ParachainHost<Block, Hash, BlockNumber> for Runtime {
 		fn validators() -> Vec<ValidatorId> {
 			parachains_runtime_api_impl::validators::<Runtime>()
@@ -1808,6 +1810,9 @@ sp_api::impl_runtime_apis! {
 			parachains_staging_runtime_api_impl::disabled_validators::<Runtime>()
 		}
 
+		fn node_features() -> NodeFeatures {
+			parachains_staging_runtime_api_impl::node_features::<Runtime>()
+		}
 	}
 
 	#[api_version(3)]
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
index 29f387657786afd1e07c207d733b7cfddfd4d83a..34541b83597e6284a401a171e703b200366114a0 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
@@ -17,9 +17,9 @@
 //! Autogenerated weights for `runtime_parachains::configuration`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-11-10, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-fljshgub-project-163-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024
 
 // Executed Command:
@@ -31,11 +31,11 @@
 // --extrinsic=*
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --json-file=/builds/parity/mirrors/polkadot/.git/.artifacts/bench.json
+// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json
 // --pallet=runtime_parachains::configuration
 // --chain=rococo-dev
-// --header=./file_header.txt
-// --output=./runtime/rococo/src/weights/
+// --header=./polkadot/file_header.txt
+// --output=./polkadot/runtime/rococo/src/weights/
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
@@ -56,11 +56,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_block_number() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_051_000 picoseconds.
-		Weight::from_parts(9_496_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_793_000 picoseconds.
+		Weight::from_parts(8_192_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -72,11 +72,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_u32() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_104_000 picoseconds.
-		Weight::from_parts(9_403_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_819_000 picoseconds.
+		Weight::from_parts(8_004_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -88,11 +88,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_option_u32() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_112_000 picoseconds.
-		Weight::from_parts(9_495_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_760_000 picoseconds.
+		Weight::from_parts(8_174_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -114,11 +114,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_balance() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_011_000 picoseconds.
-		Weight::from_parts(9_460_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_814_000 picoseconds.
+		Weight::from_parts(8_098_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -130,11 +130,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_executor_params() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_940_000 picoseconds.
-		Weight::from_parts(10_288_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 10_028_000 picoseconds.
+		Weight::from_parts(10_386_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -146,11 +146,27 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_perbill() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_192_000 picoseconds.
-		Weight::from_parts(9_595_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_867_000 picoseconds.
+		Weight::from_parts(8_191_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
+	/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
+	/// Proof: `Configuration::BypassConsistencyCheck` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0)
+	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn set_node_feature() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 10_158_000 picoseconds.
+		Weight::from_parts(10_430_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
diff --git a/polkadot/runtime/westend/src/lib.rs b/polkadot/runtime/westend/src/lib.rs
index d80640c016f7381aa4d15414579969ca983d7518..d3862aff257f6c2699362213119bf19ae0b67fa1 100644
--- a/polkadot/runtime/westend/src/lib.rs
+++ b/polkadot/runtime/westend/src/lib.rs
@@ -46,12 +46,12 @@ use pallet_session::historical as session_historical;
 use pallet_transaction_payment::{CurrencyAdapter, FeeDetails, RuntimeDispatchInfo};
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use primitives::{
-	slashing, AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash,
-	CommittedCandidateReceipt, CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash,
-	Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment, Nonce,
-	OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement, ScrapedOnChainVotes,
-	SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
-	ValidatorSignature, PARACHAIN_KEY_TYPE_ID,
+	slashing, vstaging::NodeFeatures, AccountId, AccountIndex, Balance, BlockNumber,
+	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState, DisputeState,
+	ExecutorParams, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage,
+	InboundHrmpMessage, Moment, Nonce, OccupiedCoreAssumption, PersistedValidationData,
+	PvfCheckStatement, ScrapedOnChainVotes, SessionInfo, Signature, ValidationCode,
+	ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, PARACHAIN_KEY_TYPE_ID,
 };
 use runtime_common::{
 	assigned_slots, auctions, crowdloan,
@@ -1559,6 +1559,7 @@ pub mod migrations {
 		pallet_referenda::migration::v1::MigrateV0ToV1<Runtime, ()>,
 		pallet_nomination_pools::migration::versioned_migrations::V6ToV7<Runtime>,
 		pallet_grandpa::migrations::MigrateV4ToV5<Runtime>,
+		parachains_configuration::migration::v10::MigrateToV10<Runtime>,
 	);
 }
 
@@ -1699,7 +1700,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	#[api_version(8)]
+	#[api_version(9)]
 	impl primitives::runtime_api::ParachainHost<Block, Hash, BlockNumber> for Runtime {
 		fn validators() -> Vec<ValidatorId> {
 			parachains_runtime_api_impl::validators::<Runtime>()
@@ -1846,6 +1847,10 @@ sp_api::impl_runtime_apis! {
 		fn disabled_validators() -> Vec<ValidatorIndex> {
 			parachains_staging_runtime_api_impl::disabled_validators::<Runtime>()
 		}
+
+		fn node_features() -> NodeFeatures {
+			parachains_staging_runtime_api_impl::node_features::<Runtime>()
+		}
 	}
 
 	impl beefy_primitives::BeefyApi<Block, BeefyId> for Runtime {
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
index 585dc9058f21ec29b15040470d4a4c663c18d303..3a4813b667c68ea6400c9ad58cea8fd1bfece5d0 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
@@ -17,9 +17,9 @@
 //! Autogenerated weights for `runtime_parachains::configuration`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-08-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-11-10, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-fljshgub-project-163-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024
 
 // Executed Command:
@@ -31,11 +31,11 @@
 // --extrinsic=*
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --json-file=/builds/parity/mirrors/polkadot/.git/.artifacts/bench.json
+// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json
 // --pallet=runtime_parachains::configuration
 // --chain=westend-dev
-// --header=./file_header.txt
-// --output=./runtime/westend/src/weights/
+// --header=./polkadot/file_header.txt
+// --output=./polkadot/runtime/westend/src/weights/
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
@@ -56,11 +56,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_block_number() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_616_000 picoseconds.
-		Weight::from_parts(9_961_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 8_065_000 picoseconds.
+		Weight::from_parts(8_389_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -72,11 +72,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_u32() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_587_000 picoseconds.
-		Weight::from_parts(9_964_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 8_038_000 picoseconds.
+		Weight::from_parts(8_463_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -88,11 +88,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_option_u32() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_650_000 picoseconds.
-		Weight::from_parts(9_960_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_843_000 picoseconds.
+		Weight::from_parts(8_216_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -114,11 +114,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_balance() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_545_000 picoseconds.
-		Weight::from_parts(9_845_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_969_000 picoseconds.
+		Weight::from_parts(8_362_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -130,11 +130,11 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_executor_params() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 10_258_000 picoseconds.
-		Weight::from_parts(10_607_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 10_084_000 picoseconds.
+		Weight::from_parts(10_451_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -146,11 +146,27 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
 	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	fn set_config_with_perbill() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `127`
-		//  Estimated: `1612`
-		// Minimum execution time: 9_502_000 picoseconds.
-		Weight::from_parts(9_902_000, 0)
-			.saturating_add(Weight::from_parts(0, 1612))
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 7_948_000 picoseconds.
+		Weight::from_parts(8_268_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
+	/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
+	/// Proof: `Configuration::BypassConsistencyCheck` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0)
+	/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn set_node_feature() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `151`
+		//  Estimated: `1636`
+		// Minimum execution time: 10_257_000 picoseconds.
+		Weight::from_parts(10_584_000, 0)
+			.saturating_add(Weight::from_parts(0, 1636))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}