past-session validator discovery APIs

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

@@ -134,7 +134,7 @@ fn make_runtime_api_request<Client>(
 		Request::CandidatePendingAvailability(para, sender) =>
 			query!(candidate_pending_availability(para), sender),
 		Request::CandidateEvents(sender) => query!(candidate_events(), sender),
-		Request::ValidatorDiscovery(ids, sender) => query!(validator_discovery(ids), sender),
+		Request::SessionInfo(index, sender) => query!(session_info(index), sender),
 		Request::DmqContents(id, sender) => query!(dmq_contents(id), sender),
 		Request::InboundHrmpChannelsContents(id, sender) => query!(inbound_hrmp_channels_contents(id), sender),
 	}
@@ -201,8 +201,8 @@ mod tests {
 	use polkadot_primitives::v1::{
 		ValidatorId, ValidatorIndex, GroupRotationInfo, CoreState, PersistedValidationData,
 		Id as ParaId, OccupiedCoreAssumption, ValidationData, SessionIndex, ValidationCode,
-		CommittedCandidateReceipt, CandidateEvent, AuthorityDiscoveryId, InboundDownwardMessage,
-		BlockNumber, InboundHrmpMessage,
+		CommittedCandidateReceipt, CandidateEvent, InboundDownwardMessage,
+		BlockNumber, InboundHrmpMessage, SessionInfo,
 	};
 	use polkadot_node_subsystem_test_helpers as test_helpers;
 	use sp_core::testing::TaskExecutor;
@@ -216,6 +216,7 @@ mod tests {
 		availability_cores: Vec<CoreState>,
 		validation_data: HashMap<ParaId, ValidationData>,
 		session_index_for_child: SessionIndex,
+		session_info: HashMap<SessionIndex, SessionInfo>,
 		validation_code: HashMap<ParaId, ValidationCode>,
 		historical_validation_code: HashMap<ParaId, Vec<(BlockNumber, ValidationCode)>>,
 		validation_outputs_results: HashMap<ParaId, bool>,
@@ -289,6 +290,10 @@ mod tests {
 				self.session_index_for_child.clone()
 			}
 
+			fn session_info(&self, index: SessionIndex) -> Option<SessionInfo> {
+				self.session_info.get(&index).cloned()
+			}
+
 			fn validation_code(
 				&self,
 				para: ParaId,
@@ -321,10 +326,6 @@ mod tests {
 				self.candidate_events.clone()
 			}
 
-			fn validator_discovery(ids: Vec<ValidatorId>) -> Vec<Option<AuthorityDiscoveryId>> {
-				vec![None; ids.len()]
-			}
-
 			fn dmq_contents(
 				&self,
 				recipient: ParaId,
@@ -569,6 +570,33 @@ mod tests {
 		futures::executor::block_on(future::join(subsystem_task, test_task));
 	}
 
+	#[test]
+	fn requests_session_info() {
+		let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+		let mut runtime_api = MockRuntimeApi::default();
+		let session_index = 1;
+		runtime_api.session_info.insert(session_index, Default::default());
+		let runtime_api = Arc::new(runtime_api);
+
+		let relay_parent = [1; 32].into();
+
+		let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None));
+		let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+		let test_task = async move {
+			let (tx, rx) = oneshot::channel();
+
+			ctx_handle.send(FromOverseer::Communication {
+				msg: RuntimeApiMessage::Request(relay_parent, Request::SessionInfo(session_index, tx))
+			}).await;
+
+			assert_eq!(rx.await.unwrap().unwrap(), Some(Default::default()));
+
+			ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+		};
+
+		futures::executor::block_on(future::join(subsystem_task, test_task));
+	}
+
 	#[test]
 	fn requests_validation_code() {
 		let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());

node/network/collator-protocol/src/collator_side.rs

@@ -738,6 +738,7 @@ mod tests {
 	use polkadot_primitives::v1::{
 		BlockData, CandidateDescriptor, CollatorPair, ScheduledCore,
 		ValidatorIndex, GroupRotationInfo, AuthorityDiscoveryId,
+		SessionIndex, SessionInfo,
 	};
 	use polkadot_subsystem::{ActiveLeavesUpdate, messages::{RuntimeApiMessage, RuntimeApiRequest}};
 	use polkadot_node_subsystem_util::TimeoutExt;
@@ -776,6 +777,7 @@ mod tests {
 		relay_parent: Hash,
 		availability_core: CoreState,
 		our_collator_pair: CollatorPair,
+		session_index: SessionIndex,
 	}
 
 	fn validator_pubkeys(val_ids: &[Sr25519Keyring]) -> Vec<ValidatorId> {
@@ -832,6 +834,7 @@ mod tests {
 				relay_parent,
 				availability_core,
 				our_collator_pair,
+				session_index: 1,
 			}
 		}
 	}
@@ -841,6 +844,10 @@ mod tests {
 			&self.validator_groups.0[0]
 		}
 
+		fn current_session_index(&self) -> SessionIndex {
+			self.session_index
+		}
+
 		fn current_group_validator_peer_ids(&self) -> Vec<PeerId> {
 			self.current_group_validator_indices().iter().map(|i| self.validator_peer_id[*i as usize].clone()).collect()
 		}
@@ -870,20 +877,6 @@ mod tests {
 				.collect()
 		}
 
-		fn next_group_validator_ids(&self) -> Vec<ValidatorId> {
-			self.next_group_validator_indices()
-				.iter()
-				.map(|i| self.validator_public[*i as usize].clone())
-				.collect()
-		}
-
-		/// Returns the unique count of validators in the current and next group.
-		fn current_and_next_group_unique_validator_count(&self) -> usize {
-			let mut indices = self.next_group_validator_indices().iter().collect::<HashSet<_>>();
-			indices.extend(self.current_group_validator_indices());
-			indices.len()
-		}
-
 		/// Generate a new relay parent and inform the subsystem about the new view.
 		///
 		/// If `merge_views == true` it means the subsystem will be informed that we working on the old `relay_parent`
@@ -1090,20 +1083,33 @@ mod tests {
 			overseer_recv(virtual_overseer).await,
 			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
 				relay_parent,
-				RuntimeApiRequest::ValidatorDiscovery(validators, tx),
+				RuntimeApiRequest::SessionIndexForChild(tx),
 			)) => {
 				assert_eq!(relay_parent, test_state.relay_parent);
-				assert_eq!(validators.len(), test_state.current_and_next_group_unique_validator_count());
+				tx.send(Ok(test_state.current_session_index())).unwrap();
+			}
+		);
 
