Scraper processes CandidateBacked events

paritytech · eskimor · Nov 11, 2022 · Oct 5, 2022 · Oct 5, 2022 · Oct 7, 2022
commit 56731cf6feed7801571ab288dc955accf462a9c6
diff --git a/node/core/dispute-coordinator/src/scraping/mod.rs b/node/core/dispute-coordinator/src/scraping/mod.rs
@@ -66,6 +66,8 @@ const LRU_OBSERVED_BLOCKS_CAPACITY: NonZeroUsize = match NonZeroUsize::new(20) {
 pub struct ChainScraper {
 	/// All candidates we have seen included, which not yet have been finalized.
 	included_candidates: HashSet<CandidateHash>,
+	/// All candidates we have seen backed
+	backed_candidates: HashSet<CandidateHash>,
 	/// including block -> `CandidateHash`
 	///
 	/// We need this to clean up `included_candidates` on finalization.
@@ -97,6 +99,7 @@ impl ChainScraper {
 	{
 		let mut s = Self {
 			included_candidates: HashSet::new(),
+			backed_candidates: HashSet::new(),
 			candidates_by_block_number: BTreeMap::new(),
 			last_observed_blocks: LruCache::new(LRU_OBSERVED_BLOCKS_CAPACITY),
 		};
@@ -111,6 +114,11 @@ impl ChainScraper {
 		self.included_candidates.contains(candidate_hash)
 	}
 
+	/// Check whether the candidate is backed
+	pub fn is_candidate_backed(&mut self, candidate_hash: &CandidateHash) -> bool {
+		self.backed_candidates.contains(candidate_hash)
+	}
+
 	/// Query active leaves for any candidate `CandidateEvent::CandidateIncluded` events.
 	///
 	/// and updates current heads, so we can query candidates for all non finalized blocks.
@@ -182,28 +190,49 @@ impl ChainScraper {
 	where
 		Sender: overseer::DisputeCoordinatorSenderTrait,
 	{
-		// Get included events:
-		let included =
+		// Get included and backed events:
+		let events =
 			get_candidate_events(sender, block_hash)
 				.await?
 				.into_iter()
-				.filter_map(|ev| match ev {
-					CandidateEvent::CandidateIncluded(receipt, _, _, _) => Some(receipt),
-					_ => None,
+				.filter(|ev| match ev {
+					CandidateEvent::CandidateIncluded(_, _, _, _) => true,
+					CandidateEvent::CandidateBacked(_, _, _, _) => true,
+					_ => false,
 				});
-		for receipt in included {
-			let candidate_hash = receipt.hash();
-			gum::trace!(
-				target: LOG_TARGET,
-				?candidate_hash,
-				?block_number,
-				"Processing included event"
-			);
-			self.included_candidates.insert(candidate_hash);
-			self.candidates_by_block_number
-				.entry(block_number)
-				.or_default()
-				.insert(candidate_hash);
+		for ev in events {
+			match ev {
+				CandidateEvent::CandidateIncluded(receipt, _, _, _) => {
+					let candidate_hash = receipt.hash();
+					gum::trace!(
+						target: LOG_TARGET,
+						?candidate_hash,
+						?block_number,
+						"Processing included event"
+					);
+					self.included_candidates.insert(candidate_hash);
+					self.candidates_by_block_number
+						.entry(block_number)
+						.or_default()
+						.insert(candidate_hash);
+				},
+				CandidateEvent::CandidateBacked(receipt, _, _, _) => {
+					let candidate_hash = receipt.hash();
+					gum::trace!(
+						target: LOG_TARGET,
+						?candidate_hash,
+						?block_number,
+						"Processing backed event"
+					);
+					self.backed_candidates.insert(candidate_hash);
+				},
+				_ => {
+					debug_assert!(
+						false,
+						"Candidates are already filtered out. There should be nothing unexpected."
+					)
+				},
+			}
 		}
 		Ok(())
 	}

diff --git a/node/core/dispute-coordinator/src/scraping/tests.rs b/node/core/dispute-coordinator/src/scraping/tests.rs
@@ -145,13 +145,22 @@ fn get_block_number_hash(n: BlockNumber) -> Hash {
 }
 
 /// Get a dummy event that corresponds to candidate inclusion for the given block number.
-fn get_candidate_included_events(block_number: BlockNumber) -> Vec<CandidateEvent> {
-	vec![CandidateEvent::CandidateIncluded(
-		make_candidate_receipt(get_block_number_hash(block_number)),
-		HeadData::default(),
-		CoreIndex::from(0),
-		GroupIndex::from(0),
-	)]
+fn get_candidate_events(block_number: BlockNumber) -> Vec<CandidateEvent> {
+	let candidate_receipt = make_candidate_receipt(get_block_number_hash(block_number));
+	vec![
+		CandidateEvent::CandidateIncluded(
+			candidate_receipt.clone(),
+			HeadData::default(),
+			CoreIndex::from(0),
+			GroupIndex::from(0),
+		),
+		CandidateEvent::CandidateBacked(
+			candidate_receipt,
+			HeadData::default(),
+			CoreIndex::from(0),
+			GroupIndex::from(0),
+		),
+	]
 }
 
 async fn assert_candidate_events_request(virtual_overseer: &mut VirtualOverseer, chain: &[Hash]) {
@@ -163,7 +172,7 @@ async fn assert_candidate_events_request(virtual_overseer: &mut VirtualOverseer,
 		)) => {
 			let maybe_block_number = chain.iter().position(|h| *h == hash);
 			let response = maybe_block_number
-				.map(|num| get_candidate_included_events(num as u32))
+				.map(|num| get_candidate_events(num as u32))
 				.unwrap_or_default();
 			tx.send(Ok(response)).unwrap();
 		}
@@ -236,7 +245,9 @@ fn scraper_provides_included_state_when_initialized() {
 		let TestState { mut chain, mut scraper, mut ctx } = state;
 
 		assert!(!scraper.is_candidate_included(&candidate_2.hash()));
+		assert!(!scraper.is_candidate_backed(&candidate_2.hash()));
 		assert!(scraper.is_candidate_included(&candidate_1.hash()));
+		assert!(scraper.is_candidate_backed(&candidate_1.hash()));
 
 		// After next active leaves update we should see the candidate included.
 		let next_update = next_leaf(&mut chain);
@@ -253,6 +264,7 @@ fn scraper_provides_included_state_when_initialized() {
 			.await;
 
 		assert!(scraper.is_candidate_included(&candidate_2.hash()));
+		assert!(scraper.is_candidate_backed(&candidate_2.hash()));
 	});
 }
 
@@ -282,6 +294,7 @@ fn scraper_requests_candidates_of_leaf_ancestors() {
 		for block_number in 1..next_block_number {
 			let candidate = make_candidate_receipt(get_block_number_hash(block_number));
 			assert!(scraper.is_candidate_included(&candidate.hash()));
+			assert!(scraper.is_candidate_backed(&candidate.hash()));
 		}
 	});
 }