Remove service, migrate all to service-new

node/core/candidate-validation/src/lib.rs

@@ -290,7 +290,7 @@ async fn spawn_validate_from_chain_state(
 				ctx,
 				validation_pool,
 				validation_data.persisted,
-				validation_data.transient,
+				Some(validation_data.transient),
 				validation_code,
 				descriptor,
 				pov,
@@ -311,7 +311,7 @@ async fn spawn_validate_from_chain_state(
 				ctx,
 				validation_pool,
 				validation_data.persisted,
-				validation_data.transient,
+				Some(validation_data.transient),
 				validation_code,
 				descriptor,
 				pov,
@@ -332,7 +332,7 @@ async fn spawn_validate_exhaustive(
 	ctx: &mut impl SubsystemContext<Message = CandidateValidationMessage>,
 	validation_pool: Option<ValidationPool>,
 	persisted_validation_data: PersistedValidationData,
-	transient_validation_data: TransientValidationData,
+	transient_validation_data: Option<TransientValidationData>,
 	validation_code: ValidationCode,
 	descriptor: CandidateDescriptor,
 	pov: Arc<PoV>,
@@ -449,7 +449,7 @@ impl ValidationBackend for RealValidationBackend {
 fn validate_candidate_exhaustive<B: ValidationBackend, S: SpawnNamed + 'static>(
 	backend_arg: B::Arg,
 	persisted_validation_data: PersistedValidationData,
-	transient_validation_data: TransientValidationData,
+	transient_validation_data: Option<TransientValidationData>,
 	validation_code: ValidationCode,
 	descriptor: CandidateDescriptor,
 	pov: Arc<PoV>,
@@ -460,11 +460,10 @@ fn validate_candidate_exhaustive<B: ValidationBackend, S: SpawnNamed + 'static>(
 	}
 
 	let params = ValidationParams {
+		parent_head: persisted_validation_data.parent_head.clone(),
 		block_data: pov.block_data.clone(),
-		validation_data: ValidationData {
-			persisted: persisted_validation_data.clone(),
-			transient: transient_validation_data.clone(),
-		}
+		relay_chain_height: persisted_validation_data.block_number,
+		hrmp_mqc_heads: persisted_validation_data.hrmp_mqc_heads.clone(),
 	};
 
 	match B::validate(backend_arg, &validation_code, params, spawn) {
@@ -482,10 +481,14 @@ fn validate_candidate_exhaustive<B: ValidationBackend, S: SpawnNamed + 'static>(
 			Ok(ValidationResult::Invalid(InvalidCandidate::ExecutionError(e.to_string()))),
 		Err(ValidationError::Internal(e)) => Err(ValidationFailed(e.to_string())),
 		Ok(res) => {
-			let post_check_result = check_wasm_result_against_constraints(
-				&transient_validation_data,
-				&res,
-			);
+			let post_check_result = if let Some(transient) = transient_validation_data {
+				check_wasm_result_against_constraints(
+					&transient,
+					&res,
+				)
+			} else {
+				Ok(())
+			};
 
 			Ok(match post_check_result {
 				Ok(()) => ValidationResult::Valid(ValidationOutputs {
@@ -831,7 +834,7 @@ mod tests {
 		let v = validate_candidate_exhaustive::<MockValidationBackend, _>(
 			MockValidationArg { result: Ok(validation_result) },
 			validation_data.persisted.clone(),
-			validation_data.transient,
+			Some(validation_data.transient),
 			vec![1, 2, 3].into(),
 			descriptor,
 			Arc::new(pov),
@@ -882,7 +885,7 @@ mod tests {
 				))
 			},
 			validation_data.persisted,
-			validation_data.transient,
+			Some(validation_data.transient),
 			vec![1, 2, 3].into(),
 			descriptor,
 			Arc::new(pov),
@@ -928,7 +931,7 @@ mod tests {
 				))
 			},
 			validation_data.persisted,
-			validation_data.transient,
+			Some(validation_data.transient),
 			vec![1, 2, 3].into(),
 			descriptor,
 			Arc::new(pov),
@@ -937,4 +940,49 @@ mod tests {
 
 		assert_matches!(v, Ok(ValidationResult::Invalid(InvalidCandidate::Timeout)));
 	}
+
+	#[test]
+	fn candidate_validation_ok_does_not_validate_outputs_if_no_transient() {
+		let mut validation_data: ValidationData = Default::default();
+		validation_data.transient.max_head_data_size = 1;
+		validation_data.transient.max_code_size = 1;
+
+		let pov = PoV { block_data: BlockData(vec![1; 32]) };
+
+		let mut descriptor = CandidateDescriptor::default();
+		descriptor.pov_hash = pov.hash();
+		collator_sign(&mut descriptor, Sr25519Keyring::Alice);
+
+		assert!(perform_basic_checks(&descriptor, Some(1024), &pov).is_ok());
+
+		let validation_result = WasmValidationResult {
+			head_data: HeadData(vec![1, 1, 1]),
+			new_validation_code: Some(vec![2, 2, 2].into()),
+			upward_messages: Vec::new(),
+			processed_downward_messages: 0,
+		};
+
+		assert!(check_wasm_result_against_constraints(
+			&validation_data.transient,
+			&validation_result,
+		).is_err());
+
+		let v = validate_candidate_exhaustive::<MockValidationBackend, _>(
+			MockValidationArg { result: Ok(validation_result) },
+			validation_data.persisted.clone(),
+			None,
+			vec![1, 2, 3].into(),
+			descriptor,
+			Arc::new(pov),
+			TaskExecutor::new(),
+		).unwrap();
+
+		assert_matches!(v, ValidationResult::Valid(outputs) => {
+			assert_eq!(outputs.head_data, HeadData(vec![1, 1, 1]));
+			assert_eq!(outputs.validation_data, validation_data.persisted);
+			assert_eq!(outputs.upward_messages, Vec::new());
+			assert_eq!(outputs.fees, 0);
+			assert_eq!(outputs.new_validation_code, Some(vec![2, 2, 2].into()));
+		});
+	}
 }

node/subsystem/src/messages.rs

@@ -123,11 +123,12 @@ pub enum CandidateValidationMessage {
 	),
 	/// Validate a candidate with provided, exhaustive parameters for validation.
 	///
-	/// Explicitly provide the `PersistedValidationData`, `TransientValidationData` and `ValidationCode`
-	/// so this can do full validation without needing to access the state of the relay-chain.
+	/// Explicitly provide the `PersistedValidationData` and `ValidationCode` so this can do full
+	/// validation without needing to access the state of the relay-chain. Optionally provide the
+	/// `TransientValidationData` for further checks on the outputs.
 	ValidateFromExhaustive(
 		PersistedValidationData,
-		TransientValidationData,
+		Option<TransientValidationData>,
 		ValidationCode,
 		CandidateDescriptor,
 		Arc<PoV>,

parachain/src/primitives.rs

@@ -21,7 +21,6 @@ use sp_std::vec::Vec;
 
 use codec::{Encode, Decode, CompactAs};
 use sp_core::{RuntimeDebug, TypeId};
-use sp_runtime::traits::{Hash as _, BlakeTwo256};
 
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
@@ -226,102 +225,21 @@ pub struct UpwardMessage {
 	pub data: Vec<u8>,
 }
 
-/// The validation data provide information about how to validate both the inputs and
-/// outputs of a candidate.
-///
-/// There are two types of validation data: persisted and transient.
-/// Their respective sections of the guide elaborate on their functionality in more detail.
-///
-/// This information is derived from the chain state and will vary from para to para,
-/// although some of the fields may be the same for every para.
-///
-/// Persisted validation data are generally derived from some relay-chain state to form inputs
-/// to the validation function, and as such need to be persisted by the availability system to
-/// avoid dependence on availability of the relay-chain state. The backing phase of the
-/// inclusion pipeline ensures that everything that is included in a valid fork of the
-/// relay-chain already adheres to the transient constraints.
-///
-/// The validation data also serve the purpose of giving collators a means of ensuring that
-/// their produced candidate and the commitments submitted to the relay-chain alongside it
-/// will pass the checks done by the relay-chain when backing, and give validators
-/// the same understanding when determining whether to second or attest to a candidate.
-///
-/// Since the commitments of the validation function are checked by the
-/// relay-chain, secondary checkers can rely on the invariant that the relay-chain
-/// only includes para-blocks for which these checks have already been done. As such,
-/// there is no need for the validation data used to inform validators and collators about
-/// the checks the relay-chain will perform to be persisted by the availability system.
-/// Nevertheless, we expose it so the backing validators can validate the outputs of a
-/// candidate before voting to submit it to the relay-chain and so collators can
-/// collate candidates that satisfy the criteria implied these transient validation data.
-#[derive(PartialEq, Eq, Clone, Encode, Decode)]
-#[cfg_attr(feature = "std", derive(Debug, Default))]
-pub struct ValidationData<N = RelayChainBlockNumber> {
-	/// The persisted validation data.
-	pub persisted: PersistedValidationData<N>,
-	/// The transient validation data.
-	pub transient: TransientValidationData<N>,
-}
-
-/// Validation data that needs to be persisted for secondary checkers.
-#[derive(PartialEq, Eq, Clone, Encode, Decode)]
-#[cfg_attr(feature = "std", derive(Debug, Default))]
-pub struct PersistedValidationData<N = RelayChainBlockNumber> {
-	/// The parent head-data.
-	pub parent_head: HeadData,
-	/// The relay-chain block number this is in the context of.
-	pub block_number: N,
-	/// The list of MQC heads for the inbound channels paired with the sender para ids. This
-	/// vector is sorted ascending by the para id and doesn't contain multiple entries with the same
-	/// sender.
-	pub hrmp_mqc_heads: Vec<(Id, Hash)>,
-}
-
-impl<N: Encode> PersistedValidationData<N> {
-	/// Compute the blake2-256 hash of the persisted validation data.
-	pub fn hash(&self) -> Hash {
-		BlakeTwo256::hash_of(self)
-	}
-}
-
-/// Validation data for checking outputs of the validation-function.
-/// As such, they also inform the collator about how to construct the candidate.
-///
-/// These are transient because they are not necessary beyond the point where the
-/// candidate is backed.
-#[derive(PartialEq, Eq, Clone, Encode, Decode)]
-#[cfg_attr(feature = "std", derive(Debug, Default))]
-pub struct TransientValidationData<N = RelayChainBlockNumber> {
-	/// The maximum code size permitted, in bytes.
-	pub max_code_size: u32,
-	/// The maximum head-data size permitted, in bytes.
-	pub max_head_data_size: u32,
-	/// The balance of the parachain at the moment of validation.
-	pub balance: polkadot_core_primitives::Balance,
-	/// Whether the parachain is allowed to upgrade its validation code.
-	///
-	/// This is `Some` if so, and contains the number of the minimum relay-chain
-	/// height at which the upgrade will be applied, if an upgrade is signaled
-	/// now.
-	///
-	/// A parachain should enact its side of the upgrade at the end of the first
-	/// parablock executing in the context of a relay-chain block with at least this
-	/// height. This may be equal to the current perceived relay-chain block height, in
-	/// which case the code upgrade should be applied at the end of the signaling
-	/// block.
-	pub code_upgrade_allowed: Option<N>,
-}
-
 /// Validation parameters for evaluating the parachain validity function.
 // TODO: balance downloads (https://github.com/paritytech/polkadot/issues/220)
 #[derive(PartialEq, Eq, Decode)]
 #[cfg_attr(feature = "std", derive(Debug, Encode))]
 pub struct ValidationParams {
+	/// Previous head-data.
+	pub parent_head: HeadData,
 	/// The collation body.
 	pub block_data: BlockData,
-	/// The validation data that was also available to the collator when
-	/// building the PoVBlock.
-	pub validation_data: ValidationData,
+	/// The current relay-chain block number.
+	pub relay_chain_height: RelayChainBlockNumber,
+	/// The list of MQC heads for the inbound HRMP channels paired with the sender para ids. This
+	/// vector is sorted ascending by the para id and doesn't contain multiple entries with the same
+	/// sender.
+	pub hrmp_mqc_heads: Vec<(Id, Hash)>,
 }
 
 /// The result of parachain validation.

parachain/test-parachains/adder/src/wasm_validation.rs

@@ -24,13 +24,13 @@ use codec::{Encode, Decode};
 #[no_mangle]
 pub extern fn validate_block(params: *const u8, len: usize) -> u64 {
 	let params = unsafe { parachain::load_params(params, len) };
-	let parent_head = HeadData::decode(&mut &params.validation_data.persisted.parent_head.0[..])
+	let parent_head = HeadData::decode(&mut &params.parent_head.0[..])
 		.expect("invalid parent head format.");
 
 	let block_data = BlockData::decode(&mut &params.block_data.0[..])
 		.expect("invalid block data format.");
 
-	let parent_hash = tiny_keccak::keccak256(&params.validation_data.persisted.parent_head.0[..]);
+	let parent_hash = tiny_keccak::keccak256(&params.parent_head.0[..]);
 
 	match crate::execute(parent_hash, parent_head, &block_data) {
 		Ok(new_head) => parachain::write_result(

parachain/test-parachains/tests/adder/mod.rs

@@ -20,8 +20,10 @@ const WORKER_ARGS_TEST: &[&'static str] = &["--nocapture", "validation_worker"];
 
 use parachain::{
 	primitives::{
-		BlockData as GenericBlockData, HeadData as GenericHeadData,
-		ValidationParams, ValidationData, PersistedValidationData,
+		RelayChainBlockNumber,
+		BlockData as GenericBlockData,
+		HeadData as GenericHeadData,
+		ValidationParams,
 	},
 	wasm_executor::{ValidationPool, ValidationExecutionMode}
 };
@@ -92,15 +94,10 @@ fn execute_good_on_parent(pool: ValidationPool) {
 	let ret = parachain::wasm_executor::validate_candidate(
 		adder::wasm_binary_unwrap(),
 		ValidationParams {
+			parent_head: GenericHeadData(parent_head.encode()),
 			block_data: GenericBlockData(block_data.encode()),
-			validation_data: ValidationData {
-				persisted: PersistedValidationData {
-					parent_head: GenericHeadData(parent_head.encode()),
-					block_number: 1,
-					..Default::default()
-				},
-				transient: Default::default(),
-			},
+			relay_chain_height: 1,
+			hrmp_mqc_heads: Vec::new(),
 		},
 		parachain::wasm_executor::ExecutionMode::Remote(&pool),
 		sp_core::testing::TaskExecutor::new(),
@@ -135,15 +132,10 @@ fn execute_good_chain_on_parent() {
 		let ret = parachain::wasm_executor::validate_candidate(
 			adder::wasm_binary_unwrap(),
 			ValidationParams {
+				parent_head: GenericHeadData(parent_head.encode()),
 				block_data: GenericBlockData(block_data.encode()),
-				validation_data: ValidationData {
-					persisted: PersistedValidationData {
-						parent_head: GenericHeadData(parent_head.encode()),
-						block_number: (number + 1) as _,
-						..Default::default()
-					},
-					transient: Default::default(),
-				},
+				relay_chain_height: number as RelayChainBlockNumber + 1,
+				hrmp_mqc_heads: Vec::new(),
 			},
 			parachain::wasm_executor::ExecutionMode::Remote(&pool),
 			sp_core::testing::TaskExecutor::new(),
@@ -179,15 +171,10 @@ fn execute_bad_on_parent() {
 	let _ret = parachain::wasm_executor::validate_candidate(
 		adder::wasm_binary_unwrap(),
 		ValidationParams {
+			parent_head: GenericHeadData(parent_head.encode()),
 			block_data: GenericBlockData(block_data.encode()),
-			validation_data: ValidationData {
-				persisted: PersistedValidationData {
-					parent_head: GenericHeadData(parent_head.encode()),
-					block_number: 1,
-					..Default::default()
-				},
-				transient: Default::default(),
-			},
+			relay_chain_height: 1,
+			hrmp_mqc_heads: Vec::new(),
 		},
 		parachain::wasm_executor::ExecutionMode::Remote(&pool),
 		sp_core::testing::TaskExecutor::new(),