Elastic scaling: runtime dependency tracking and enactment

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

@@ -13,7 +13,7 @@
 
 pub use v1::MigrateToV1;
 
-mod v0 {
+pub mod v0 {
 	use crate::inclusion::{Config, Pallet};
 	use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
 	use frame_support::{storage_alias, Twox64Concat};

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

@@ -117,7 +117,10 @@ impl<H, N> CandidatePendingAvailability<H, N> {
 	}
 
 	/// Get the relay-chain block number this was backed in.
-	pub(crate) fn backed_in_number(&self) -> &N {
+	pub(crate) fn backed_in_number(&self) -> &N
+	where
+		N: Clone,
+	{
 		&self.backed_in_number
 	}
 
@@ -149,6 +152,16 @@ impl<H, N> CandidatePendingAvailability<H, N> {
 		self.relay_parent_number.clone()
 	}
 
+	/// Get the candidate backing group.
+	pub(crate) fn backing_group(&self) -> GroupIndex {
+		self.backing_group
+	}
+
+	/// Get the candidate's backers.
+	pub(crate) fn backers(&self) -> &BitVec<u8, BitOrderLsb0> {
+		&self.backers
+	}
+
 	#[cfg(any(feature = "runtime-benchmarks", test))]
 	pub(crate) fn new(
 		core: CoreIndex,

polkadot/runtime/parachains/src/runtime_api_impl/v7.rs

@@ -22,6 +22,7 @@ use crate::{
 	scheduler::{self, CoreOccupied},
 	session_info, shared,
 };
+use frame_support::traits::{GetStorageVersion, StorageVersion};
 use frame_system::pallet_prelude::*;
 use primitives::{
 	async_backing::{
@@ -92,18 +93,41 @@ pub fn availability_cores<T: initializer::Config>() -> Vec<CoreState<T::Hash, Bl
 		.enumerate()
 		.map(|(i, core)| match core {
 			CoreOccupied::Paras(entry) => {
-				let pending_availability = <inclusion::Pallet<T>>::pending_availability_with_core(
-					entry.para_id(),
-					CoreIndex(i as u32),
-				)
-				.expect("Occupied core always has pending availability; qed");
-
-				let backed_in_number = *pending_availability.backed_in_number();
+				// Due to https://github.com/paritytech/polkadot-sdk/issues/64, using the new storage types would cause
+				// this runtime API to panic. We explicitly handle the storage for version 0 to
+				// prevent that. When removing the inclusion v0 -> v1 migration, this bit of code
+				// can also be removed.
+				let pending_availability = if <inclusion::Pallet<T>>::on_chain_storage_version() ==
+					StorageVersion::new(0)
+				{
+					inclusion::migration::v0::PendingAvailability::<T>::get(entry.para_id())
+						.expect("Occupied core always has pending availability; qed")
+				} else {
+					let candidate = <inclusion::Pallet<T>>::pending_availability_with_core(
+						entry.para_id(),
+						CoreIndex(i as u32),
+					)
+					.expect("Occupied core always has pending availability; qed");
+
+					// Translate to the old candidate format, as we don't need the commitments now.
+					inclusion::migration::v0::CandidatePendingAvailability {
+						core: candidate.core_occupied(),
+						hash: candidate.candidate_hash(),
+						descriptor: candidate.candidate_descriptor().clone(),
+						availability_votes: candidate.availability_votes().clone(),
+						backers: candidate.backers().clone(),
+						relay_parent_number: candidate.relay_parent_number(),
+						backed_in_number: candidate.backed_in_number().clone(),
+						backing_group: candidate.backing_group(),
+					}
+				};
+
+				let backed_in_number = pending_availability.backed_in_number;
 
 				// Use the same block number for determining the responsible group as what the
 				// backing subsystem would use when it calls validator_groups api.
 				let backing_group_allocation_time =
-					pending_availability.relay_parent_number() + One::one();
+					pending_availability.relay_parent_number + One::one();
 				CoreState::Occupied(OccupiedCore {
 					next_up_on_available: <scheduler::Pallet<T>>::next_up_on_available(CoreIndex(
 						i as u32,
@@ -113,13 +137,13 @@ pub fn availability_cores<T: initializer::Config>() -> Vec<CoreState<T::Hash, Bl
 					next_up_on_time_out: <scheduler::Pallet<T>>::next_up_on_time_out(CoreIndex(
 						i as u32,
 					)),
-					availability: pending_availability.availability_votes().clone(),
+					availability: pending_availability.availability_votes.clone(),
 					group_responsible: group_responsible_for(
 						backing_group_allocation_time,
-						pending_availability.core_occupied(),
+						pending_availability.core,
 					),
-					candidate_hash: pending_availability.candidate_hash(),
-					candidate_descriptor: pending_availability.candidate_descriptor().clone(),
+					candidate_hash: pending_availability.hash,
+					candidate_descriptor: pending_availability.descriptor,
 				})
 			},
 			CoreOccupied::Free => {