refactor(consensus, evm): move post-execution validation to consensus

[shekhirin]

Resolves #8313

It also includes a change to the Executor and BatchExecutor semantics, as per discussed with @mattsse.

reth/crates/evm/src/execute.rs

Lines 8 to 28 in 9bfde10

	/// A general purpose executor trait that executes an input (e.g. block) and produces an output
	/// (e.g. state changes and receipts).
	///
	/// This executor does not validate the output, see [BatchExecutor] for that.
	pub trait Executor<DB> {
	/// The input type for the executor.
	type Input<'a>;
	/// The output type for the executor.
	type Output;
	/// The error type returned by the executor.
	type Error;
	/// Consumes the type and executes the block.
	///
	/// # Note
	/// Execution happens without any validation of the output. To validate the output, use the
	/// [BatchExecutor].
	///
	/// # Returns
	/// The output of the block execution.
	fn execute(self, input: Self::Input<'_>) -> Result<Self::Output, Self::Error>;

reth/crates/evm/src/execute.rs

Lines 31 to 70 in 9bfde10

	/// A general purpose executor that can execute multiple inputs in sequence, validate the outputs,
	/// and keep track of the state over the entire batch.
	pub trait BatchExecutor<DB> {
	/// The input type for the executor.
	type Input<'a>;
	/// The output type for the executor.
	type Output;
	/// The error type returned by the executor.
	type Error;
	/// Executes the next block in the batch, veryfies the output and updates the state internally.
	fn execute_and_verify_one(&mut self, input: Self::Input<'_>) -> Result<(), Self::Error>;
	/// Executes multiple inputs in the batch, verifies the output, and updates the state
	/// internally.
	///
	/// This method is a convenience function for calling [`BatchExecutor::execute_and_verify_one`]
	/// for each input.
	fn execute_and_verify_many<'a, I>(&mut self, inputs: I) -> Result<(), Self::Error>
	where
	I: IntoIterator<Item = Self::Input<'a>>,
	{
	for input in inputs {
	self.execute_and_verify_one(input)?;
	}
	Ok(())
	}
	/// Executes the entire batch, verifies the output, and returns the final state.
	///
	/// This method is a convenience function for calling [`BatchExecutor::execute_and_verify_many`]
	/// and [`BatchExecutor::finalize`].
	fn execute_and_verify_batch<'a, I>(mut self, batch: I) -> Result<Self::Output, Self::Error>
	where
	I: IntoIterator<Item = Self::Input<'a>>,
	Self: Sized,
	{
	self.execute_and_verify_many(batch)?;
	Ok(self.finalize())
	}

[mattsse]

renaming and additional fn makes sense,

the receipt verify functions need to be moved to the network specific implementations

[mattsse]

great!