Move PVF timeouts to executor environment parameters (#6823)

* Move PVF timeouts to executor environment parameters

* Typo

Co-authored-by: Marcin S. <marcin@realemail.net>

* Fix comments

* Change handle_import_statements to FatalResult (#6820)

* Changing dispute db errors to fatal

* fmt

* Change node-key for bootnodes (#6772)

* Additional tracing in `provisioner`, `vote_selection` and `dispute-coordinator` (#6775)

* Additional tracing in `provisioner`, `vote_selection`

* Add `fetched_onchain_disputes` metric to provisioner

* Some tracelines in dispute-coordinator

TODO: cherry pick this in the initial branch!!!

* Remove spammy logs

* Remove some trace lines

* Rename and fix things

* Fix comments

* Typo

* Minor fixes

* Add codec indexes; Remove macro

---------

Co-authored-by: Marcin S. <marcin@realemail.net>
Co-authored-by: Bradley Olson <34992650+BradleyOlson64@users.noreply.github.com>
Co-authored-by: Petr Mensik <petr.mensik1@gmail.com>
Co-authored-by: Tsvetomir Dimitrov <tsvetomir@parity.io>

polkadot/node/core/pvf/src/pvf.rs

@@ -23,26 +23,39 @@ use std::{
 	cmp::{Eq, PartialEq},
 	fmt,
 	sync::Arc,
+	time::Duration,
 };
 
-/// A struct that carries code of a parachain validation function, its hash, and a corresponding
-/// set of executor parameters.
+#[cfg(test)]
+use crate::host::tests::TEST_PREPARATION_TIMEOUT;
+
+/// A struct that carries the exhaustive set of data to prepare an artifact out of plain
+/// Wasm binary
 ///
 /// Should be cheap to clone.
 #[derive(Clone, Encode, Decode)]
-pub struct PvfWithExecutorParams {
+pub struct PvfPrepData {
+	/// Wasm code (uncompressed)
 	pub(crate) code: Arc<Vec<u8>>,
+	/// Wasm code hash
 	pub(crate) code_hash: ValidationCodeHash,
+	/// Executor environment parameters for the session for which artifact is prepared
 	pub(crate) executor_params: Arc<ExecutorParams>,
+	/// Preparation timeout
+	pub(crate) prep_timeout: Duration,
 }
 
-impl PvfWithExecutorParams {
+impl PvfPrepData {
 	/// Returns an instance of the PVF out of the given PVF code and executor params.
-	pub fn from_code(code: Vec<u8>, executor_params: ExecutorParams) -> Self {
+	pub fn from_code(
+		code: Vec<u8>,
+		executor_params: ExecutorParams,
+		prep_timeout: Duration,
+	) -> Self {
 		let code = Arc::new(code);
 		let code_hash = blake2_256(&code).into();
 		let executor_params = Arc::new(executor_params);
-		Self { code, code_hash, executor_params }
+		Self { code, code_hash, executor_params, prep_timeout }
 	}
 
 	/// Returns artifact ID that corresponds to the PVF with given executor params
@@ -67,27 +80,32 @@ impl PvfWithExecutorParams {
 
 	/// Creates a structure for tests
 	#[cfg(test)]
-	pub(crate) fn from_discriminator(num: u32) -> Self {
+	pub(crate) fn from_discriminator_and_timeout(num: u32, timeout: Duration) -> Self {
 		let descriminator_buf = num.to_le_bytes().to_vec();
-		Self::from_code(descriminator_buf, ExecutorParams::default())
+		Self::from_code(descriminator_buf, ExecutorParams::default(), timeout)
+	}
+
+	#[cfg(test)]
+	pub(crate) fn from_discriminator(num: u32) -> Self {
+		Self::from_discriminator_and_timeout(num, TEST_PREPARATION_TIMEOUT)
 	}
 }
 
-impl fmt::Debug for PvfWithExecutorParams {
+impl fmt::Debug for PvfPrepData {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		write!(
 			f,
-			"Pvf {{ code, code_hash: {:?}, executor_params: {:?} }}",
-			self.code_hash, self.executor_params
+			"Pvf {{ code, code_hash: {:?}, executor_params: {:?}, prep_timeout: {:?} }}",
+			self.code_hash, self.executor_params, self.prep_timeout
 		)
 	}
 }
 
-impl PartialEq for PvfWithExecutorParams {
+impl PartialEq for PvfPrepData {
 	fn eq(&self, other: &Self) -> bool {
 		self.code_hash == other.code_hash &&
 			self.executor_params.hash() == other.executor_params.hash()
 	}
 }
 
-impl Eq for PvfWithExecutorParams {}
+impl Eq for PvfPrepData {}