-				let current_validators = test_state.current_group_validator_ids();
-				let next_validators = test_state.next_group_validator_ids();
+		assert_matches!(
+			overseer_recv(virtual_overseer).await,
+			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+				relay_parent,
+				RuntimeApiRequest::SessionInfo(index, tx),
+			)) => {
+				assert_eq!(relay_parent, test_state.relay_parent);
+				assert_eq!(index, test_state.current_session_index());
 
-				assert!(validators.iter().all(|v| current_validators.contains(&v) || next_validators.contains(&v)));
+				let validators = test_state.current_group_validator_ids();
+				let current_discovery_keys = test_state.current_group_validator_authority_ids();
+				let next_discovery_keys = test_state.next_group_validator_authority_ids();
 
-				let current_validators = test_state.current_group_validator_authority_ids();
-				let next_validators = test_state.next_group_validator_authority_ids();
+				let discovery_keys = [&current_discovery_keys[..], &next_discovery_keys[..]].concat();
 
-				tx.send(Ok(current_validators.into_iter().chain(next_validators).map(Some).collect())).unwrap();
+				tx.send(Ok(Some(SessionInfo {
+					validators,
+					discovery_keys,
+					..Default::default()
+				}))).unwrap();
 			}
 		);
 

node/network/collator-protocol/src/lib.rs

@@ -60,16 +60,6 @@ enum Error {
 	Prometheus(#[from] prometheus::PrometheusError),
 }
 
-impl From<util::validator_discovery::Error> for Error {
-	fn from(me: util::validator_discovery::Error) -> Self {
-		match me {
-			util::validator_discovery::Error::Subsystem(s) => Error::Subsystem(s),
-			util::validator_discovery::Error::RuntimeApi(ra) => Error::RuntimeApi(ra),
-			util::validator_discovery::Error::Oneshot(c) => Error::Oneshot(c),
-		}
-	}
-}
-
 type Result<T> = std::result::Result<T, Error>;
 
 /// What side of the collator protocol is being engaged

node/network/pov-distribution/src/error.rs

@@ -27,8 +27,6 @@ pub enum Error {
 	#[error(transparent)]
 	Runtime(#[from] polkadot_subsystem::errors::RuntimeApiError),
 	#[error(transparent)]
-	ValidatorDiscovery(#[from] polkadot_node_subsystem_util::validator_discovery::Error),
-	#[error(transparent)]
 	Util(#[from] polkadot_node_subsystem_util::Error),
 }