Introduce interface for relay chain interaction (#835)

cumulus/client/service/src/lib.rs

@@ -20,9 +20,8 @@
 
 use cumulus_client_consensus_common::ParachainConsensus;
 use cumulus_primitives_core::{CollectCollationInfo, ParaId};
-use polkadot_overseer::Handle as OverseerHandle;
-use polkadot_primitives::v1::{Block as PBlock, CollatorPair};
-use polkadot_service::{AbstractClient, Client as PClient, ClientHandle, RuntimeApiCollection};
+use cumulus_relay_chain_interface::RelayChainInterface;
+use polkadot_primitives::v1::CollatorPair;
 use sc_client_api::{
 	Backend as BackendT, BlockBackend, BlockchainEvents, Finalizer, UsageProvider,
 };
@@ -30,47 +29,32 @@ use sc_consensus::{
 	import_queue::{ImportQueue, IncomingBlock, Link, Origin},
 	BlockImport,
 };
-use sc_service::{Configuration, Role, TaskManager};
-use sc_telemetry::TelemetryWorkerHandle;
+use sc_service::{Configuration, TaskManager};
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_consensus::BlockOrigin;
-use sp_core::{traits::SpawnNamed, Pair};
+use sp_core::traits::SpawnNamed;
 use sp_runtime::{
-	traits::{BlakeTwo256, Block as BlockT, NumberFor},
+	traits::{Block as BlockT, NumberFor},
 	Justifications,
 };
-use std::{marker::PhantomData, ops::Deref, sync::Arc};
+use std::{sync::Arc, time::Duration};
 
 pub mod genesis;
 
-/// The relay chain full node handle.
-pub struct RFullNode<C> {
-	/// The relay chain full node handles.
-	pub relay_chain_full_node: polkadot_service::NewFull<C>,
-	/// The collator key used by the node.
-	pub collator_key: CollatorPair,
-}
-
-impl<C> Deref for RFullNode<C> {
-	type Target = polkadot_service::NewFull<C>;
-
-	fn deref(&self) -> &Self::Target {
-		&self.relay_chain_full_node
-	}
-}
-
 /// Parameters given to [`start_collator`].
-pub struct StartCollatorParams<'a, Block: BlockT, BS, Client, Spawner, RClient, IQ> {
+pub struct StartCollatorParams<'a, Block: BlockT, BS, Client, RCInterface, Spawner, IQ> {
 	pub block_status: Arc<BS>,
 	pub client: Arc<Client>,
 	pub announce_block: Arc<dyn Fn(Block::Hash, Option<Vec<u8>>) + Send + Sync>,
 	pub spawner: Spawner,
 	pub para_id: ParaId,
-	pub relay_chain_full_node: RFullNode<RClient>,
+	pub relay_chain_interface: RCInterface,
 	pub task_manager: &'a mut TaskManager,
 	pub parachain_consensus: Box<dyn ParachainConsensus<Block>>,
 	pub import_queue: IQ,
+	pub collator_key: CollatorPair,
+	pub slot_duration: Duration,
 }
 
 /// Start a collator node for a parachain.
@@ -78,7 +62,7 @@ pub struct StartCollatorParams<'a, Block: BlockT, BS, Client, Spawner, RClient,
 /// A collator is similar to a validator in a normal blockchain.
 /// It is responsible for producing blocks and sending the blocks to a
 /// parachain validator for validation and inclusion into the relay chain.
-pub async fn start_collator<'a, Block, BS, Client, Backend, Spawner, RClient, IQ>(
+pub async fn start_collator<'a, Block, BS, Client, Backend, RCInterface, Spawner, IQ>(
 	StartCollatorParams {
 		block_status,
 		client,
@@ -86,10 +70,12 @@ pub async fn start_collator<'a, Block, BS, Client, Backend, Spawner, RClient, IQ
 		spawner,
 		para_id,
 		task_manager,
-		relay_chain_full_node,
+		relay_chain_interface,
 		parachain_consensus,
 		import_queue,
-	}: StartCollatorParams<'a, Block, BS, Client, Spawner, RClient, IQ>,
+		collator_key,
+		slot_duration,
+	}: StartCollatorParams<'a, Block, BS, Client, RCInterface, Spawner, IQ>,
 ) -> sc_service::error::Result<()>
 where
 	Block: BlockT,
@@ -106,55 +92,58 @@ where
 	Client::Api: CollectCollationInfo<Block>,
 	for<'b> &'b Client: BlockImport<Block>,
 	Spawner: SpawnNamed + Clone + Send + Sync + 'static,
