Refactor check_validation_outputs

runtime/parachains/src/inclusion/mod.rs

@@ -514,6 +514,7 @@ impl<T: Config> Pallet<T> {
 				if let FullCheck::Yes = full_check {
 					check_ctx.verify_backed_candidate(
 						parent_hash,
+						parent_storage_root,
 						candidate_idx,
 						backed_candidate,
 					)?;
@@ -533,32 +534,6 @@ impl<T: Config> Pallet<T> {
 							);
 						}
 
-						{
-							// this should never fail because the para is registered
-							let persisted_validation_data =
-								match crate::util::make_persisted_validation_data::<T>(
-									para_id,
-									relay_parent_number,
-									parent_storage_root,
-								) {
-									Some(l) => l,
-									None => {
-										// We don't want to error out here because it will
-										// brick the relay-chain. So we return early without
-										// doing anything.
-										return Ok(ProcessedCandidates::default())
-									},
-								};
-
-							let expected = persisted_validation_data.hash();
-
-							ensure!(
-								expected ==
-									backed_candidate.descriptor().persisted_validation_data_hash,
-								Error::<T>::ValidationDataHashMismatch,
-							);
-						}
-
 						ensure!(
 							<PendingAvailability<T>>::get(&para_id).is_none() &&
 								<PendingAvailabilityCommitments<T>>::get(&para_id).is_none(),
@@ -955,10 +930,37 @@ impl<T: Config> CandidateCheckContext<T> {
 	pub(crate) fn verify_backed_candidate(
 		&self,
 		parent_hash: <T as frame_system::Config>::Hash,
+		parent_storage_root: T::Hash,
 		candidate_idx: usize,
 		backed_candidate: &BackedCandidate<<T as frame_system::Config>::Hash>,
 	) -> Result<(), Error<T>> {
 		let para_id = backed_candidate.descriptor().para_id;
+		let now = <frame_system::Pallet<T>>::block_number();
+		let relay_parent_number = now - One::one();
+
+		{
+			// this should never fail because the para is registered
+			let persisted_validation_data = match crate::util::make_persisted_validation_data::<T>(
+				para_id,
+				relay_parent_number,
+				parent_storage_root,
+			) {
+				Some(l) => l,
+				None => {
+					// We don't want to error out here because it will
+					// brick the relay-chain. So we return early without
+					// doing anything.
+					return Ok(())
+				},
+			};
+
+			let expected = persisted_validation_data.hash();
+
+			ensure!(
+				expected == backed_candidate.descriptor().persisted_validation_data_hash,
+				Error::<T>::ValidationDataHashMismatch,
+			);
+		}
 
 		// we require that the candidate is in the context of the parent block.
 		ensure!(

runtime/parachains/src/paras_inherent/mod.rs

@@ -594,6 +594,7 @@ impl<T: Config> Pallet<T> {
 				let scheduled = <scheduler::Pallet<T>>::scheduled();
 
 				let relay_parent_number = now - One::one();
+				let parent_storage_root = parent_header.state_root().clone();
 
 				let check_ctx = CandidateCheckContext::<T>::new(now, relay_parent_number);
 				let backed_candidates = sanitize_backed_candidates::<T, _>(
@@ -609,7 +610,7 @@ impl<T: Config> Pallet<T> {
 							// That way we avoid possible duplicate checks while assuring all
 							// backed candidates fine to pass on.
 							check_ctx
-								.verify_backed_candidate(parent_hash, candidate_idx, backed_candidate)
+								.verify_backed_candidate(parent_hash, parent_storage_root, candidate_idx, backed_candidate)
 								.is_err()
 					},
 					&scheduled[..],