runtime: assume elastic scaling MVP is always enabled (#7986)

The runtime part of
#6352.

The node-side part is handled by
#7286 (which should be
merged first)

Author: alindima

polkadot/node/core/backing/src/lib.rs

@@ -650,7 +650,7 @@ fn table_attested_to_backed(
 			.map(|(pos_in_votes, _pos_in_group)| validity_votes[pos_in_votes].clone())
 			.collect(),
 		validator_indices,
-		Some(core_index),
+		core_index,
 	))
 }
 

polkadot/node/core/backing/src/tests/mod.rs

@@ -905,7 +905,7 @@ fn backing_works() {
 		assert_eq!(candidates[0].validity_votes().len(), 3);
 
 		let (validator_indices, maybe_core_index) =
-			candidates[0].validator_indices_and_core_index(true);
+			candidates[0].validator_indices_and_core_index();
 
 		assert_eq!(maybe_core_index.unwrap(), CoreIndex(0));
 
@@ -1553,7 +1553,7 @@ fn backing_works_while_validation_ongoing() {
 			.validity_votes()
 			.contains(&ValidityAttestation::Explicit(signed_c.signature().clone())));
 		assert_eq!(
-			candidates[0].validator_indices_and_core_index(true),
+			candidates[0].validator_indices_and_core_index(),
 			(
 				bitvec::bitvec![u8, bitvec::order::Lsb0; 1, 0, 1, 1].as_bitslice(),
 				Some(CoreIndex(0))
@@ -2224,7 +2224,7 @@ fn candidate_backing_reorders_votes() {
 		vec![fake_attestation(1).into(), fake_attestation(3).into(), fake_attestation(5).into()];
 
 	assert_eq!(
-		backed.validator_indices_and_core_index(true),
+		backed.validator_indices_and_core_index(),
 		(expected_bitvec.as_bitslice(), Some(CoreIndex(10)))
 	);
 	assert_eq!(backed.validity_votes(), expected_attestations);

polkadot/node/core/provisioner/src/tests.rs

@@ -304,7 +304,7 @@ mod select_candidates {
 					},
 					Vec::new(),
 					default_bitvec(MOCK_GROUP_SIZE),
-					None,
+					CoreIndex(0),
 				)
 			})
 			.collect();
@@ -716,7 +716,7 @@ mod select_candidates {
 					committed_receipt.clone(),
 					Vec::new(),
 					default_bitvec(MOCK_GROUP_SIZE),
-					None,
+					CoreIndex(0),
 				)
 			})
 			.collect();
@@ -818,7 +818,7 @@ mod select_candidates {
 					committed_receipt.clone(),
 					Vec::new(),
 					default_bitvec(MOCK_GROUP_SIZE),
-					None,
+					CoreIndex(0),
 				)
 			})
 			.collect();
@@ -1006,7 +1006,7 @@ mod select_candidates {
 					},
 					Vec::new(),
 					default_bitvec(MOCK_GROUP_SIZE),
-					None,
+					CoreIndex(0),
 				)
 			})
 			.collect();

polkadot/primitives/src/v8/mod.rs

@@ -754,9 +754,8 @@ pub struct BackedCandidate<H = Hash> {
 	candidate: CommittedCandidateReceipt<H>,
 	/// The validity votes themselves, expressed as signatures.
 	validity_votes: Vec<ValidityAttestation>,
-	/// The indices of the validators within the group, expressed as a bitfield. May be extended
-	/// beyond the backing group size to contain the assigned core index, if ElasticScalingMVP is
-	/// enabled.
+	/// The indices of the validators within the group, expressed as a bitfield. Is extended
+	/// beyond the backing group size to contain the assigned core index.
 	validator_indices: BitVec<u8, bitvec::order::Lsb0>,
 }
 
@@ -766,12 +765,10 @@ impl<H> BackedCandidate<H> {
 		candidate: CommittedCandidateReceipt<H>,
 		validity_votes: Vec<ValidityAttestation>,
 		validator_indices: BitVec<u8, bitvec::order::Lsb0>,
-		core_index: Option<CoreIndex>,
+		core_index: CoreIndex,
 	) -> Self {
 		let mut instance = Self { candidate, validity_votes, validator_indices };
-		if let Some(core_index) = core_index {
-			instance.inject_core_index(core_index);
-		}
+		instance.inject_core_index(core_index);
 		instance
 	}
 
