Replace RollingSessionWindow in approval-voting with RuntimeInfo

node/core/approval-voting/src/import.rs

@@ -40,10 +40,7 @@ use polkadot_node_subsystem::{
 	},
 	overseer, RuntimeApiError, SubsystemError, SubsystemResult,
 };
-use polkadot_node_subsystem_util::{
-	determine_new_blocks,
-	rolling_session_window::{RollingSessionWindow, SessionWindowUpdate},
-};
+use polkadot_node_subsystem_util::determine_new_blocks;
 use polkadot_primitives::{
 	BlockNumber, CandidateEvent, CandidateHash, CandidateReceipt, ConsensusLog, CoreIndex,
 	GroupIndex, Hash, Header, SessionIndex,
@@ -59,9 +56,12 @@ use std::collections::HashMap;
 use super::approval_db::v1;
 use crate::{
 	backend::{Backend, OverlayedBackend},
+	cache_session_info_for_head,
 	criteria::{AssignmentCriteria, OurAssignment},
+	get_session_info,
 	persisted_entries::CandidateEntry,
 	time::{slot_number_to_tick, Tick},
+	SessionInfoProvider,
 };
 
 use super::{State, LOG_TARGET};
@@ -78,7 +78,7 @@ struct ImportedBlockInfo {
 }
 
 struct ImportedBlockInfoEnv<'a> {
-	session_window: &'a Option<RollingSessionWindow>,
+	runtime_info: &'a mut Option<SessionInfoProvider>, // this is required just for the `earliest_session()`
 	assignment_criteria: &'a (dyn AssignmentCriteria + Send + Sync),
 	keystore: &'a LocalKeystore,
 }
@@ -160,11 +160,7 @@ async fn imported_block_info<Context>(
 				return Err(ImportedBlockInfoError::FutureCancelled("SessionIndexForChild", error)),
 		};
 
