Introduce new Runtime API endpoint for fetching the validation data (#3728)

* Introduce new Runtime API endpoint

`persisted_validation_data_with_code_hash` that will be used
by the candidate validation subsystem in order to decrease amount
of runtime API requests.

* Node-side part of new runtime API request

* Define code hash getter via macro

* Rename new endpoint to `assumed_validation_data`

* Docs for runtime API impl of new endpoint

* AssumedValidationData specialized request function

* fmt

polkadot/node/core/runtime-api/src/tests.rs

@@ -90,6 +90,17 @@ sp_api::mock_impl_runtime_apis! {
 			self.validation_data.get(&para).cloned()
 		}
 
+		fn assumed_validation_data(
+			para_id: ParaId,
+			expected_persisted_validation_data_hash: Hash,
+		) -> Option<(PersistedValidationData, ValidationCodeHash)> {
+			self.validation_data
+				.get(&para_id)
+				.cloned()
+				.filter(|data| data.hash() == expected_persisted_validation_data_hash)
+				.zip(self.validation_code.get(&para_id).map(|code| code.hash()))
+		}
+
 		fn check_validation_outputs(
 			&self,
 			para_id: ParaId,
@@ -345,6 +356,58 @@ fn requests_persisted_validation_data() {
 	futures::executor::block_on(future::join(subsystem_task, test_task));
 }
 
+#[test]
+fn requests_assumed_validation_data() {
+	let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+	let relay_parent = [1; 32].into();
+	let para_a = 5.into();
+	let para_b = 6.into();
+	let spawner = sp_core::testing::TaskExecutor::new();
+
+	let validation_code = ValidationCode(vec![1, 2, 3]);
+	let expected_data_hash = <PersistedValidationData as Default>::default().hash();
+	let expected_code_hash = validation_code.hash();
+
+	let mut runtime_api = MockRuntimeApi::default();
+	runtime_api.validation_data.insert(para_a, Default::default());
+	runtime_api.validation_code.insert(para_a, validation_code);
+	runtime_api.validation_data.insert(para_b, Default::default());
+	let runtime_api = Arc::new(runtime_api);
+
+	let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+	let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+	let test_task = async move {
+		let (tx, rx) = oneshot::channel();
+
+		ctx_handle
+			.send(FromOverseer::Communication {
+				msg: RuntimeApiMessage::Request(
+					relay_parent,
+					Request::AssumedValidationData(para_a, expected_data_hash, tx),
+				),
+			})
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap(), Some((Default::default(), expected_code_hash)));
+
+		let (tx, rx) = oneshot::channel();
+		ctx_handle
+			.send(FromOverseer::Communication {
+				msg: RuntimeApiMessage::Request(
+					relay_parent,
+					Request::AssumedValidationData(para_a, Hash::zero(), tx),
+				),
+			})
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap(), None);
+
+		ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+	};
+
+	futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
 #[test]
 fn requests_check_validation_outputs() {
 	let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());