@@ -814,20 +811,13 @@ impl<H> BackedCandidate<H> {
 	/// Get a copy of the validator indices and the assumed core index, if any.
 	pub fn validator_indices_and_core_index(
 		&self,
-		core_index_enabled: bool,
 	) -> (&BitSlice<u8, bitvec::order::Lsb0>, Option<CoreIndex>) {
-		// This flag tells us if the block producers must enable Elastic Scaling MVP hack.
-		// It extends `BackedCandidate::validity_indices` to store a 8 bit core index.
-		if core_index_enabled {
-			let core_idx_offset = self.validator_indices.len().saturating_sub(8);
-			if core_idx_offset > 0 {
-				let (validator_indices_slice, core_idx_slice) =
-					self.validator_indices.split_at(core_idx_offset);
-				return (
-					validator_indices_slice,
-					Some(CoreIndex(core_idx_slice.load::<u8>() as u32)),
-				);
-			}
+		// `BackedCandidate::validity_indices` are extended to store a 8 bit core index.
+		let core_idx_offset = self.validator_indices.len().saturating_sub(8);
+		if core_idx_offset > 0 {
+			let (validator_indices_slice, core_idx_slice) =
+				self.validator_indices.split_at(core_idx_offset);
+			return (validator_indices_slice, Some(CoreIndex(core_idx_slice.load::<u8>() as u32)));
 		}
 
 		(&self.validator_indices, None)
@@ -2311,60 +2301,35 @@ pub mod tests {
 			dummy_committed_candidate_receipt(),
 			vec![],
 			initial_validator_indices.clone(),
-			None,
+			CoreIndex(10),
 		);
 
-		// No core index supplied, ElasticScalingMVP is off.
-		let (validator_indices, core_index) = candidate.validator_indices_and_core_index(false);
-		assert_eq!(validator_indices, initial_validator_indices.as_bitslice());
-		assert!(core_index.is_none());
-
-		// No core index supplied, ElasticScalingMVP is on. Still, decoding will be ok if backing
-		// group size is <= 8, to give a chance to parachains that don't have multiple cores
-		// assigned.
-		let (validator_indices, core_index) = candidate.validator_indices_and_core_index(true);
+		// No core index supplied.
+		candidate
+			.set_validator_indices_and_core_index(initial_validator_indices.clone().into(), None);
+		let (validator_indices, core_index) = candidate.validator_indices_and_core_index();
 		assert_eq!(validator_indices, initial_validator_indices.as_bitslice());
 		assert!(core_index.is_none());
 
-		let encoded_validator_indices = candidate.validator_indices.clone();
-		candidate.set_validator_indices_and_core_index(validator_indices.into(), core_index);
-		assert_eq!(candidate.validator_indices, encoded_validator_indices);
-
-		// No core index supplied, ElasticScalingMVP is on. Decoding is corrupted if backing group
+		// No core index supplied. Decoding is corrupted if backing group
 		// size larger than 8.
-		let candidate = BackedCandidate::new(
-			dummy_committed_candidate_receipt(),
-			vec![],
-			bitvec![u8, bitvec::order::Lsb0; 0, 1, 0, 1, 0, 1, 0, 1, 0],
+		candidate.set_validator_indices_and_core_index(
+			bitvec![u8, bitvec::order::Lsb0; 0, 1, 0, 1, 0, 1, 0, 1, 0].into(),
 			None,
 		);
-		let (validator_indices, core_index) = candidate.validator_indices_and_core_index(true);
+
+		let (validator_indices, core_index) = candidate.validator_indices_and_core_index();
 		assert_eq!(validator_indices, bitvec![u8, bitvec::order::Lsb0; 0].as_bitslice());
 		assert!(core_index.is_some());
 
-		// Core index supplied, ElasticScalingMVP is off. Core index will be treated as normal
-		// validator indices. Runtime will check against this.
-		let candidate = BackedCandidate::new(
-			dummy_committed_candidate_receipt(),
-			vec![],
-			bitvec![u8, bitvec::order::Lsb0; 0, 1, 0, 1],
-			Some(CoreIndex(10)),
-		);
-		let (validator_indices, core_index) = candidate.validator_indices_and_core_index(false);
-		assert_eq!(
-			validator_indices,
-			bitvec![u8, bitvec::order::Lsb0; 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0]
-		);
-		assert!(core_index.is_none());
-
-		// Core index supplied, ElasticScalingMVP is on.
+		// Core index supplied.
 		let mut candidate = BackedCandidate::new(
 			dummy_committed_candidate_receipt(),
 			vec![],
 			bitvec![u8, bitvec::order::Lsb0; 0, 1, 0, 1],
-			Some(CoreIndex(10)),
+			CoreIndex(10),
 		);
-		let (validator_indices, core_index) = candidate.validator_indices_and_core_index(true);
+		let (validator_indices, core_index) = candidate.validator_indices_and_core_index();
 		assert_eq!(validator_indices, bitvec![u8, bitvec::order::Lsb0; 0, 1, 0, 1]);
 		assert_eq!(core_index, Some(CoreIndex(10)));
 

polkadot/primitives/src/vstaging/mod.rs

@@ -709,12 +709,10 @@ impl<H> BackedCandidate<H> {
 		candidate: CommittedCandidateReceiptV2<H>,
 		validity_votes: Vec<ValidityAttestation>,
 		validator_indices: BitVec<u8, bitvec::order::Lsb0>,
-		core_index: Option<CoreIndex>,
+		core_index: CoreIndex,
 	) -> Self {
 		let mut instance = Self { candidate, validity_votes, validator_indices };
-		if let Some(core_index) = core_index {
-			instance.inject_core_index(core_index);
-		}
+		instance.inject_core_index(core_index);
 		instance
 	}
 
@@ -769,20 +767,13 @@ impl<H> BackedCandidate<H> {
 	/// Get a copy of the validator indices and the assumed core index, if any.
 	pub fn validator_indices_and_core_index(
 		&self,
-		core_index_enabled: bool,
 	) -> (&BitSlice<u8, bitvec::order::Lsb0>, Option<CoreIndex>) {
-		// This flag tells us if the block producers must enable Elastic Scaling MVP hack.
-		// It extends `BackedCandidate::validity_indices` to store a 8 bit core index.
-		if core_index_enabled {
-			let core_idx_offset = self.validator_indices.len().saturating_sub(8);
-			if core_idx_offset > 0 {
-				let (validator_indices_slice, core_idx_slice) =
-					self.validator_indices.split_at(core_idx_offset);
-				return (
-					validator_indices_slice,
-					Some(CoreIndex(core_idx_slice.load::<u8>() as u32)),
-				);
-			}
+		// `BackedCandidate::validity_indices` are extended to store a 8 bit core index.
+		let core_idx_offset = self.validator_indices.len().saturating_sub(8);
+		if core_idx_offset > 0 {
+			let (validator_indices_slice, core_idx_slice) =
+				self.validator_indices.split_at(core_idx_offset);
+			return (validator_indices_slice, Some(CoreIndex(core_idx_slice.load::<u8>() as u32)));
 		}
 
 		(&self.validator_indices, None)

polkadot/runtime/parachains/src/builder.rs

@@ -33,7 +33,6 @@ use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
 use frame_support::pallet_prelude::*;
 use frame_system::pallet_prelude::*;
 use polkadot_primitives::{
-	node_features::FeatureIndex,
 	vstaging::{
 		BackedCandidate, CandidateDescriptorV2, ClaimQueueOffset,
 		CommittedCandidateReceiptV2 as CommittedCandidateReceipt, CoreSelector,
@@ -763,16 +762,6 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 							})
 							.collect();
 
-						// Don't inject core when it is available in descriptor.
-						let core_idx = if candidate.descriptor.core_index().is_some() {
-							None
-						} else {
-							configuration::ActiveConfig::<T>::get()
-								.node_features
-								.get(FeatureIndex::ElasticScalingMVP as usize)
-								.and_then(|the_bit| if *the_bit { Some(core_idx) } else { None })
-						};
-
 						BackedCandidate::<T::Hash>::new(
 							candidate,
 							validity_votes,

polkadot/runtime/parachains/src/inclusion/mod.rs

@@ -628,7 +628,6 @@ impl<T: Config> Pallet<T> {
 		allowed_relay_parents: &AllowedRelayParentsTracker<T::Hash, BlockNumberFor<T>>,
 		candidates: &BTreeMap<ParaId, Vec<(BackedCandidate<T::Hash>, CoreIndex)>>,
 		group_validators: GV,
-		core_index_enabled: bool,
 	) -> Result<
 		Vec<(CandidateReceipt<T::Hash>, Vec<(ValidatorIndex, ValidityAttestation)>)>,
 		DispatchError,
@@ -688,12 +687,8 @@ impl<T: Config> Pallet<T> {
 					group_validators(group_idx).ok_or_else(|| Error::<T>::InvalidGroupIndex)?;
 
 				// Check backing vote count and validity.
-				let (backers, backer_idx_and_attestation) = Self::check_backing_votes(
-					candidate,
-					&validators,
-					group_vals,
-					core_index_enabled,
-				)?;
+				let (backers, backer_idx_and_attestation) =
+					Self::check_backing_votes(candidate, &validators, group_vals)?;
 
 				// Found a valid candidate.
 				latest_head_data = candidate.candidate().commitments.head_data.clone();
@@ -760,7 +755,6 @@ impl<T: Config> Pallet<T> {
 		backed_candidate: &BackedCandidate<T::Hash>,
 		validators: &[ValidatorId],
 		group_vals: Vec<ValidatorIndex>,
-		core_index_enabled: bool,
 	) -> Result<(BitVec<u8, BitOrderLsb0>, Vec<(ValidatorIndex, ValidityAttestation)>), Error<T>> {
 		let minimum_backing_votes = configuration::ActiveConfig::<T>::get().minimum_backing_votes;
 
@@ -770,8 +764,7 @@ impl<T: Config> Pallet<T> {
 			session_index: shared::CurrentSessionIndex::<T>::get(),
 		};
 
-		let (validator_indices, _) =
-			backed_candidate.validator_indices_and_core_index(core_index_enabled);
+		let (validator_indices, _) = backed_candidate.validator_indices_and_core_index();
 
 		// check the signatures in the backing and that it is a majority.
 		let maybe_amount_validated = polkadot_primitives::check_candidate_backing(