Integrate new Aura / Parachain Consensus Logic in Parachain-Template …

…/ Polkadot-Parachain (#2864)

* add a comment

* refactor client/service utilities

* deprecate start_collator

* update parachain-template

* update test-service in the same way

* update polkadot-parachain crate

* fmt

* wire up new SubmitCollation message

* some runtime utilities for implementing unincluded segment runtime APIs

* allow parachains to configure their level of sybil-resistance when starting the network

* make aura-ext compile

* update to specify sybil resistance levels

* fmt

* specify relay chain slot duration in milliseconds

* update Aura to explicitly produce Send futures

also, make relay_chain_slot_duration a Duration

* add authoring duration to basic collator and document params

* integrate new basic collator into parachain-template

* remove assert_send used for testing

* basic-aura: only author when parent included

* update polkadot-parachain-bin

* fmt

* some fixes

* fixes

* add a RelayNumberMonotonicallyIncreases

* add a utility function for initializing subsystems

* some logging for timestamp adjustment

* fmt

* some fixes for lookahead collator

* add a log

* update `find_potential_parents` to account for sessions

* bound the loop

* restore & deprecate old start_collator and start_full_node functions.

* remove unnecessary await calls

* fix warning

* clippy

* more clippy

* remove unneeded logic

* ci

client/collator/src/lib.rs

@@ -26,7 +26,8 @@ use sp_core::traits::SpawnNamed;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 
 use cumulus_client_consensus_common::ParachainConsensus;
-use polkadot_node_primitives::{CollationResult, MaybeCompressedPoV};
+use polkadot_node_primitives::{CollationGenerationConfig, CollationResult, MaybeCompressedPoV};
+use polkadot_node_subsystem::messages::{CollationGenerationMessage, CollatorProtocolMessage};
 use polkadot_overseer::Handle as OverseerHandle;
 use polkadot_primitives::{CollatorPair, Id as ParaId};
 
@@ -233,6 +234,31 @@ pub mod relay_chain_driven {
 	}
 }
 
