Fixed some [nit]s after review the PR for fuel-core-sync integration

crates/fuel-core/src/executor.rs

@@ -8,7 +8,6 @@ use crate::{
     service::Config,
 };
 use fuel_core_executor::refs::ContractRef;
-use fuel_core_producer::ports::Executor as ExecutorTrait;
 use fuel_core_storage::{
     tables::{
         Coins,
@@ -138,15 +137,15 @@ impl Executor {
     }
 }
 
-impl ExecutorTrait<Database> for Executor {
-    fn execute_without_commit(
+impl Executor {
+    pub fn execute_without_commit(
         &self,
         block: ExecutionBlock,
     ) -> ExecutorResult<UncommittedResult<StorageTransaction<Database>>> {
         self.execute_inner(block, &self.database)
     }
 
-    fn dry_run(
+    pub fn dry_run(
         &self,
         block: ExecutionBlock,
         utxo_validation: Option<bool>,

crates/fuel-core/src/query/message_proof/test.rs

@@ -162,7 +162,7 @@ async fn can_build_message_proof() {
             let header = header.clone();
             let message_ids = message_ids.clone();
             move |_| {
-                let header = header.clone().generate(&[vec![]], &message_ids);
+                let header = header.clone().generate(&[], &message_ids);
                 let transactions = TXNS.to_vec();
                 Ok(CompressedBlock::test(header, transactions))
             }
@@ -173,6 +173,6 @@ async fn can_build_message_proof() {
         .unwrap();
     assert_eq!(p.message_id(), message_id);
     assert_eq!(p.signature, Signature::default());
-    let header = header.generate(&[vec![]], &message_ids);
+    let header = header.generate(&[], &message_ids);
     assert_eq!(p.header.output_messages_root, header.output_messages_root);
 }

crates/fuel-core/src/service/adapters.rs

@@ -8,14 +8,14 @@ use std::sync::Arc;
 
 pub mod block_importer;
 pub mod consensus_module;
+pub mod executor;
 pub mod graphql_api;
 #[cfg(feature = "p2p")]
 pub mod p2p;
 pub mod producer;
-pub mod txpool;
-
 #[cfg(feature = "p2p")]
 pub mod sync;
+pub mod txpool;
 
 #[derive(Clone)]
 pub struct PoAAdapter {
@@ -60,7 +60,6 @@ pub struct BlockProducerAdapter {
 pub struct BlockImporterAdapter {
     pub block_importer:
         Arc<fuel_core_importer::Importer<Database, ExecutorAdapter, VerifierAdapter>>,
-    execution_semaphore: Arc<tokio::sync::Semaphore>,
 }
 
 #[cfg(feature = "p2p")]

crates/fuel-core/src/service/adapters/block_importer.rs

@@ -36,9 +36,10 @@ use fuel_core_types::{
         SealedBlock,
     },
     fuel_tx::Bytes32,
-    services::{
-        block_importer::UncommittedResult,
-        executor::ExecutionBlock,
+    services::executor::{
+        ExecutionBlock,
+        Result as ExecutorResult,
+        UncommittedResult as UncommittedExecutionResult,
     },
 };
 use std::sync::Arc;
@@ -52,38 +53,22 @@ impl BlockImporterAdapter {
     ) -> Self {
         Self {
             block_importer: Arc::new(Importer::new(config, database, executor, verifier)),
-            execution_semaphore: Arc::new(tokio::sync::Semaphore::new(1)),
         }
     }
 
     pub async fn execute_and_commit(
         &self,
         sealed_block: SealedBlock,
     ) -> anyhow::Result<()> {
-        let permit = self.execution_semaphore.acquire().await?;
         tokio::task::spawn_blocking({
             let importer = self.block_importer.clone();
             move || importer.execute_and_commit(sealed_block)
         })
         .await??;
-        core::mem::drop(permit);
         Ok(())
     }
 }
 
-impl fuel_core_poa::ports::BlockImporter for BlockImporterAdapter {
-    type Database = Database;
-
-    fn commit_result(
-        &self,
-        result: UncommittedResult<StorageTransaction<Self::Database>>,
-    ) -> anyhow::Result<()> {
-        self.block_importer
-            .commit_result(result)
-            .map_err(Into::into)
-    }
-}
-
 impl BlockVerifier for VerifierAdapter {
     fn verify_block_fields(
         &self,
@@ -126,14 +111,8 @@ impl Executor for ExecutorAdapter {
     fn execute_without_commit(
         &self,
         block: ExecutionBlock,
-    ) -> Result<
-        fuel_core_types::services::executor::UncommittedResult<
-            StorageTransaction<Self::Database>,
-        >,
-        fuel_core_types::services::executor::Error,
-    > {
-        fuel_core_producer::ports::Executor::<Database>::execute_without_commit(
-            self, block,
-        )
+    ) -> ExecutorResult<UncommittedExecutionResult<StorageTransaction<Self::Database>>>
+    {
+        self._execute_without_commit(block)
     }
 }

crates/fuel-core/src/service/adapters/consensus_module/poa.rs

@@ -2,13 +2,17 @@ use crate::{
     database::Database,
     fuel_core_graphql_api::ports::ConsensusModulePort,
     service::adapters::{
+        BlockImporterAdapter,
         BlockProducerAdapter,
         PoAAdapter,
         TxPoolAdapter,
     },
 };
 use fuel_core_poa::{
-    ports::TransactionPool,
+    ports::{
+        BlockImporter,
+        TransactionPool,
+    },
     service::SharedState,
 };
 use fuel_core_services::stream::BoxStream;
@@ -22,6 +26,7 @@ use fuel_core_types::{
         TxId,
     },
     services::{
+        block_importer::UncommittedResult as UncommittedImporterResult,
         executor::UncommittedResult,
         txpool::{
             ArcPoolTx,
@@ -98,3 +103,16 @@ impl fuel_core_poa::ports::BlockProducer for BlockProducerAdapter {
             .await
     }
 }
+
+impl BlockImporter for BlockImporterAdapter {
+    type Database = Database;
+
+    fn commit_result(
+        &self,
+        result: UncommittedImporterResult<StorageTransaction<Self::Database>>,
+    ) -> anyhow::Result<()> {
+        self.block_importer
+            .commit_result(result)
+            .map_err(Into::into)
+    }
+}

crates/fuel-core/src/service/adapters/executor.rs

@@ -0,0 +1,39 @@
+use crate::{
+    database::Database,
+    executor::Executor,
+    service::adapters::ExecutorAdapter,
+};
+use fuel_core_storage::transactional::StorageTransaction;
+use fuel_core_types::{
+    fuel_tx::Receipt,
+    services::executor::{
+        ExecutionBlock,
+        Result as ExecutorResult,
+        UncommittedResult,
+    },
+};
+
+impl ExecutorAdapter {
+    pub(crate) fn _execute_without_commit(
+        &self,
+        block: ExecutionBlock,
+    ) -> ExecutorResult<UncommittedResult<StorageTransaction<Database>>> {
+        let executor = Executor {
+            database: self.database.clone(),
+            config: self.config.clone(),
+        };
+        executor.execute_without_commit(block)
+    }
+
+    pub(crate) fn _dry_run(
+        &self,
+        block: ExecutionBlock,
+        utxo_validation: Option<bool>,
+    ) -> ExecutorResult<Vec<Vec<Receipt>>> {
+        let executor = Executor {
+            database: self.database.clone(),
+            config: self.config.clone(),
+        };
+        executor.dry_run(block, utxo_validation)
+    }
+}

crates/fuel-core/src/service/adapters/producer.rs

@@ -1,6 +1,5 @@
 use crate::{
     database::Database,
-    executor::Executor,
     service::adapters::{
         BlockProducerAdapter,
         ExecutorAdapter,
@@ -66,23 +65,15 @@ impl fuel_core_producer::ports::Executor<Database> for ExecutorAdapter {
         &self,
         block: ExecutionBlock,
     ) -> ExecutorResult<UncommittedResult<StorageTransaction<Database>>> {
-        let executor = Executor {
-            database: self.database.clone(),
-            config: self.config.clone(),
-        };
-        executor.execute_without_commit(block)
+        self._execute_without_commit(block)
     }
 
     fn dry_run(
         &self,
         block: ExecutionBlock,
         utxo_validation: Option<bool>,
     ) -> ExecutorResult<Vec<Vec<Receipt>>> {
-        let executor = Executor {
-            database: self.database.clone(),
-            config: self.config.clone(),
-        };
-        executor.dry_run(block, utxo_validation)
+        self._dry_run(block, utxo_validation)
     }
 }
 

crates/fuel-core/src/service/sub_services.rs

@@ -123,9 +123,8 @@ pub fn init_sub_services(
 
     #[cfg(feature = "p2p")]
     let sync = {
-        let current_fuel_block_height = Some(database.latest_height()?);
         fuel_core_sync::service::new_service(
-            current_fuel_block_height,
+            last_height,
             p2p_adapter,
             importer_adapter.clone(),
             verifier,

crates/services/consensus_module/poa/src/verifier.rs

@@ -4,9 +4,9 @@ use fuel_core_storage::Result as StorageResult;
 use fuel_core_types::{
     blockchain::{
         block::Block,
+        consensus::poa::PoAConsensus,
         header::BlockHeader,
         primitives::BlockHeight,
-        SealedBlockHeader,
     },
     fuel_tx::Input,
     fuel_types::Bytes32,
@@ -31,32 +31,25 @@ pub trait Database {
     fn block_header_merkle_root(&self, height: &BlockHeight) -> StorageResult<Bytes32>;
 }
 
+// TODO: Make this function `async` and await the synchronization with the relayer.
 pub fn verify_consensus(
     consensus_config: &ConsensusConfig,
-    header: &SealedBlockHeader,
+    header: &BlockHeader,
+    consensus: &PoAConsensus,
 ) -> bool {
-    let SealedBlockHeader {
-        entity: header,
-        consensus,
-    } = header;
-    match consensus {
-        fuel_core_types::blockchain::consensus::Consensus::PoA(consensus) => {
-            match consensus_config {
-                ConsensusConfig::PoA { signing_key } => {
-                    let id = header.id();
-                    let m = id.as_message();
-                    consensus
-                        .signature
-                        .recover(m)
-                        .map_or(false, |k| Input::owner(&k) == *signing_key)
-                }
-            }
+    match consensus_config {
+        ConsensusConfig::PoA { signing_key } => {
+            let id = header.id();
+            let m = id.as_message();
+            consensus
+                .signature
+                .recover(m)
+                .map_or(false, |k| Input::owner(&k) == *signing_key)
         }
-        _ => true,
     }
 }
 
-pub fn verify_poa_block_fields<D: Database>(
+pub fn verify_block_fields<D: Database>(
     config: &Config,
     database: &D,
     block: &Block,

crates/services/consensus_module/poa/src/verifier/tests.rs

@@ -107,5 +107,5 @@ fn test_verify_genesis_block_fields(input: Input) -> anyhow::Result<()> {
     let mut b = Block::default();
     b.header_mut().consensus = ch;
     b.header_mut().application = ah;
-    verify_poa_block_fields(&c, &d, &b)
+    verify_block_fields(&c, &d, &b)
 }

crates/services/consensus_module/src/block_verifier.rs

@@ -8,11 +8,7 @@ mod tests;
 
 use crate::block_verifier::config::Config;
 use anyhow::ensure;
-use fuel_core_poa::verifier::{
-    verify_consensus,
-    verify_poa_block_fields,
-    Database as PoAVerifierDatabase,
-};
+use fuel_core_poa::verifier::Database as PoAVerifierDatabase;
 use fuel_core_types::{
     blockchain::{
         block::Block,
@@ -66,15 +62,28 @@ where
                     .unwrap_or_else(|| 0u32.into());
                 verify_genesis_block_fields(expected_genesis_height, block.header())
             }
-            Consensus::PoA(_) => {
-                verify_poa_block_fields(&self.config.poa, &self.database, block)
-            }
+            Consensus::PoA(_) => fuel_core_poa::verifier::verify_block_fields(
+                &self.config.poa,
+                &self.database,
+                block,
+            ),
         }
     }
 
     /// Verifies the consensus of the block header.
     pub fn verify_consensus(&self, header: &SealedBlockHeader) -> bool {
-        verify_consensus(&self.config.chain_config.consensus, header)
+        let SealedBlockHeader {
+            entity: header,
+            consensus,
+        } = header;
+        match consensus {
+            Consensus::Genesis(_) => true,
+            Consensus::PoA(consensus) => fuel_core_poa::verifier::verify_consensus(
+                &self.config.chain_config.consensus,
+                header,
+                consensus,
+            ),
+        }
     }
 }