-	RClient: ClientHandle,
+	RCInterface: RelayChainInterface + Clone + 'static,
 	Backend: BackendT<Block> + 'static,
 	IQ: ImportQueue<Block> + 'static,
 {
-	relay_chain_full_node.client.execute_with(StartConsensus {
+	let consensus = cumulus_client_consensus_common::run_parachain_consensus(
 		para_id,
-		announce_block: announce_block.clone(),
-		client: client.clone(),
-		task_manager,
-		_phantom: PhantomData,
-	});
+		client.clone(),
+		relay_chain_interface.clone(),
+		announce_block.clone(),
+	);
 
-	relay_chain_full_node.client.execute_with(StartPoVRecovery {
-		para_id,
-		client: client.clone(),
-		import_queue,
-		task_manager,
-		overseer_handle: relay_chain_full_node
-			.overseer_handle
-			.clone()
+	task_manager
+		.spawn_essential_handle()
+		.spawn("cumulus-consensus", None, consensus);
+
+	let pov_recovery = cumulus_client_pov_recovery::PoVRecovery::new(
+		relay_chain_interface
+			.overseer_handle()
 			.ok_or_else(|| "Polkadot full node did not provide an `OverseerHandle`!")?,
-		_phantom: PhantomData,
-	})?;
+		slot_duration,
+		client.clone(),
+		import_queue,
+		relay_chain_interface.clone(),
+		para_id,
+	);
+
+	task_manager
+		.spawn_essential_handle()
+		.spawn("cumulus-pov-recovery", None, pov_recovery.run());
 
 	cumulus_client_collator::start_collator(cumulus_client_collator::StartCollatorParams {
 		runtime_api: client.clone(),
 		block_status,
 		announce_block,
-		overseer_handle: relay_chain_full_node
-			.overseer_handle
-			.clone()
+		overseer_handle: relay_chain_interface
+			.overseer_handle()
 			.ok_or_else(|| "Polkadot full node did not provide an `OverseerHandle`!")?,
 		spawner,
 		para_id,
-		key: relay_chain_full_node.collator_key.clone(),
+		key: collator_key,
 		parachain_consensus,
 	})
 	.await;
 
-	task_manager.add_child(relay_chain_full_node.relay_chain_full_node.task_manager);
-
 	Ok(())
 }
 
 /// Parameters given to [`start_full_node`].
-pub struct StartFullNodeParams<'a, Block: BlockT, Client, PClient> {
+pub struct StartFullNodeParams<'a, Block: BlockT, Client, RCInterface> {
 	pub para_id: ParaId,
 	pub client: Arc<Client>,
-	pub relay_chain_full_node: RFullNode<PClient>,
+	pub relay_chain_interface: RCInterface,
 	pub task_manager: &'a mut TaskManager,
 	pub announce_block: Arc<dyn Fn(Block::Hash, Option<Vec<u8>>) + Send + Sync>,
 }
@@ -163,14 +152,14 @@ pub struct StartFullNodeParams<'a, Block: BlockT, Client, PClient> {
 ///
 /// A full node will only sync the given parachain and will follow the
 /// tip of the chain.
-pub fn start_full_node<Block, Client, Backend, PClient>(
+pub fn start_full_node<Block, Client, Backend, RCInterface>(
 	StartFullNodeParams {
 		client,
 		announce_block,
 		task_manager,
-		relay_chain_full_node,
+		relay_chain_interface,
 		para_id,
-	}: StartFullNodeParams<Block, Client, PClient>,
+	}: StartFullNodeParams<Block, Client, RCInterface>,
 ) -> sc_service::error::Result<()>
 where
 	Block: BlockT,
@@ -183,116 +172,22 @@ where
 		+ 'static,
 	for<'a> &'a Client: BlockImport<Block>,
 	Backend: BackendT<Block> + 'static,
-	PClient: ClientHandle,
+	RCInterface: RelayChainInterface + Clone + 'static,
 {
-	relay_chain_full_node.client.execute_with(StartConsensus {
-		announce_block,
+	let consensus = cumulus_client_consensus_common::run_parachain_consensus(
 		para_id,
-		client,
-		task_manager,
-		_phantom: PhantomData,
-	});
+		client.clone(),
+		relay_chain_interface.clone(),
+		announce_block,
+	);
 
-	task_manager.add_child(relay_chain_full_node.relay_chain_full_node.task_manager);
+	task_manager
+		.spawn_essential_handle()
+		.spawn("cumulus-consensus", None, consensus);
 
 	Ok(())
 }
 