+/// Initialize the collation-related subsystems on the relay-chain side.
+///
+/// This must be done prior to collation, and does not set up any callback for collation.
+/// For callback-driven collators, use the [`relay_chain_driven`] module.
+pub async fn initialize_collator_subsystems(
+	overseer_handle: &mut OverseerHandle,
+	key: CollatorPair,
+	para_id: ParaId,
+) {
+	overseer_handle
+		.send_msg(
+			CollationGenerationMessage::Initialize(CollationGenerationConfig {
+				key,
+				para_id,
+				collator: None,
+			}),
+			"StartCollator",
+		)
+		.await;
+
+	overseer_handle
+		.send_msg(CollatorProtocolMessage::CollateOn(para_id), "StartCollator")
+		.await;
+}
+
 /// Parameters for [`start_collator`].
 pub struct StartCollatorParams<Block: BlockT, RA, BS, Spawner> {
 	pub para_id: ParaId,
@@ -246,7 +272,24 @@ pub struct StartCollatorParams<Block: BlockT, RA, BS, Spawner> {
 }
 
 /// Start the collator.
+#[deprecated = "Collators should run consensus futures which handle this logic internally"]
 pub async fn start_collator<Block, RA, BS, Spawner>(
+	params: StartCollatorParams<Block, RA, BS, Spawner>,
+) where
+	Block: BlockT,
+	BS: BlockBackend<Block> + Send + Sync + 'static,
+	Spawner: SpawnNamed + Clone + Send + Sync + 'static,
+	RA: ProvideRuntimeApi<Block> + Send + Sync + 'static,
+	RA::Api: CollectCollationInfo<Block>,
+{
+	// This never needed to be asynchronous, but shouldn't be changed due to backcompat.
+	#[allow(deprecated)]
+	start_collator_sync(params);
+}
+
+/// Start the collator in a synchronous function.
+#[deprecated = "Collators should run consensus futures which handle this logic internally"]
+pub fn start_collator_sync<Block, RA, BS, Spawner>(
 	StartCollatorParams {
 		para_id,
 		block_status,
@@ -269,9 +312,8 @@ pub async fn start_collator<Block, RA, BS, Spawner>(
 
 	let collator = Collator::new(collator_service, parachain_consensus);
 
-	let mut request_stream = relay_chain_driven::init(key, para_id, overseer_handle).await;
-
 	let collation_future = Box::pin(async move {
+		let mut request_stream = relay_chain_driven::init(key, para_id, overseer_handle).await;
 		while let Some(request) = request_stream.next().await {
 			let collation = collator
 				.clone()
@@ -375,6 +417,7 @@ mod tests {
 
 		spawner.spawn("overseer", None, overseer.run().then(|_| async {}).boxed());
 
+		#[allow(deprecated)]
 		let collator_start = start_collator(StartCollatorParams {
 			runtime_api: client.clone(),
 			block_status: client.clone(),

client/consensus/aura/Cargo.toml

@@ -45,4 +45,5 @@ cumulus-client-collator = { path = "../../collator" }
 # Polkadot
 polkadot-primitives = { git = "https://github.com/paritytech/polkadot", branch = "rh-async-backing-feature" }
 polkadot-node-primitives = { git = "https://github.com/paritytech/polkadot", branch = "rh-async-backing-feature" }
+polkadot-node-subsystem = { git = "https://github.com/paritytech/polkadot", branch = "rh-async-backing-feature" }
 polkadot-overseer = { git = "https://github.com/paritytech/polkadot", branch = "rh-async-backing-feature" }

client/consensus/aura/src/collator.rs

@@ -55,7 +55,7 @@ use sp_runtime::{
 };
 use sp_state_machine::StorageChanges;
 use sp_timestamp::Timestamp;
-use std::{convert::TryFrom, error::Error, sync::Arc, time::Duration};
+use std::{convert::TryFrom, error::Error, time::Duration};
 
 /// Parameters for instantiating a [`Collator`].
 pub struct Params<BI, CIDP, RClient, Proposer, CS> {
@@ -64,7 +64,7 @@ pub struct Params<BI, CIDP, RClient, Proposer, CS> {
 	/// The block import handle.
 	pub block_import: BI,
 	/// An interface to the relay-chain client.
-	pub relay_client: Arc<RClient>,
+	pub relay_client: RClient,
 	/// The keystore handle used for accessing parachain key material.
 	pub keystore: KeystorePtr,
 	/// The identifier of the parachain within the relay-chain.
@@ -81,7 +81,7 @@ pub struct Params<BI, CIDP, RClient, Proposer, CS> {
 pub struct Collator<Block, P, BI, CIDP, RClient, Proposer, CS> {
 	create_inherent_data_providers: CIDP,
 	block_import: BI,
-	relay_client: Arc<RClient>,
+	relay_client: RClient,
 	keystore: KeystorePtr,
 	para_id: ParaId,
 	proposer: Proposer,
@@ -124,7 +124,7 @@ where
 		validation_data: &PersistedValidationData,
 		parent_hash: Block::Hash,
 		timestamp: impl Into<Option<Timestamp>>,
-	) -> Result<(ParachainInherentData, InherentData), Box<dyn Error>> {
+	) -> Result<(ParachainInherentData, InherentData), Box<dyn Error + Send + Sync + 'static>> {
 		let paras_inherent_data = ParachainInherentData::create_at(
 			relay_parent,
 			&self.relay_client,
@@ -144,7 +144,7 @@ where
 		let mut other_inherent_data = self
 			.create_inherent_data_providers
 			.create_inherent_data_providers(parent_hash, ())
-			.map_err(|e| e as Box<dyn Error>)
+			.map_err(|e| e as Box<dyn Error + Send + Sync + 'static>)
 			.await?
 			.create_inherent_data()
 			.await
@@ -173,7 +173,8 @@ where
 		inherent_data: (ParachainInherentData, InherentData),
 		proposal_duration: Duration,
 		max_pov_size: usize,
-	) -> Result<(Collation, ParachainBlockData<Block>, Block::Hash), Box<dyn Error>> {
+	) -> Result<(Collation, ParachainBlockData<Block>, Block::Hash), Box<dyn Error + Send + 'static>>
+	{
 		let mut digest = additional_pre_digest.into().unwrap_or_default();
 		digest.push(slot_claim.pre_digest.clone());
 
@@ -188,14 +189,15 @@ where
 				Some(max_pov_size),
 			)
 			.await
-			.map_err(|e| Box::new(e))?;
+			.map_err(|e| Box::new(e) as Box<dyn Error + Send>)?;
 
 		let sealed_importable = seal::<_, _, P>(
 			proposal.block,
 			proposal.storage_changes,
 			&slot_claim.author_pub,
 			&self.keystore,
-		)?;
+		)
+		.map_err(|e| e as Box<dyn Error + Send>)?;
 
 		let post_hash = sealed_importable.post_hash();
 		let block = Block::new(
@@ -207,7 +209,10 @@ where
 				.clone(),
 		);
 
-		self.block_import.import_block(sealed_importable).await?;
+		self.block_import
+			.import_block(sealed_importable)
+			.map_err(|e| Box::new(e) as Box<dyn Error + Send>)
+			.await?;
 
 		if let Some((collation, block_data)) = self.collator_service.build_collation(
 			parent_header,
@@ -232,7 +237,8 @@ where
 
 			Ok((collation, block_data, post_hash))
 		} else {
-			Err("Unable to produce collation".to_string().into())
+			Err(Box::<dyn Error + Send + Sync>::from("Unable to produce collation")
+				as Box<dyn Error + Send>)
 		}
 	}
 
@@ -286,7 +292,7 @@ pub async fn claim_slot<B, C, P>(
 	parent_hash: B::Hash,
 	relay_parent_header: &PHeader,
 	slot_duration: SlotDuration,
-	relay_chain_slot_duration: SlotDuration,
+	relay_chain_slot_duration: Duration,
 	keystore: &KeystorePtr,
 ) -> Result<Option<SlotClaim<P::Public>>, Box<dyn Error>>
 where
@@ -305,7 +311,19 @@ where
 		relay_parent_header,
 		relay_chain_slot_duration,
 	) {
-		Some((_, t)) => (Slot::from_timestamp(t, slot_duration), t),
+		Some((r_s, t)) => {
+			let our_slot = Slot::from_timestamp(t, slot_duration);
+			tracing::debug!(
+				target: crate::LOG_TARGET,
+				relay_slot = ?r_s,
+				para_slot = ?our_slot,
+				timestamp = ?t,
+				?slot_duration,
+				?relay_chain_slot_duration,
+				"Adjusted relay-chain slot to parachain slot"
+			);
+			(our_slot, t)
+		},
 		None => return Ok(None),
 	};
 
@@ -327,7 +345,7 @@ pub fn seal<B: BlockT, T, P>(
 	storage_changes: StorageChanges<T, HashingFor<B>>,
 	author_pub: &P::Public,
 	keystore: &KeystorePtr,
-) -> Result<BlockImportParams<B, T>, Box<dyn Error>>
+) -> Result<BlockImportParams<B, T>, Box<dyn Error + Send + Sync + 'static>>
 where
 	P: Pair,
 	P::Signature: Codec + TryFrom<Vec<u8>>,