deprecate AsyncBackingParams (#7254)

Part of #5079.

Removes all usage of the static async backing params, replacing them
with dynamically computed equivalent values (based on the claim queue
and scheduling lookahead).

Adds a new runtime API for querying the scheduling lookahead value. If
not present, falls back to 3 (the default value that is backwards
compatible with values we have on production networks for
allowed_ancestry_len)

Also resolves most of
#4447, removing code
that handles async backing not yet being enabled.
While doing this, I removed the support for collation protocol version 1
on collators, as it only worked for leaves not supporting async backing
(which are none).
I also unhooked the legacy v1 statement-distribution (for the same
reason as above). That subsystem is basically dead code now, so I had to
remove some of its tests as they would no longer pass (since the
subsystem no longer sends messages to the legacy variant). I did not
remove the entire legacy subsystem yet, as that would pollute this PR
too much. We can remove the entire v1 and v2 validation protocols in a
follow up PR.

In another PR: remove test files with names `prospective_parachains`
(it'd pollute this PR if we do now)

TODO:
- [x] add deprecation warnings
- [x] prdoc

---------

Co-authored-by: cmd[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: alindima

cumulus/client/consensus/aura/src/collators/mod.rs

@@ -22,19 +22,18 @@
 
 use crate::collator::SlotClaim;
 use codec::Codec;
-use cumulus_client_consensus_common::{
-	self as consensus_common, load_abridged_host_configuration, ParentSearchParams,
-};
+use cumulus_client_consensus_common::{self as consensus_common, ParentSearchParams};
 use cumulus_primitives_aura::{AuraUnincludedSegmentApi, Slot};
 use cumulus_primitives_core::{relay_chain::Hash as ParaHash, BlockT, ClaimQueueOffset};
 use cumulus_relay_chain_interface::RelayChainInterface;
+use polkadot_node_subsystem::messages::RuntimeApiRequest;
 use polkadot_node_subsystem_util::runtime::ClaimQueueSnapshot;
 use polkadot_primitives::{
-	AsyncBackingParams, CoreIndex, Hash as RelayHash, Id as ParaId, OccupiedCoreAssumption,
-	ValidationCodeHash,
+	CoreIndex, Hash as RelayHash, Id as ParaId, OccupiedCoreAssumption, ValidationCodeHash,
+	DEFAULT_SCHEDULING_LOOKAHEAD,
 };
 use sc_consensus_aura::{standalone as aura_internal, AuraApi};
-use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_api::{ApiExt, ProvideRuntimeApi, RuntimeApiInfo};
 use sp_core::Pair;
 use sp_keystore::KeystorePtr;
 use sp_timestamp::Timestamp;
@@ -102,26 +101,43 @@ async fn check_validation_code_or_log(
 	}
 }
 
-/// Reads async backing parameters from the relay chain storage at the given relay parent.
-async fn async_backing_params(
+/// Fetch scheduling lookahead at given relay parent.
+async fn scheduling_lookahead(
 	relay_parent: RelayHash,
 	relay_client: &impl RelayChainInterface,
-) -> Option<AsyncBackingParams> {
-	match load_abridged_host_configuration(relay_parent, relay_client).await {
-		Ok(Some(config)) => Some(config.async_backing_params),
-		Ok(None) => {
+) -> Option<u32> {
+	let runtime_api_version = relay_client
+		.version(relay_parent)
+		.await
+		.map_err(|e| {
 			tracing::error!(
-				target: crate::LOG_TARGET,
-				"Active config is missing in relay chain storage",
-			);
-			None
-		},
+				target: super::LOG_TARGET,
+				error = ?e,
+				"Failed to fetch relay chain runtime version.",
+			)
+		})
+		.ok()?;
+
+	let parachain_host_runtime_api_version = runtime_api_version
+		.api_version(
+			&<dyn polkadot_primitives::runtime_api::ParachainHost<polkadot_primitives::Block>>::ID,
+		)
+		.unwrap_or_default();
+
+	if parachain_host_runtime_api_version <
+		RuntimeApiRequest::SCHEDULING_LOOKAHEAD_RUNTIME_REQUIREMENT
+	{
+		return None
+	}
+
+	match relay_client.scheduling_lookahead(relay_parent).await {
+		Ok(scheduling_lookahead) => Some(scheduling_lookahead),
 		Err(err) => {
 			tracing::error!(
 				target: crate::LOG_TARGET,
 				?err,
 				?relay_parent,
-				"Failed to read active config from relay chain client",
+				"Failed to fetch scheduling lookahead from relay chain",
 			);
 			None
 		},
@@ -217,9 +233,10 @@ where
 	let parent_search_params = ParentSearchParams {
 		relay_parent,
 		para_id,
-		ancestry_lookback: crate::collators::async_backing_params(relay_parent, relay_client)
+		ancestry_lookback: scheduling_lookahead(relay_parent, relay_client)
 			.await
-			.map_or(0, |params| params.allowed_ancestry_len as usize),
+			.unwrap_or(DEFAULT_SCHEDULING_LOOKAHEAD)
+			.saturating_sub(1) as usize,
 		max_depth: PARENT_SEARCH_DEPTH,
 		ignore_alternative_branches: true,
 	};

cumulus/client/consensus/common/src/tests.rs

@@ -284,6 +284,10 @@ impl RelayChainInterface for Relaychain {
 	) -> RelayChainResult<Vec<u8>> {
 		unimplemented!("Not needed for test")
 	}
+
+	async fn scheduling_lookahead(&self, _: PHash) -> RelayChainResult<u32> {
+		unimplemented!("Not needed for test")
+	}
 }
 
 fn sproof_with_best_parent(client: &Client) -> RelayStateSproofBuilder {

cumulus/client/network/src/tests.rs

@@ -347,6 +347,10 @@ impl RelayChainInterface for DummyRelayChainInterface {
 	) -> RelayChainResult<Vec<u8>> {
 		unimplemented!("Not needed for test")
 	}
+
+	async fn scheduling_lookahead(&self, _: PHash) -> RelayChainResult<u32> {
+		unimplemented!("Not needed for test")
+	}
 }
 
 fn make_validator_and_api() -> (

cumulus/client/pov-recovery/src/tests.rs

@@ -503,6 +503,10 @@ impl RelayChainInterface for Relaychain {
 	) -> RelayChainResult<Vec<u8>> {
 		unimplemented!("Not needed for test")
 	}
+
+	async fn scheduling_lookahead(&self, _: PHash) -> RelayChainResult<u32> {
+		unimplemented!("Not needed for test")
+	}
 }
 
 fn make_candidate_chain(candidate_number_range: Range<u32>) -> Vec<CommittedCandidateReceipt> {

cumulus/client/relay-chain-inprocess-interface/src/lib.rs

@@ -316,6 +316,10 @@ impl RelayChainInterface for RelayChainInProcessInterface {
 	) -> RelayChainResult<BTreeMap<CoreIndex, VecDeque<ParaId>>> {
 		Ok(self.full_client.runtime_api().claim_queue(hash)?)
 	}
+
+	async fn scheduling_lookahead(&self, hash: PHash) -> RelayChainResult<u32> {
+		Ok(self.full_client.runtime_api().scheduling_lookahead(hash)?)
+	}
 }
 
 pub enum BlockCheckStatus {

cumulus/client/relay-chain-interface/src/lib.rs

@@ -244,6 +244,9 @@ pub trait RelayChainInterface: Send + Sync {
 		&self,
 		relay_parent: PHash,
 	) -> RelayChainResult<BTreeMap<CoreIndex, VecDeque<ParaId>>>;
+
+	/// Fetch the scheduling lookahead value.
+	async fn scheduling_lookahead(&self, relay_parent: PHash) -> RelayChainResult<u32>;
 }
 
 #[async_trait]
@@ -398,6 +401,10 @@ where
 	) -> RelayChainResult<BTreeMap<CoreIndex, VecDeque<ParaId>>> {
 		(**self).claim_queue(relay_parent).await
 	}
+
+	async fn scheduling_lookahead(&self, relay_parent: PHash) -> RelayChainResult<u32> {
+		(**self).scheduling_lookahead(relay_parent).await
+	}
 }
 
 /// Helper function to call an arbitrary runtime API using a `RelayChainInterface` client.

cumulus/client/relay-chain-minimal-node/src/blockchain_rpc_client.rs

@@ -464,6 +464,10 @@ impl RuntimeApiSubsystemClient for BlockChainRpcClient {
 	) -> Result<Option<Constraints>, ApiError> {
 		Ok(self.rpc_client.parachain_host_backing_constraints(at, para_id).await?)
 	}
+
+	async fn scheduling_lookahead(&self, at: Hash) -> Result<u32, sp_api::ApiError> {
+		Ok(self.rpc_client.parachain_host_scheduling_lookahead(at).await?)
+	}
 }
 
 #[async_trait::async_trait]

cumulus/client/relay-chain-rpc-interface/src/lib.rs

@@ -282,4 +282,8 @@ impl RelayChainInterface for RelayChainRpcInterface {
 	> {
 		self.rpc_client.parachain_host_claim_queue(relay_parent).await
 	}
+
+	async fn scheduling_lookahead(&self, relay_parent: RelayHash) -> RelayChainResult<u32> {
+		self.rpc_client.parachain_host_scheduling_lookahead(relay_parent).await
+	}
 }

cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs

@@ -706,6 +706,14 @@ impl RelayChainRpcClient {
 		.await
 	}
 
+	pub async fn parachain_host_scheduling_lookahead(
+		&self,
+		at: RelayHash,
+	) -> Result<u32, RelayChainError> {
+		self.call_remote_runtime_function("ParachainHost_scheduling_lookahead", at, None::<()>)
+			.await
+	}
+
 	pub async fn validation_code_hash(
 		&self,
 		at: RelayHash,

cumulus/zombienet/tests/0008-elastic_authoring.toml

@@ -1,10 +1,6 @@
 [settings]
 timeout = 1000
 
-[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params]
-  max_candidate_depth = 6
-  allowed_ancestry_len = 3
-
 [relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
   max_validators_per_core = 1
   num_cores = 4

cumulus/zombienet/tests/0009-elastic_pov_recovery.toml

@@ -9,10 +9,6 @@ requests = { memory = "2G", cpu = "1" }
 limits = { memory = "4G", cpu = "2" }
 requests = { memory = "2G", cpu = "1" }
 
-[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params]
-  max_candidate_depth = 6
-  allowed_ancestry_len = 3
-
 [relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
   max_validators_per_core = 1
   num_cores = 4