Create validation in parallel-executor

crates/services/executor/src/executor.rs

@@ -888,7 +888,7 @@ where
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn execute_transaction_and_commit<'a, W>(
+    pub fn execute_transaction_and_commit<'a, W>(
         &'a self,
         block: &'a mut PartialFuelBlock,
         storage_tx: &mut BlockStorageTransaction<W>,

crates/services/parallel-executor/src/executor.rs

@@ -10,6 +10,11 @@ use crate::{
         SchedulerError,
         SchedulerExecutionResult,
     },
+    txs_ext::TxCoinbaseExt,
+    validator::{
+        self,
+        Validator,
+    },
 };
 use fuel_core_executor::{
     executor::ExecutionData,
@@ -30,9 +35,12 @@ use fuel_core_storage::{
     },
 };
 use fuel_core_types::{
-    blockchain::block::{
-        Block,
-        PartialFuelBlock,
+    blockchain::{
+        block::{
+            Block,
+            PartialFuelBlock,
+        },
+        header::PartialBlockHeader,
     },
     fuel_tx::{
         ContractId,
@@ -70,23 +78,34 @@ mod defaults {
 
 pub struct Executor<S, R, P> {
     scheduler: Scheduler<R, S, P>,
+    relayer: R,
+    validator: Validator,
 }
 
-impl<S, R, P> Executor<S, R, P> {
+impl<S, R, P> Executor<S, R, P>
+where
+    R: Clone,
+{
     pub fn new(
         storage_view_provider: S,
-        relayer_view_provider: R,
+        relayer: R,
         preconfirmation_sender: P,
         config: Config,
     ) -> Result<Self, SchedulerError> {
         let scheduler = Scheduler::new(
-            config,
-            relayer_view_provider,
+            config.clone(),
+            relayer.clone(),
             storage_view_provider,
             preconfirmation_sender,
         )?;
 
-        Ok(Self { scheduler })
+        let validator = Validator::new(config);
+
+        Ok(Self {
+            scheduler,
+            relayer,
+            validator,
+        })
     }
 }
 
@@ -130,6 +149,44 @@ where
         self.finalize_block(&mut components, scheduler_result, &mut memory)
     }
 
+    async fn validate_block(
+        mut self,
+        block: &Block,
+        block_storage_tx: StorageTransaction<View>,
+    ) -> Result<validator::ValidationResult, SchedulerError> {
+        let mut data = ExecutionData::new();
+
+        let partial_header = PartialBlockHeader::from(block.header());
+        let mut partial_block = PartialFuelBlock::new(partial_header, vec![]);
+        let transactions = block.transactions();
+        let mut memory = MemoryInstance::new();
+
+        let (gas_price, coinbase_contract_id) = transactions.coinbase()?;
+
+        let block_storage_tx = self.process_l1_txs(
+            &mut partial_block,
+            coinbase_contract_id,
+            &mut data,
+            &mut memory,
+            block_storage_tx,
+        )?;
+        let processed_l1_tx_count = partial_block.transactions.len();
+
+        let components = Components {
+            header_to_produce: partial_block.header,
+            transactions_source: transactions.iter().cloned().skip(processed_l1_tx_count),
+            coinbase_recipient: coinbase_contract_id,
+            gas_price,
+        };
+
+        let executed_block_result = self
+            .validator
+            .validate_block(self.relayer.clone(), components, block_storage_tx, block)
+            .await?;
+
+        Ok(executed_block_result)
+    }
+
     /// Process DA changes if the DA height has changed
     async fn process_da_if_needed(
         &mut self,
@@ -156,12 +213,17 @@ where
             .is_some();
 
         if should_process_da {
+            let storage_tx = StorageTransaction::transaction(
+                view,
+                ConflictPolicy::Fail,
+                Default::default(),
+            );
             let storage_tx = self.process_l1_txs(
                 partial_block,
                 components.coinbase_recipient,
                 execution_data,
                 memory,
-                view,
+                storage_tx,
             )?;
             Ok(storage_tx.into_changes())
         } else {
@@ -176,14 +238,8 @@ where
         coinbase_contract_id: ContractId,
         execution_data: &mut ExecutionData,
         memory: &mut MemoryInstance,
-        view: View,
+        mut storage_tx: StorageTransaction<View>,
     ) -> Result<StorageTransaction<View>, SchedulerError> {
-        let mut storage_tx = StorageTransaction::transaction(
-            view,
-            ConflictPolicy::Fail,
-            Default::default(),
-        );
-
         self.scheduler
             .executor
             .process_l1_txs(
@@ -281,6 +337,7 @@ where
         let block = partial_block
             .generate(
                 &execution_data.message_ids,
+                // TODO:
                 Default::default(),
                 #[cfg(feature = "fault-proving")]
                 &Default::default(),

crates/services/parallel-executor/src/lib.rs

@@ -4,9 +4,11 @@ pub mod config;
 pub mod executor;
 pub(crate) mod l1_execution_data;
 pub mod ports;
+pub(crate) mod txs_ext;
 
 mod once_transaction_source;
 mod tx_waiter;
+mod validator;
 
 #[cfg(test)]
 mod tests;

crates/services/parallel-executor/src/scheduler.rs

@@ -216,6 +216,14 @@ pub enum SchedulerError {
     StorageError(StorageError),
     /// Internal error
     InternalError(String),
+    /// Mint missing error
+    MintMissing,
+    /// Skipped transaction error
+    SkippedTransaction(ExecutorError),
+    /// Block mismatch
+    BlockMismatch,
+    /// Consensus parameters not found
+    ConsensusParametersNotFound(u32),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/services/parallel-executor/src/txs_ext.rs

@@ -0,0 +1,25 @@
+use fuel_core_types::fuel_tx::{
+    ContractId,
+    Transaction,
+    field::{
+        InputContract,
+        MintGasPrice,
+    },
+};
+
+use crate::scheduler::SchedulerError;
+
+/// Returns the coinbase transaction details if it exists.
+pub trait TxCoinbaseExt {
+    fn coinbase(&self) -> Result<(u64, ContractId), SchedulerError>;
+}
+
+impl TxCoinbaseExt for &[Transaction] {
+    fn coinbase(&self) -> Result<(u64, ContractId), SchedulerError> {
+        if let Some(Transaction::Mint(mint)) = self.last() {
+            Ok((*mint.gas_price(), mint.input_contract().contract_id))
+        } else {
+            Err(SchedulerError::MintMissing)
+        }
+    }
+}