backing: move the min votes threshold to the runtime

node/core/backing/src/lib.rs

@@ -80,8 +80,8 @@ use futures::{
 
 use error::{Error, FatalResult};
 use polkadot_node_primitives::{
-	minimum_votes, AvailableData, InvalidCandidate, PoV, SignedFullStatementWithPVD,
-	StatementWithPVD, ValidationResult,
+	AvailableData, InvalidCandidate, PoV, SignedFullStatementWithPVD, StatementWithPVD,
+	ValidationResult,
 };
 use polkadot_node_subsystem::{
 	messages::{
@@ -96,8 +96,7 @@ use polkadot_node_subsystem::{
 use polkadot_node_subsystem_util::{
 	self as util,
 	backing_implicit_view::{FetchError as ImplicitViewFetchError, View as ImplicitView},
-	request_from_runtime, request_session_index_for_child, request_validator_groups,
-	request_validators,
+	request_from_runtime, request_validator_groups, request_validators,
 	runtime::{prospective_parachains_mode, ProspectiveParachainsMode},
 	Validator,
 };
@@ -116,6 +115,7 @@ use statement_table::{
 	},
 	Config as TableConfig, Context as TableContextTrait, Table,
 };
+use util::runtime::{request_min_backing_votes, RuntimeInfo};
 
 mod error;
 
@@ -219,6 +219,8 @@ struct PerRelayParentState {
 	awaiting_validation: HashSet<CandidateHash>,
 	/// Data needed for retrying in case of `ValidatedCandidateCommand::AttestNoPoV`.
 	fallbacks: HashMap<CandidateHash, AttestingData>,
+	/// The minimum backing votes threshold.
+	minimum_backing_votes: u32,
 }
 
 struct PerCandidateState {
@@ -275,6 +277,8 @@ struct State {
 	background_validation_tx: mpsc::Sender<(Hash, ValidatedCandidateCommand)>,
 	/// The handle to the keystore used for signing.
 	keystore: KeystorePtr,
+	/// Runtime info cached per-session.
+	runtime_info: RuntimeInfo,
 }
 
 impl State {
@@ -289,6 +293,7 @@ impl State {
 			per_candidate: HashMap::new(),
 			background_validation_tx,
 			keystore,
+			runtime_info: RuntimeInfo::new(None),
 		}
 	}
 }
@@ -400,8 +405,8 @@ impl TableContextTrait for TableContext {
 		self.groups.get(group).map_or(false, |g| g.iter().any(|a| a == authority))
 	}
 
-	fn requisite_votes(&self, group: &ParaId) -> usize {
-		self.groups.get(group).map_or(usize::MAX, |g| minimum_votes(g.len()))
+	fn get_group_size(&self, group: &ParaId) -> Option<usize> {
+		self.groups.get(group).map(|g| g.len())
 	}
 }
 
@@ -943,7 +948,14 @@ async fn handle_active_leaves_update<Context>(
 
 		// construct a `PerRelayParent` from the runtime API
 		// and insert it.
-		let per = construct_per_relay_parent_state(ctx, maybe_new, &state.keystore, mode).await?;
+		let per = construct_per_relay_parent_state(
+			ctx,
+			maybe_new,
+			&state.keystore,
+			&mut state.runtime_info,
+			mode,
+		)
+		.await?;
 
 		if let Some(per) = per {
 			state.per_relay_parent.insert(maybe_new, per);
@@ -959,6 +971,7 @@ async fn construct_per_relay_parent_state<Context>(
 	ctx: &mut Context,
 	relay_parent: Hash,
 	keystore: &KeystorePtr,
+	runtime_info: &mut RuntimeInfo,
 	mode: ProspectiveParachainsMode,
 ) -> Result<Option<PerRelayParentState>, Error> {
 	macro_rules! try_runtime_api {
@@ -983,10 +996,18 @@ async fn construct_per_relay_parent_state<Context>(
 
 	let parent = relay_parent;
 
-	let (validators, groups, session_index, cores) = futures::try_join!(
+	let session_index =
+		try_runtime_api!(runtime_info.get_session_index_for_child(ctx.sender(), parent).await);
+
+	let minimum_backing_votes =
+		request_min_backing_votes(parent, ctx.sender(), |parent, sender| {
+			runtime_info.get_min_backing_votes(sender, session_index, parent)
+		})
+		.await?;
+
+	let (validators, groups, cores) = futures::try_join!(
 		request_validators(parent, ctx.sender()).await,
 		request_validator_groups(parent, ctx.sender()).await,
-		request_session_index_for_child(parent, ctx.sender()).await,
 		request_from_runtime(parent, ctx.sender(), |tx| {
 			RuntimeApiRequest::AvailabilityCores(tx)
 		},)
@@ -996,7 +1017,6 @@ async fn construct_per_relay_parent_state<Context>(
 
 	let validators: Vec<_> = try_runtime_api!(validators);
 	let (validator_groups, group_rotation_info) = try_runtime_api!(groups);
-	let session_index = try_runtime_api!(session_index);
 	let cores = try_runtime_api!(cores);
 
 	let signing_context = SigningContext { parent_hash: parent, session_index };
@@ -1061,6 +1081,7 @@ async fn construct_per_relay_parent_state<Context>(
 		issued_statements: HashSet::new(),
 		awaiting_validation: HashSet::new(),
 		fallbacks: HashMap::new(),
+		minimum_backing_votes,
 	}))
 }
 
@@ -1563,10 +1584,13 @@ async fn post_import_statement_actions<Context>(
 	rp_state: &mut PerRelayParentState,
 	summary: Option<&TableSummary>,
 ) -> Result<(), Error> {
-	if let Some(attested) = summary
-		.as_ref()
-		.and_then(|s| rp_state.table.attested_candidate(&s.candidate, &rp_state.table_context))
-	{
+	if let Some(attested) = summary.as_ref().and_then(|s| {
+		rp_state.table.attested_candidate(
+			&s.candidate,
+			&rp_state.table_context,
+			rp_state.minimum_backing_votes,
+		)
+	}) {
 		let candidate_hash = attested.candidate.hash();
 
 		// `HashSet::insert` returns true if the thing wasn't in there already.
@@ -2009,7 +2033,11 @@ fn handle_get_backed_candidates_message(
 			};
 			rp_state
 				.table
-				.attested_candidate(&candidate_hash, &rp_state.table_context)
+				.attested_candidate(
+					&candidate_hash,
+					&rp_state.table_context,
+					rp_state.minimum_backing_votes,
+				)
 				.and_then(|attested| table_attested_to_backed(attested, &rp_state.table_context))
 		})
 		.collect();

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

@@ -80,6 +80,7 @@ struct TestState {
 	head_data: HashMap<ParaId, HeadData>,
 	signing_context: SigningContext,
 	relay_parent: Hash,
+	minimum_backing_votes: u32,
 }
 
 impl TestState {
@@ -150,6 +151,7 @@ impl Default for TestState {
 			validation_data,
 			signing_context,
 			relay_parent,
+			minimum_backing_votes: 2,
 		}
 	}
 }
@@ -250,33 +252,60 @@ async fn test_startup(virtual_overseer: &mut VirtualOverseer, test_state: &TestS
 		}
 	);
 
-	// Check that subsystem job issues a request for a validator set.
+	// Check that subsystem job issues a request for the session index for child.
 	assert_matches!(
 		virtual_overseer.recv().await,
 		AllMessages::RuntimeApi(
-			RuntimeApiMessage::Request(parent, RuntimeApiRequest::Validators(tx))
+			RuntimeApiMessage::Request(parent, RuntimeApiRequest::SessionIndexForChild(tx))
 		) if parent == test_state.relay_parent => {
-			tx.send(Ok(test_state.validator_public.clone())).unwrap();
+			tx.send(Ok(test_state.signing_context.session_index)).unwrap();
 		}
 	);
 
-	// Check that subsystem job issues a request for the validator groups.
+	// Check that subsystem job issues a request for the runtime API version.
+	// assert_matches!(
+	// 	virtual_overseer.recv().await,
+	// 	AllMessages::RuntimeApi(
+	// 		RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx))
+	// 	) if parent == test_state.relay_parent => {
+	// 		tx.send(Ok(RuntimeApiRequest::MINIMUM_BACKING_VOTES_RUNTIME_REQUIREMENT)).unwrap();
+	// 	}
+	// );
+
+	// Check if subsystem job issues a request for the minimum backing votes.
+	// This may or may not happen, depending if the minimum backing votes is already cached in the
+	// RuntimeInfo.
+	let next_message = {
+		let msg = virtual_overseer.recv().await;
+		match msg {
+			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+				parent,
+				RuntimeApiRequest::MinimumBackingVotes(tx),
+			)) if parent == test_state.relay_parent => {
+				tx.send(Ok(test_state.minimum_backing_votes)).unwrap();
+				virtual_overseer.recv().await
+			},
+			_ => msg,
+		}
+	};
+
+	// Check that subsystem job issues a request for a validator set.
 	assert_matches!(
-		virtual_overseer.recv().await,
+		next_message,
 		AllMessages::RuntimeApi(
-			RuntimeApiMessage::Request(parent, RuntimeApiRequest::ValidatorGroups(tx))
+			RuntimeApiMessage::Request(parent, RuntimeApiRequest::Validators(tx))
 		) if parent == test_state.relay_parent => {
-			tx.send(Ok(test_state.validator_groups.clone())).unwrap();
+			tx.send(Ok(test_state.validator_public.clone())).unwrap();
 		}
 	);
 
-	// Check that subsystem job issues a request for the session index for child.
+	// Check that subsystem job issues a request for the validator groups.
 	assert_matches!(
 		virtual_overseer.recv().await,
 		AllMessages::RuntimeApi(
-			RuntimeApiMessage::Request(parent, RuntimeApiRequest::SessionIndexForChild(tx))
+			RuntimeApiMessage::Request(parent, RuntimeApiRequest::ValidatorGroups(tx))
 		) if parent == test_state.relay_parent => {
-			tx.send(Ok(test_state.signing_context.session_index)).unwrap();
+			tx.send(Ok(test_state.validator_groups.clone())).unwrap();
 		}
 	);
 

node/core/backing/src/tests/prospective_parachains.rs

@@ -138,13 +138,41 @@ async fn activate_leaf(
 	}
 
 	for (hash, number) in ancestry_iter.take(requested_len) {
-		// Check that subsystem job issues a request for a validator set.
 		let msg = match next_overseer_message.take() {
 			Some(msg) => msg,
 			None => virtual_overseer.recv().await,
 		};
+
+		// Check that subsystem job issues a request for the session index for child.
 		assert_matches!(
 			msg,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::SessionIndexForChild(tx))
+			) if parent == hash => {
+				tx.send(Ok(test_state.signing_context.session_index)).unwrap();
+			}
+		);
+
+		// Check if subsystem job issues a request for the minimum backing votes.
+		// This may or may not happen, depending if the minimum backing votes is already cached in
+		// the `RuntimeInfo`.
+		let next_message = {
+			let msg = virtual_overseer.recv().await;
+			match msg {
+				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+					parent,
+					RuntimeApiRequest::MinimumBackingVotes(tx),
+				)) if parent == hash => {
+					tx.send(Ok(test_state.minimum_backing_votes)).unwrap();
+					virtual_overseer.recv().await
+				},
+				_ => msg,
+			}
+		};
+
+		// Check that subsystem job issues a request for a validator set.
+		assert_matches!(
+			next_message,
 			AllMessages::RuntimeApi(
 				RuntimeApiMessage::Request(parent, RuntimeApiRequest::Validators(tx))
 			) if parent == hash => {
@@ -164,16 +192,6 @@ async fn activate_leaf(
 			}
 		);
 
-		// Check that subsystem job issues a request for the session index for child.
-		assert_matches!(
-			virtual_overseer.recv().await,
-			AllMessages::RuntimeApi(
-				RuntimeApiMessage::Request(parent, RuntimeApiRequest::SessionIndexForChild(tx))
-			) if parent == hash => {
-				tx.send(Ok(test_state.signing_context.session_index)).unwrap();
-			}
-		);
-
 		// Check that subsystem job issues a request for the availability cores.
 		assert_matches!(
 			virtual_overseer.recv().await,

node/core/runtime-api/src/cache.rs

@@ -40,6 +40,7 @@ const DEFAULT_CACHE_CAP: NonZeroUsize = match NonZeroUsize::new(128) {
 pub(crate) struct RequestResultCache {
 	authorities: LruCache<Hash, Vec<AuthorityDiscoveryId>>,
 	validators: LruCache<Hash, Vec<ValidatorId>>,
+	minimum_backing_votes: LruCache<Hash, u32>,
 	validator_groups: LruCache<Hash, (Vec<Vec<ValidatorIndex>>, GroupRotationInfo)>,
 	availability_cores: LruCache<Hash, Vec<CoreState>>,
 	persisted_validation_data:
@@ -78,6 +79,7 @@ impl Default for RequestResultCache {
 		Self {
 			authorities: LruCache::new(DEFAULT_CACHE_CAP),
 			validators: LruCache::new(DEFAULT_CACHE_CAP),
+			minimum_backing_votes: LruCache::new(DEFAULT_CACHE_CAP),
 			validator_groups: LruCache::new(DEFAULT_CACHE_CAP),
 			availability_cores: LruCache::new(DEFAULT_CACHE_CAP),
 			persisted_validation_data: LruCache::new(DEFAULT_CACHE_CAP),
@@ -131,6 +133,18 @@ impl RequestResultCache {
 		self.validators.put(relay_parent, validators);
 	}
 
+	pub(crate) fn minimum_backing_votes(&mut self, relay_parent: &Hash) -> Option<u32> {
+		self.minimum_backing_votes.get(relay_parent).copied()
+	}
+
+	pub(crate) fn cache_minimum_backing_votes(
+		&mut self,
+		relay_parent: Hash,
+		minimum_backing_votes: u32,
+	) {
+		self.minimum_backing_votes.put(relay_parent, minimum_backing_votes);
+	}
+
 	pub(crate) fn validator_groups(
 		&mut self,
 		relay_parent: &Hash,
@@ -472,6 +486,7 @@ pub(crate) enum RequestResult {
 	// The structure of each variant is (relay_parent, [params,]*, result)
 	Authorities(Hash, Vec<AuthorityDiscoveryId>),
 	Validators(Hash, Vec<ValidatorId>),
+	MinimumBackingVotes(Hash, u32),
 	ValidatorGroups(Hash, (Vec<Vec<ValidatorIndex>>, GroupRotationInfo)),
 	AvailabilityCores(Hash, Vec<CoreState>),
 	PersistedValidationData(Hash, ParaId, OccupiedCoreAssumption, Option<PersistedValidationData>),

node/core/runtime-api/src/lib.rs

@@ -101,6 +101,9 @@ where
 				self.requests_cache.cache_authorities(relay_parent, authorities),
 			Validators(relay_parent, validators) =>
 				self.requests_cache.cache_validators(relay_parent, validators),
+			MinimumBackingVotes(relay_parent, minimum_backing_votes) => self
+				.requests_cache
+				.cache_minimum_backing_votes(relay_parent, minimum_backing_votes),
 			ValidatorGroups(relay_parent, groups) =>
 				self.requests_cache.cache_validator_groups(relay_parent, groups),
 			AvailabilityCores(relay_parent, cores) =>
@@ -301,6 +304,8 @@ where
 			Request::StagingAsyncBackingParams(sender) =>
 				query!(staging_async_backing_params(), sender)
 					.map(|sender| Request::StagingAsyncBackingParams(sender)),
+			Request::MinimumBackingVotes(sender) => query!(minimum_backing_votes(), sender)
+				.map(|sender| Request::MinimumBackingVotes(sender)),
 		}
 	}
 
@@ -551,6 +556,12 @@ where
 			ver = Request::SUBMIT_REPORT_DISPUTE_LOST_RUNTIME_REQUIREMENT,
 			sender
 		),
+		Request::MinimumBackingVotes(sender) => query!(
+			MinimumBackingVotes,
+			minimum_backing_votes(),
+			ver = Request::MINIMUM_BACKING_VOTES_RUNTIME_REQUIREMENT,
+			sender
+		),
 
 		Request::StagingParaBackingState(para, sender) => {
 			query!(

node/core/runtime-api/src/tests.rs

@@ -264,6 +264,10 @@ impl RuntimeApiSubsystemClient for MockSubsystemClient {
 	) -> Result<Option<vstaging::BackingState>, ApiError> {
 		todo!("Not required for tests")
 	}
+
+	async fn minimum_backing_votes(&self, _: Hash) -> Result<u32, ApiError> {
+		todo!("Not required for tests")
+	}
 }
 
 #[test]