-		if env
-			.session_window
-			.as_ref()
-			.map_or(true, |s| session_index < s.earliest_session())
-		{
+		if env.runtime_info.as_ref().map_or(true, |s| session_index < s.earliest_session()) {
 			gum::debug!(
 				target: LOG_TARGET,
 				"Block {} is from ancient session {}. Skipping",
@@ -212,15 +208,19 @@ async fn imported_block_info<Context>(
 		}
 	};
 
-	let session_info = match env.session_window.as_ref().and_then(|s| s.session_info(session_index))
-	{
-		Some(s) => s,
-		None => {
-			gum::debug!(target: LOG_TARGET, "Session info unavailable for block {}", block_hash,);
-
-			return Err(ImportedBlockInfoError::SessionInfoUnavailable)
-		},
-	};
+	let session_info =
+		match get_session_info(env.runtime_info, ctx.sender(), block_hash, session_index).await {
+			Some(session_info) => session_info,
+			None => {
+				gum::error!(
+					target: LOG_TARGET,
+					relay_parent = ?block_hash,
+					session = session_index,
+					"Session info unavailable"
+				);
+				return Err(ImportedBlockInfoError::SessionInfoUnavailable)
+			},
+		};
 
 	let (assignments, slot, relay_vrf_story) = {
 		let unsafe_vrf = approval_types::babe_unsafe_vrf_info(&block_header);
@@ -323,8 +323,9 @@ pub struct BlockImportedCandidates {
 #[overseer::contextbounds(ApprovalVoting, prefix = self::overseer)]
 pub(crate) async fn handle_new_head<Context, B: Backend>(
 	ctx: &mut Context,
-	state: &mut State,
+	state: &State,
 	db: &mut OverlayedBackend<'_, B>,
+	session_info_provider: &mut Option<SessionInfoProvider>,
 	head: Hash,
 	finalized_number: &Option<BlockNumber>,
 ) -> SubsystemResult<Vec<BlockImportedCandidates>> {
@@ -360,25 +361,7 @@ pub(crate) async fn handle_new_head<Context, B: Backend>(
 	};
 
 	// Update session info based on most recent head.
-	match state.cache_session_info_for_head(ctx, head).await {
-		Err(e) => {
-			gum::debug!(
-				target: LOG_TARGET,
-				?head,
-				?e,
-				"Could not cache session info when processing head.",
-			);
-			return Ok(Vec::new())
-		},
-		Ok(Some(a @ SessionWindowUpdate::Advanced { .. })) => {
-			gum::info!(
-				target: LOG_TARGET,
-				update = ?a,
-				"Advanced session window for approvals",
-			);
-		},
-		Ok(_) => {},
-	}
+	cache_session_info_for_head(ctx.sender(), head, session_info_provider).await;
 
 	// If we've just started the node and are far behind,
 	// import at most `MAX_HEADS_LOOK_BACK` blocks.
@@ -407,7 +390,7 @@ pub(crate) async fn handle_new_head<Context, B: Backend>(
 		let mut imported_blocks_and_info = Vec::with_capacity(new_blocks.len());
 		for (block_hash, block_header) in new_blocks.into_iter().rev() {
 			let env = ImportedBlockInfoEnv {
-				session_window: &state.session_window,
+				runtime_info: session_info_provider,
 				assignment_criteria: &*state.assignment_criteria,
 				keystore: &state.keystore,
 			};
@@ -461,11 +444,25 @@ pub(crate) async fn handle_new_head<Context, B: Backend>(
 			force_approve,
 		} = imported_block_info;
 
-		let session_info = state
-			.session_window
-			.as_ref()
-			.and_then(|s| s.session_info(session_index))
-			.expect("imported_block_info requires session info to be available; qed");
+		let session_info = match get_session_info(
+			session_info_provider,
+			ctx.sender(),
+			head,
+			session_index,
+		)
+		.await
+		{
+			Some(session_info) => session_info,
+			None => {
+				gum::error!(
+					target: LOG_TARGET,
+					session = session_index,
+					?head,
+					"Can't get session info for the new head"
+				);
+				return Ok(Vec::new())
+			},
+		};
 
 		let (block_tick, no_show_duration) = {
 			let block_tick = slot_number_to_tick(state.slot_duration_millis, slot);
@@ -609,13 +606,19 @@ pub(crate) async fn handle_new_head<Context, B: Backend>(
 #[cfg(test)]
 pub(crate) mod tests {
 	use super::*;
-	use crate::approval_db::v1::DbBackend;
+	use crate::{approval_db::v1::DbBackend, RuntimeInfo, RuntimeInfoConfig};
 	use ::test_helpers::{dummy_candidate_receipt, dummy_hash};
 	use assert_matches::assert_matches;
-	use polkadot_node_primitives::approval::{VrfSignature, VrfTranscript};
+	use polkadot_node_primitives::{
+		approval::{VrfSignature, VrfTranscript},
+		DISPUTE_WINDOW,
+	};
 	use polkadot_node_subsystem::messages::{AllMessages, ApprovalVotingMessage};
 	use polkadot_node_subsystem_test_helpers::make_subsystem_context;
-	use polkadot_node_subsystem_util::database::Database;
+	use polkadot_node_subsystem_util::{
+		database::Database,
+		runtime::{ExtendedSessionInfo, ValidatorInfo},
+	};
 	use polkadot_primitives::{Id as ParaId, IndexedVec, SessionInfo, ValidatorId, ValidatorIndex};
 	pub(crate) use sp_consensus_babe::{
 		digests::{CompatibleDigestItem, PreDigest, SecondaryVRFPreDigest},
@@ -624,7 +627,7 @@ pub(crate) mod tests {
 	use sp_core::{crypto::VrfSigner, testing::TaskExecutor};
 	use sp_keyring::sr25519::Keyring as Sr25519Keyring;
 	pub(crate) use sp_runtime::{Digest, DigestItem};
-	use std::{pin::Pin, sync::Arc};
+	use std::{num::NonZeroUsize, pin::Pin, sync::Arc};
 
 	use crate::{approval_db::v1::Config as DatabaseConfig, criteria, BlockEntry};
 
@@ -649,26 +652,42 @@ pub(crate) mod tests {
 	}
 
 	fn blank_state() -> State {
-		let db = kvdb_memorydb::create(NUM_COLUMNS);
-		let db = polkadot_node_subsystem_util::database::kvdb_impl::DbAdapter::new(db, &[]);
-		let db: Arc<dyn Database> = Arc::new(db);
 		State {
-			session_window: None,
 			keystore: Arc::new(LocalKeystore::in_memory()),
 			slot_duration_millis: 6_000,
 			clock: Box::new(MockClock::default()),
 			assignment_criteria: Box::new(MockAssignmentCriteria),
-			db,
-			db_config: TEST_CONFIG,
 			spans: HashMap::new(),
 		}
 	}
 
-	fn single_session_state(index: SessionIndex, info: SessionInfo) -> State {
-		State {
-			session_window: Some(RollingSessionWindow::with_session_info(index, vec![info])),
-			..blank_state()
-		}
+	fn single_session_state(
+		index: SessionIndex,
+		info: SessionInfo,
+		relay_parent: Hash,
+	) -> (State, SessionInfoProvider) {
+		let runtime_info = RuntimeInfo::new_with_cache(
+			RuntimeInfoConfig {
+				keystore: None,
+				session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+					.expect("DISPUTE_WINDOW can't be 0; qed."),
+			},
+			vec![(
+				index,
+				relay_parent,
+				ExtendedSessionInfo {
+					session_info: info,
+					validator_info: ValidatorInfo { our_group: None, our_index: None },
+				},
+			)],
+		);
+
+		let state = blank_state();
+
+		let session_info_provider =
+			SessionInfoProvider { runtime_info, gaps_in_cache: false, highest_session_seen: index };
+
+		(state, session_info_provider)
 	}
 
 	struct MockAssignmentCriteria;
@@ -776,13 +795,30 @@ pub(crate) mod tests {
 				.map(|(r, c, g)| (r.hash(), r.clone(), *c, *g))
 				.collect::<Vec<_>>();
 
-			let session_window =
-				RollingSessionWindow::with_session_info(session, vec![session_info]);
+			let session_info_provider = SessionInfoProvider {
+				runtime_info: RuntimeInfo::new_with_cache(
+					RuntimeInfoConfig {
+						keystore: None,
+						session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+							.expect("DISPUTE_WINDOW can't be 0; qed."),
+					},
+					vec![(
+						session,
+						hash,
+						ExtendedSessionInfo {
+							session_info,
+							validator_info: ValidatorInfo { our_index: None, our_group: None },
+						},
+					)],
+				),
+				gaps_in_cache: false,
+				highest_session_seen: session,
+			};
 
 			let header = header.clone();
 			Box::pin(async move {
 				let env = ImportedBlockInfoEnv {
-					session_window: &Some(session_window),
+					runtime_info: &mut Some(session_info_provider),
 					assignment_criteria: &MockAssignmentCriteria,
 					keystore: &LocalKeystore::in_memory(),
 				};
@@ -882,13 +918,30 @@ pub(crate) mod tests {
 			.collect::<Vec<_>>();
 
 		let test_fut = {
-			let session_window =
-				RollingSessionWindow::with_session_info(session, vec![session_info]);
+			let session_info_provider = SessionInfoProvider {
+				runtime_info: RuntimeInfo::new_with_cache(
+					RuntimeInfoConfig {
+						keystore: None,
+						session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+							.expect("DISPUTE_WINDOW can't be 0; qed."),
+					},
+					vec![(
+						session,
+						hash,
+						ExtendedSessionInfo {
+							session_info,
+							validator_info: ValidatorInfo { our_index: None, our_group: None },
+						},
+					)],
+				),
+				gaps_in_cache: false,
+				highest_session_seen: session,
+			};
 
 			let header = header.clone();
 			Box::pin(async move {
 				let env = ImportedBlockInfoEnv {
-					session_window: &Some(session_window),
+					runtime_info: &mut Some(session_info_provider),
 					assignment_criteria: &MockAssignmentCriteria,
 					keystore: &LocalKeystore::in_memory(),
 				};
@@ -982,12 +1035,12 @@ pub(crate) mod tests {
 			.collect::<Vec<_>>();
 
 		let test_fut = {
-			let session_window = None;
+			let mut runtime_info = None;
 
 			let header = header.clone();
 			Box::pin(async move {
 				let env = ImportedBlockInfoEnv {
-					session_window: &session_window,
+					runtime_info: &mut runtime_info,
 					assignment_criteria: &MockAssignmentCriteria,
 					keystore: &LocalKeystore::in_memory(),
 				};
@@ -1077,13 +1130,30 @@ pub(crate) mod tests {
 				.map(|(r, c, g)| (r.hash(), r.clone(), *c, *g))
 				.collect::<Vec<_>>();
 
-			let session_window =
-				Some(RollingSessionWindow::with_session_info(session, vec![session_info]));
+			let session_info_provider = SessionInfoProvider {
+				runtime_info: RuntimeInfo::new_with_cache(
+					RuntimeInfoConfig {
+						keystore: None,
+						session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+							.expect("DISPUTE_WINDOW can't be 0; qed."),
+					},
+					vec![(
+						session,
+						hash,
+						ExtendedSessionInfo {
+							session_info,
+							validator_info: ValidatorInfo { our_index: None, our_group: None },
+						},
+					)],
+				),
+				gaps_in_cache: false,
+				highest_session_seen: session,
+			};
 
 			let header = header.clone();
 			Box::pin(async move {
 				let env = ImportedBlockInfoEnv {
-					session_window: &session_window,
+					runtime_info: &mut Some(session_info_provider),
 					assignment_criteria: &MockAssignmentCriteria,
 					keystore: &LocalKeystore::in_memory(),
 				};
@@ -1220,7 +1290,8 @@ pub(crate) mod tests {
 			.map(|(r, c, g)| CandidateEvent::CandidateIncluded(r, Vec::new().into(), c, g))
 			.collect::<Vec<_>>();
 
-		let mut state = single_session_state(session, session_info);
+		let (state, session_info_provider) =
+			single_session_state(session, session_info, parent_hash);
 		overlay_db.write_block_entry(
 			v1::BlockEntry {
 				block_hash: parent_hash,
@@ -1242,9 +1313,16 @@ pub(crate) mod tests {
 		let test_fut = {
 			Box::pin(async move {
 				let mut overlay_db = OverlayedBackend::new(&db);
-				let result = handle_new_head(&mut ctx, &mut state, &mut overlay_db, hash, &Some(1))
-					.await
-					.unwrap();
+				let result = handle_new_head(
+					&mut ctx,
+					&state,
+					&mut overlay_db,
+					&mut Some(session_info_provider),
+					hash,
+					&Some(1),
+				)
+				.await
+				.unwrap();
 
 				let write_ops = overlay_db.into_write_ops();
 				db.write(write_ops).unwrap();