-struct StartConsensus<'a, Block: BlockT, Client, Backend> {
-	para_id: ParaId,
-	announce_block: Arc<dyn Fn(Block::Hash, Option<Vec<u8>>) + Send + Sync>,
-	client: Arc<Client>,
-	task_manager: &'a mut TaskManager,
-	_phantom: PhantomData<Backend>,
-}
-
-impl<'a, Block, Client, Backend> polkadot_service::ExecuteWithClient
-	for StartConsensus<'a, Block, Client, Backend>
-where
-	Block: BlockT,
-	Client: Finalizer<Block, Backend>
-		+ UsageProvider<Block>
-		+ Send
-		+ Sync
-		+ BlockBackend<Block>
-		+ BlockchainEvents<Block>
-		+ 'static,
-	for<'b> &'b Client: BlockImport<Block>,
-	Backend: BackendT<Block> + 'static,
-{
-	type Output = ();
-
-	fn execute_with_client<PClient, Api, PBackend>(self, client: Arc<PClient>) -> Self::Output
-	where
-		<Api as sp_api::ApiExt<PBlock>>::StateBackend: sp_api::StateBackend<BlakeTwo256>,
-		PBackend: sc_client_api::Backend<PBlock>,
-		PBackend::State: sp_api::StateBackend<BlakeTwo256>,
-		Api: RuntimeApiCollection<StateBackend = PBackend::State>,
-		PClient: AbstractClient<PBlock, PBackend, Api = Api> + 'static,
-	{
-		let consensus = cumulus_client_consensus_common::run_parachain_consensus(
-			self.para_id,
-			self.client.clone(),
-			client.clone(),
-			self.announce_block,
-		);
-
-		self.task_manager
-			.spawn_essential_handle()
-			.spawn("cumulus-consensus", None, consensus);
-	}
-}
-
-struct StartPoVRecovery<'a, Block: BlockT, Client, IQ> {
-	para_id: ParaId,
-	client: Arc<Client>,
-	task_manager: &'a mut TaskManager,
-	overseer_handle: OverseerHandle,
-	import_queue: IQ,
-	_phantom: PhantomData<Block>,
-}
-
-impl<'a, Block, Client, IQ> polkadot_service::ExecuteWithClient
-	for StartPoVRecovery<'a, Block, Client, IQ>
-where
-	Block: BlockT,
-	Client: UsageProvider<Block>
-		+ Send
-		+ Sync
-		+ BlockBackend<Block>
-		+ BlockchainEvents<Block>
-		+ 'static,
-	IQ: ImportQueue<Block> + 'static,
-{
-	type Output = sc_service::error::Result<()>;
-
-	fn execute_with_client<PClient, Api, PBackend>(self, client: Arc<PClient>) -> Self::Output
-	where
-		<Api as sp_api::ApiExt<PBlock>>::StateBackend: sp_api::StateBackend<BlakeTwo256>,
-		PBackend: sc_client_api::Backend<PBlock>,
-		PBackend::State: sp_api::StateBackend<BlakeTwo256>,
-		Api: RuntimeApiCollection<StateBackend = PBackend::State>,
-		PClient: AbstractClient<PBlock, PBackend, Api = Api> + 'static,
-	{
-		let pov_recovery = cumulus_client_pov_recovery::PoVRecovery::new(
-			self.overseer_handle,
-			sc_consensus_babe::Config::get(&*client)?.slot_duration(),
-			self.client,
-			self.import_queue,
-			client,
-			self.para_id,
-		);
-
-		self.task_manager.spawn_essential_handle().spawn(
-			"cumulus-pov-recovery",
-			None,
-			pov_recovery.run(),
-		);
-
-		Ok(())
-	}
-}
-
 /// Prepare the parachain's node condifugration
 ///
 /// This function will disable the default announcement of Substrate for the parachain in favor
@@ -303,32 +198,6 @@ pub fn prepare_node_config(mut parachain_config: Configuration) -> Configuration
 	parachain_config
 }
 
-/// Build the Polkadot full node using the given `config`.
-#[sc_tracing::logging::prefix_logs_with("Relaychain")]
-pub fn build_polkadot_full_node(
-	config: Configuration,
-	telemetry_worker_handle: Option<TelemetryWorkerHandle>,
-) -> Result<RFullNode<PClient>, polkadot_service::Error> {
-	let is_light = matches!(config.role, Role::Light);
-	if is_light {
-		Err(polkadot_service::Error::Sub("Light client not supported.".into()))
-	} else {
-		let collator_key = CollatorPair::generate().0;
-
-		let relay_chain_full_node = polkadot_service::build_full(
-			config,
-			polkadot_service::IsCollator::Yes(collator_key.clone()),
-			None,
-			true,
-			None,
-			telemetry_worker_handle,
-			polkadot_service::RealOverseerGen,
-		)?;
-
-		Ok(RFullNode { relay_chain_full_node, collator_key })
-	}
-}
-
 /// A shared import queue
 ///
 /// This is basically a hack until the Substrate side is implemented properly.