unify spawn_essential_handles params into SpawnEssentialHandlesParams

Author: liamaharon

node/src/consensus/aura_consensus.rs

@@ -1,3 +1,4 @@
+use crate::consensus::consensus_mechanism::SpawnEssentialHandlesParams;
 use crate::consensus::hybrid_import_queue::HybridBlockImport;
 use crate::consensus::{ConsensusMechanism, StartAuthoringParams};
 use crate::{
@@ -11,7 +12,6 @@ use sc_client_api::{AuxStore, BlockOf, UsageProvider};
 use sc_consensus::{BlockImport, BoxBlockImport};
 use sc_consensus_grandpa::BlockNumberOps;
 use sc_consensus_slots::{BackoffAuthoringBlocksStrategy, InherentDataProviderExt};
-use sc_network_sync::SyncingService;
 use sc_service::{Configuration, TaskManager};
 use sc_telemetry::TelemetryHandle;
 use sc_transaction_pool::TransactionPoolHandle;
@@ -193,15 +193,12 @@ impl ConsensusMechanism for AuraConsensus {
 
     fn spawn_essential_handles(
         &self,
-        task_manager: &mut TaskManager,
-        client: Arc<FullClient>,
-        triggered: Option<Arc<std::sync::atomic::AtomicBool>>,
-        sync_service: Arc<SyncingService<Block>>,
+        p: SpawnEssentialHandlesParams,
     ) -> Result<(), sc_service::Error> {
-        let client_clone = client.clone();
-        let triggered_clone = triggered.clone();
-        let slot_duration = self.slot_duration(&client)?;
-        task_manager.spawn_essential_handle().spawn(
+        let client_clone = p.client.clone();
+        let triggered_clone = p.triggered.clone();
+        let slot_duration = self.slot_duration(&p.client)?;
+        p.task_manager.spawn_essential_handle().spawn(
             "babe-switch",
             None,
             Box::pin(async move {
@@ -219,7 +216,7 @@ impl ConsensusMechanism for AuraConsensus {
 						// Babe service. If we only wait for the "warp sync" to finish while state
 						// sync is still in progress prior to switching, the warp sync will not
 						// complete successfully.
-                        let syncing = sync_service.status().await.is_ok_and(|status| status.warp_sync.is_some() || status.state_sync.is_some());
+                        let syncing = p.sync_service.status().await.is_ok_and(|status| status.warp_sync.is_some() || status.state_sync.is_some());
                         if !c.authorities.is_empty() && !syncing {
                             log::info!("Babe runtime detected! Intentionally failing the essential handle `babe-switch` to trigger switch to Babe service.");
                             if let Some(triggered) = triggered {

node/src/consensus/babe_consensus.rs

@@ -1,5 +1,6 @@
 use crate::consensus::ConsensusMechanism;
 use crate::consensus::StartAuthoringParams;
+use crate::consensus::consensus_mechanism::SpawnEssentialHandlesParams;
 use crate::{
     client::{FullBackend, FullClient},
     conditional_evm_block_import::ConditionalEVMBlockImport,
@@ -16,7 +17,6 @@ use sc_consensus_babe::{BabeLink, BabeWorkerHandle};
 use sc_consensus_babe_rpc::{Babe, BabeApiServer};
 use sc_consensus_grandpa::BlockNumberOps;
 use sc_consensus_slots::{BackoffAuthoringBlocksStrategy, InherentDataProviderExt};
-use sc_network_sync::SyncingService;
 use sc_service::{Configuration, TaskManager};
 use sc_telemetry::TelemetryHandle;
 use sc_transaction_pool::TransactionPoolHandle;
@@ -216,10 +216,7 @@ impl ConsensusMechanism for BabeConsensus {
 
     fn spawn_essential_handles(
         &self,
-        _task_manager: &mut TaskManager,
-        _client: Arc<FullClient>,
-        _triggered: Option<Arc<std::sync::atomic::AtomicBool>>,
-        _sync_service: Arc<SyncingService<Block>>,
+        _params: SpawnEssentialHandlesParams,
     ) -> Result<(), sc_service::Error> {
         // No additional Babe handles required.
         Ok(())

node/src/consensus/consensus_mechanism.rs

@@ -122,10 +122,7 @@ pub trait ConsensusMechanism {
     /// Spawns any consensus mechanism specific essential handles.
     fn spawn_essential_handles(
         &self,
-        task_manager: &mut TaskManager,
-        client: Arc<FullClient>,
-        triggered: Option<Arc<AtomicBool>>,
-        sync_service: Arc<SyncingService<Block>>,
+        params: SpawnEssentialHandlesParams,
     ) -> Result<(), ServiceError>;
 
     /// Returns any consensus mechanism specific rpc methods to register.
@@ -136,3 +133,26 @@ pub trait ConsensusMechanism {
         select_chain: FullSelectChain,
     ) -> Result<Vec<Methods>, sc_service::Error>;
 }
+
+pub struct SpawnEssentialHandlesParams<'a> {
+    pub task_manager: &'a mut TaskManager,
+    pub client: Arc<FullClient>,
+    pub triggered: Option<Arc<AtomicBool>>,
+    pub sync_service: Arc<SyncingService<Block>>,
+}
+
+impl<'a> SpawnEssentialHandlesParams<'a> {
+    pub fn new(
+        task_manager: &'a mut TaskManager,
+        client: Arc<FullClient>,
+        triggered: Option<Arc<AtomicBool>>,
+        sync_service: Arc<SyncingService<Block>>,
+    ) -> Self {
+        Self {
+            task_manager,
+            client,
+            triggered,
+            sync_service,
+        }
+    }
+}

node/src/consensus/mod.rs

@@ -6,4 +6,5 @@ mod hybrid_import_queue;
 pub use aura_consensus::AuraConsensus;
 pub use babe_consensus::BabeConsensus;
 pub use consensus_mechanism::ConsensusMechanism;
+pub use consensus_mechanism::SpawnEssentialHandlesParams;
 pub use consensus_mechanism::StartAuthoringParams;

node/src/service.rs

@@ -1,6 +1,7 @@
 //! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
 
 use crate::consensus::ConsensusMechanism;
+use crate::consensus::SpawnEssentialHandlesParams;
 use futures::{FutureExt, channel::mpsc, future};
 use node_subtensor_runtime::{RuntimeApi, TransactionConverter, opaque::Block};
 use sc_chain_spec::ChainType;
@@ -350,12 +351,12 @@ where
             metrics,
         })?;
 
-    consensus_mechanism.spawn_essential_handles(
+    consensus_mechanism.spawn_essential_handles(SpawnEssentialHandlesParams::new(
         &mut task_manager,
         client.clone(),
         custom_service_signal,
         sync_service.clone(),
-    )?;
+    ))?;
 
     if config.offchain_worker.enabled && config.role.is_authority() {
         let public_keys = keystore_container