refactor validation data: runtime

runtime/parachains/src/configuration.rs

@@ -19,13 +19,12 @@
 //! Configuration can change only at session boundaries and is buffered until then.
 
 use sp_std::prelude::*;
-use primitives::v1::{ValidatorId, GlobalValidationData};
+use primitives::v1::ValidatorId;
 use frame_support::{
 	decl_storage, decl_module, decl_error,
 	dispatch::DispatchResult,
 	weights::{DispatchClass, Weight},
 };
-use sp_runtime::traits::One;
 use codec::{Encode, Decode};
 use frame_system::ensure_root;
 
@@ -220,16 +219,6 @@ impl<T: Trait> Module<T> {
 			<Self as Store>::PendingConfig::set(Some(prev));
 		}
 	}
-
-	/// Computes the global validation-data, assuming the context of the parent block.
-	pub(crate) fn global_validation_data() -> GlobalValidationData<T::BlockNumber> {
-		let config = Self::config();
-		GlobalValidationData {
-			max_code_size: config.max_code_size,
-			max_head_data_size: config.max_head_data_size,
-			block_number: <frame_system::Module<T>>::block_number() - One::one(),
-		}
-	}
 }
 
 #[cfg(test)]

runtime/parachains/src/inclusion.rs

@@ -22,7 +22,6 @@
 
 use sp_std::prelude::*;
 use primitives::v1::{
-	validation_data_hash,
 	ValidatorId, CandidateCommitments, CandidateDescriptor, ValidatorIndex, Id as ParaId,
 	AvailabilityBitfield as AvailabilityBitfield, SignedAvailabilityBitfields, SigningContext,
 	BackedCandidate, CoreIndex, GroupIndex, CoreAssignment, CommittedCandidateReceipt,
@@ -435,23 +434,18 @@ impl<T: Trait> Module<T> {
 
 						{
 							// this should never fail because the para is registered
-							let (global_validation_data, local_validation_data) = (
-								<configuration::Module<T>>::global_validation_data(),
-								match <paras::Module<T>>::local_validation_data(para_id) {
+							let persisted_validation_data =
+								match crate::util::make_persisted_validation_data::<T>(para_id) {
 									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(Vec::new());
 									}
-								}
-							);
+								};
 
-							let expected = validation_data_hash(
-								&global_validation_data,
-								&local_validation_data,
-							);
+							let expected = persisted_validation_data.hash();
 
 							ensure!(
 								expected == candidate.descriptor().validation_data_hash,
@@ -875,9 +869,9 @@ mod tests {
 	}
 
 	fn make_vdata_hash(para_id: ParaId) -> Option<Hash> {
-		let global_validation_data = Configuration::global_validation_data();
-		let local_validation_data = Paras::local_validation_data(para_id)?;
-		Some(validation_data_hash(&global_validation_data, &local_validation_data))
+		let persisted_validation_data
+			= crate::util::make_persisted_validation_data::<Test>(para_id)?;
+		Some(persisted_validation_data.hash())
 	}
 
 	#[test]

runtime/parachains/src/lib.rs

@@ -38,6 +38,8 @@ pub mod validity;
 
 pub mod runtime_api_impl;
 
+mod util;
+
 #[cfg(test)]
 mod mock;
 

runtime/parachains/src/paras.rs

@@ -25,9 +25,8 @@
 
 use sp_std::prelude::*;
 use sp_std::marker::PhantomData;
-use sp_runtime::traits::{One, BlakeTwo256, Hash as HashT, Saturating};
 use primitives::v1::{
-	Id as ParaId, ValidationCode, HeadData, LocalValidationData,
+	Id as ParaId, ValidationCode, HeadData,
 };
 use frame_support::{
 	decl_storage, decl_module, decl_error,
@@ -549,37 +548,6 @@ impl<T: Trait> Module<T> {
 
 		Self::past_code_meta(&id).most_recent_change()
 	}
-
-	/// Compute the local-validation data based on the head of the para. This assumes the
-	/// relay-parent is the parent of the current block.
-	pub(crate) fn local_validation_data(para_id: ParaId) -> Option<LocalValidationData<T::BlockNumber>> {
-		let relay_parent_number = <frame_system::Module<T>>::block_number() - One::one();
-
-		let config = <configuration::Module<T>>::config();
-		let freq = config.validation_upgrade_frequency;
-		let delay = config.validation_upgrade_delay;
-
-		let last_code_upgrade = Self::last_code_upgrade(para_id, true);
-		let can_upgrade_code = last_code_upgrade.map_or(
-			true,
-			|l| { l <= relay_parent_number && relay_parent_number.saturating_sub(l) >= freq },
-		);
-
-		let code_upgrade_allowed = if can_upgrade_code {
-			Some(relay_parent_number + delay)
-		} else {
-			None
-		};
-
-		Some(LocalValidationData {
-			parent_head: Self::para_head(&para_id)?,
-			balance: 0,
-			validation_code_hash: BlakeTwo256::hash_of(
-				&Self::current_code(&para_id)?
-			),
-			code_upgrade_allowed,
-		})
-	}
 }
 
 #[cfg(test)]

runtime/parachains/src/runtime_api_impl/v1.rs

@@ -19,10 +19,10 @@
 
 use sp_std::prelude::*;
 use primitives::v1::{
-	ValidatorId, ValidatorIndex, GroupRotationInfo, CoreState, GlobalValidationData,
-	Id as ParaId, OccupiedCoreAssumption, LocalValidationData, SessionIndex, ValidationCode,
+	ValidatorId, ValidatorIndex, GroupRotationInfo, CoreState, ValidationData,
+	Id as ParaId, OccupiedCoreAssumption, SessionIndex, ValidationCode,
 	CommittedCandidateReceipt, ScheduledCore, OccupiedCore, CoreOccupied, CoreIndex,
-	GroupIndex, CandidateEvent,
+	GroupIndex, CandidateEvent, PersistedValidationData,
 };
 use sp_runtime::traits::Zero;
 use frame_support::debug;
@@ -161,36 +161,61 @@ pub fn availability_cores<T: initializer::Trait>() -> Vec<CoreState<T::BlockNumb
 	core_states
 }
 
-/// Implementation for the `global_validation_data` function of the runtime API.
-pub fn global_validation_data<T: initializer::Trait>()
-	-> GlobalValidationData<T::BlockNumber>
-{
-	<configuration::Module<T>>::global_validation_data()
-}
-
-/// Implementation for the `local_validation_data` function of the runtime API.
-pub fn local_validation_data<T: initializer::Trait>(
+fn with_assumption<Trait, T, F>(
 	para_id: ParaId,
 	assumption: OccupiedCoreAssumption,
-) -> Option<LocalValidationData<T::BlockNumber>> {
+	build: F,
+) -> Option<T> where
+	Trait: inclusion::Trait,
+	F: FnOnce() -> Option<T>,
+{
 	match assumption {
 		OccupiedCoreAssumption::Included => {
-			<inclusion::Module<T>>::force_enact(para_id);
-			<paras::Module<T>>::local_validation_data(para_id)
+			<inclusion::Module<Trait>>::force_enact(para_id);
+			build()
 		}
 		OccupiedCoreAssumption::TimedOut => {
-			<paras::Module<T>>::local_validation_data(para_id)
+			build()
 		}
 		OccupiedCoreAssumption::Free => {
-			if <inclusion::Module<T>>::pending_availability(para_id).is_some() {
+			if <inclusion::Module<Trait>>::pending_availability(para_id).is_some() {
 				None
 			} else {
-				<paras::Module<T>>::local_validation_data(para_id)
+				build()
 			}
 		}
 	}
 }
 
+/// Implementation for the `full_validation_data` function of the runtime API.
+pub fn full_validation_data<T: initializer::Trait>(
+	para_id: ParaId,
+	assumption: OccupiedCoreAssumption,
+)
+	-> Option<ValidationData<T::BlockNumber>>
+{
+	with_assumption::<T, _, _>(
+		para_id,
+		assumption,
+		|| Some(ValidationData {
+			persisted: crate::util::make_persisted_validation_data::<T>(para_id)?,
+			transient: crate::util::make_transient_validation_data::<T>(para_id)?,
+		}),
+	)
+}
+
+/// Implementation for the `persisted_validation_data` function of the runtime API.
+pub fn persisted_validation_data<T: initializer::Trait>(
+	para_id: ParaId,
+	assumption: OccupiedCoreAssumption,
+) -> Option<PersistedValidationData<T::BlockNumber>> {
+	with_assumption::<T, _, _>(
+		para_id,
+		assumption,
+		|| crate::util::make_persisted_validation_data::<T>(para_id),
+	)
+}
+
 /// Implementation for the `session_index_for_child` function of the runtime API.
 pub fn session_index_for_child<T: initializer::Trait>() -> SessionIndex {
 	// Just returns the session index from `inclusion`. Runtime APIs follow
@@ -208,26 +233,11 @@ pub fn validation_code<T: initializer::Trait>(
 	para_id: ParaId,
 	assumption: OccupiedCoreAssumption,
 ) -> Option<ValidationCode> {
-	let fetch = || {
-		<paras::Module<T>>::current_code(&para_id)
-	};
-
-	match assumption {
-		OccupiedCoreAssumption::Included => {
-			<inclusion::Module<T>>::force_enact(para_id);
-			fetch()
-		}
-		OccupiedCoreAssumption::TimedOut => {
-			fetch()
-		}
-		OccupiedCoreAssumption::Free => {
-			if <inclusion::Module<T>>::pending_availability(para_id).is_some() {
-				None
-			} else {
-				fetch()
-			}
-		}
-	}
+	with_assumption::<T, _, _>(
+		para_id,
+		assumption,
+		|| <paras::Module<T>>::current_code(&para_id),
+	)
 }
 
 /// Implementation for the `candidate_pending_availability` function of the runtime API.

runtime/parachains/src/util.rs

@@ -0,0 +1,70 @@
+// Copyright 2017-2020 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Utilities that don't belong to any particular module but may draw
+//! on all modules.
+
+use sp_runtime::traits::{One, Saturating};
+use primitives::v1::{Id as ParaId, PersistedValidationData, TransientValidationData};
+
+use crate::{configuration, paras};
+
+/// Make the persisted validation data for a particular parachain.
+///
+/// This ties together the storage of several modules.
+pub fn make_persisted_validation_data<T: paras::Trait>(
+	para_id: ParaId,
+) -> Option<PersistedValidationData<T::BlockNumber>> {
+	let relay_parent_number = <frame_system::Module<T>>::block_number() - One::one();
+
+	let config = <configuration::Module<T>>::config();
+	let freq = config.validation_upgrade_frequency;
+	let delay = config.validation_upgrade_delay;
+
+	let last_code_upgrade = <paras::Module<T>>::last_code_upgrade(para_id, true);
+	let can_upgrade_code = last_code_upgrade.map_or(
+		true,
+		|l| { l <= relay_parent_number && relay_parent_number.saturating_sub(l) >= freq },
+	);
+
+	let code_upgrade_allowed = if can_upgrade_code {
+		Some(relay_parent_number + delay)
+	} else {
+		None
+	};
+
+	Some(PersistedValidationData {
+		parent_head: <paras::Module<T>>::para_head(&para_id)?,
+		code_upgrade_allowed,
+		block_number: relay_parent_number,
+	})
+}
+
+/// Make the transient validation data for a particular parachain.
+///
+/// This ties together the storage of several modules.
+pub fn make_transient_validation_data<T: configuration::Trait>(
+	_para_id: ParaId,
+) -> Option<TransientValidationData> {
+	let config = <configuration::Module<T>>::config();
+
+	Some(TransientValidationData {
+		max_code_size: config.max_code_size,
+		max_head_data_size: config.max_head_data_size,
+		balance: 0,
+		hrmp_mqc_heads: Vec::new(),
+	})
+}