Remove deprecated/unused consensus code (#9869)

This pull request removes unused consensus-related code from the
codebase. The removed code was not referenced or required by any
existing logic or features, and its removal helps to:

- Reduce technical debt
- Simplify the codebase for future maintenance

Author: RomarQ

cumulus/client/consensus/aura/src/lib.rs

@@ -18,44 +18,17 @@
 //! The AuRa consensus algorithm for parachains.
 //!
 //! This extends the Substrate provided AuRa consensus implementation to make it compatible for
-//! parachains. The main entry points for of this consensus algorithm are [`AuraConsensus::build`]
-//! and [`fn@import_queue`].
+//! parachains.
 //!
 //! For more information about AuRa, the Substrate crate should be checked.
 
-use codec::{Codec, Encode};
-use cumulus_client_consensus_common::{
-	ParachainBlockImportMarker, ParachainCandidate, ParachainConsensus,
-};
-use cumulus_primitives_core::{relay_chain::Hash as PHash, PersistedValidationData};
+use codec::Encode;
+use cumulus_primitives_core::PersistedValidationData;
 
 use cumulus_primitives_core::relay_chain::HeadData;
-use futures::lock::Mutex;
 use polkadot_primitives::{BlockNumber as RBlockNumber, Hash as RHash};
-use sc_client_api::{backend::AuxStore, BlockOf};
-use sc_consensus::BlockImport;
-use sc_consensus_slots::{BackoffAuthoringBlocksStrategy, SimpleSlotWorker, SlotInfo};
-use sc_telemetry::TelemetryHandle;
-use sp_api::ProvideRuntimeApi;
-use sp_application_crypto::AppPublic;
-use sp_blockchain::HeaderBackend;
-use sp_consensus::{EnableProofRecording, Environment, ProofRecording, Proposer, SyncOracle};
-use sp_consensus_aura::{AuraApi, SlotDuration};
-use sp_core::crypto::Pair;
-use sp_inherents::CreateInherentDataProviders;
-use sp_keystore::KeystorePtr;
-use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member, NumberFor};
-use std::{
-	convert::TryFrom,
-	fs,
-	fs::File,
-	marker::PhantomData,
-	path::PathBuf,
-	sync::{
-		atomic::{AtomicU64, Ordering},
-		Arc,
-	},
-};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::{fs, fs::File, path::PathBuf};
 
 mod import_queue;
 
@@ -73,192 +46,6 @@ pub mod equivocation_import_queue;
 
 const LOG_TARGET: &str = "aura::cumulus";
 
-/// The implementation of the AURA consensus for parachains.
-pub struct AuraConsensus<B, CIDP, W> {
-	create_inherent_data_providers: Arc<CIDP>,
-	aura_worker: Arc<Mutex<W>>,
-	slot_duration: SlotDuration,
-	last_slot_processed: Arc<AtomicU64>,
-	_phantom: PhantomData<B>,
-}
-
-impl<B, CIDP, W> Clone for AuraConsensus<B, CIDP, W> {
-	fn clone(&self) -> Self {
-		Self {
-			create_inherent_data_providers: self.create_inherent_data_providers.clone(),
-			aura_worker: self.aura_worker.clone(),
-			slot_duration: self.slot_duration,
-			last_slot_processed: self.last_slot_processed.clone(),
-			_phantom: PhantomData,
-		}
-	}
-}
-
-/// Parameters of [`AuraConsensus::build`].
-#[deprecated = "Use the `aura::collators::basic` collator instead"]
-pub struct BuildAuraConsensusParams<PF, BI, CIDP, Client, BS, SO> {
-	pub proposer_factory: PF,
-	pub create_inherent_data_providers: CIDP,
-	pub block_import: BI,
-	pub para_client: Arc<Client>,
-	pub backoff_authoring_blocks: Option<BS>,
-	pub sync_oracle: SO,
-	pub keystore: KeystorePtr,
-	pub force_authoring: bool,
-	pub slot_duration: SlotDuration,
-	pub telemetry: Option<TelemetryHandle>,
-	pub block_proposal_slot_portion: SlotProportion,
-	pub max_block_proposal_slot_portion: Option<SlotProportion>,
-}
-
-impl<B, CIDP> AuraConsensus<B, CIDP, ()>
-where
-	B: BlockT,
-	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)> + 'static,
-	CIDP::InherentDataProviders: InherentDataProviderExt,
-{
-	/// Create a new boxed instance of AURA consensus.
-	#[allow(deprecated)]
-	#[deprecated = "Use the `aura::collators::basic` collator instead"]
-	pub fn build<P, Client, BI, SO, PF, BS, Error>(
-		BuildAuraConsensusParams {
-			proposer_factory,
-			create_inherent_data_providers,
-			block_import,
-			para_client,
-			backoff_authoring_blocks,
-			sync_oracle,
-			keystore,
-			force_authoring,
-			slot_duration,
-			telemetry,
-			block_proposal_slot_portion,
-			max_block_proposal_slot_portion,
-		}: BuildAuraConsensusParams<PF, BI, CIDP, Client, BS, SO>,
-	) -> Box<dyn ParachainConsensus<B>>
-	where
-		Client:
-			ProvideRuntimeApi<B> + BlockOf + AuxStore + HeaderBackend<B> + Send + Sync + 'static,
-		Client::Api: AuraApi<B, P::Public>,
-		BI: BlockImport<B> + ParachainBlockImportMarker + Send + Sync + 'static,
-		SO: SyncOracle + Send + Sync + Clone + 'static,
-		BS: BackoffAuthoringBlocksStrategy<NumberFor<B>> + Send + Sync + 'static,
-		PF: Environment<B, Error = Error> + Send + Sync + 'static,
-		PF::Proposer: Proposer<
-			B,
-			Error = Error,
-			ProofRecording = EnableProofRecording,
-			Proof = <EnableProofRecording as ProofRecording>::Proof,
-		>,
-		Error: std::error::Error + Send + From<sp_consensus::Error> + 'static,
-		P: Pair + 'static,
-		P::Public: AppPublic + Member + Codec,
-		P::Signature: TryFrom<Vec<u8>> + Member + Codec,
-	{
-		let worker = sc_consensus_aura::build_aura_worker::<P, _, _, _, _, _, _, _, _>(
-			BuildAuraWorkerParams {
-				client: para_client,
-				block_import,
-				justification_sync_link: (),
-				proposer_factory,
-				sync_oracle,
-				force_authoring,
-				backoff_authoring_blocks,
-				keystore,
-				telemetry,
-				block_proposal_slot_portion,
-				max_block_proposal_slot_portion,
-				compatibility_mode: sc_consensus_aura::CompatibilityMode::None,
-			},
-		);
-
-		Box::new(AuraConsensus {
-			create_inherent_data_providers: Arc::new(create_inherent_data_providers),
-			aura_worker: Arc::new(Mutex::new(worker)),
-			last_slot_processed: Default::default(),
-			slot_duration,
-			_phantom: PhantomData,
-		})
-	}
-}
-
-impl<B, CIDP, W> AuraConsensus<B, CIDP, W>
-where
-	B: BlockT,
-	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)> + 'static,
-	CIDP::InherentDataProviders: InherentDataProviderExt,
-{
-	/// Create the inherent data.
-	///
-	/// Returns the created inherent data and the inherent data providers used.
-	async fn inherent_data(
-		&self,
-		parent: B::Hash,
-		validation_data: &PersistedValidationData,
-		relay_parent: PHash,
-	) -> Option<CIDP::InherentDataProviders> {
-		self.create_inherent_data_providers
-			.create_inherent_data_providers(parent, (relay_parent, validation_data.clone()))
-			.await
-			.map_err(|e| {
-				tracing::error!(
-					target: LOG_TARGET,
-					error = ?e,
-					"Failed to create inherent data providers.",
-				)
-			})
-			.ok()
-	}
-}
-
-#[async_trait::async_trait]
-impl<B, CIDP, W> ParachainConsensus<B> for AuraConsensus<B, CIDP, W>
-where
-	B: BlockT,
-	CIDP: CreateInherentDataProviders<B, (PHash, PersistedValidationData)> + Send + Sync + 'static,
-	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
-	W: SimpleSlotWorker<B> + Send + Sync,
-	W::Proposer: Proposer<B, Proof = <EnableProofRecording as ProofRecording>::Proof>,
-{
-	async fn produce_candidate(
-		&mut self,
-		parent: &B::Header,
-		relay_parent: PHash,
-		validation_data: &PersistedValidationData,
-	) -> Option<ParachainCandidate<B>> {
-		let inherent_data_providers =
-			self.inherent_data(parent.hash(), validation_data, relay_parent).await?;
-
-		let info = SlotInfo::new(
-			inherent_data_providers.slot(),
-			Box::new(inherent_data_providers),
-			self.slot_duration.as_duration(),
-			parent.clone(),
-			// Set the block limit to 50% of the maximum PoV size.
-			//
-			// TODO: If we got benchmarking that includes the proof size,
-			// we should be able to use the maximum pov size.
-			Some((validation_data.max_pov_size / 2) as usize),
-		);
-
-		// With async backing this function will be called every relay chain block.
-		//
-		// Most parachains currently run with 12 seconds slots and thus, they would try to produce
-		// multiple blocks per slot which very likely would fail on chain. Thus, we have this "hack"
-		// to only produce on block per slot.
-		//
-		// With https://github.com/paritytech/polkadot-sdk/issues/3168 this implementation will be
-		// obsolete and also the underlying issue will be fixed.
-		if self.last_slot_processed.fetch_max(*info.slot, Ordering::Relaxed) >= *info.slot {
-			return None
-		}
-
-		let res = self.aura_worker.lock().await.on_slot(info).await?;
-
-		Some(ParachainCandidate { block: res.block, proof: res.storage_proof })
-	}
-}
-
 /// Export the given `pov` to the file system at `path`.
 ///
 /// The file will be named `block_hash_block_number.pov`.

cumulus/client/consensus/common/src/lib.rs

@@ -16,9 +16,7 @@
 // along with Cumulus. If not, see <https://www.gnu.org/licenses/>.
 
 use codec::Decode;
-use polkadot_primitives::{
-	Block as PBlock, Hash as PHash, Header as PHeader, PersistedValidationData, ValidationCodeHash,
-};
+use polkadot_primitives::{Block as PBlock, Hash as PHash, Header as PHeader, ValidationCodeHash};
 
 use cumulus_primitives_core::{relay_chain, AbridgedHostConfiguration};
 use cumulus_relay_chain_interface::{RelayChainError, RelayChainInterface};
@@ -63,54 +61,14 @@ where
 	}
 }
 
-/// The result of [`ParachainConsensus::produce_candidate`].
+/// The result from building a collation.
 pub struct ParachainCandidate<B> {
 	/// The block that was built for this candidate.
 	pub block: B,
 	/// The proof that was recorded while building the block.
 	pub proof: sp_trie::StorageProof,
 }
 
-/// A specific parachain consensus implementation that can be used by a collator to produce
-/// candidates.
-///
-/// The collator will call [`Self::produce_candidate`] every time there is a free core for the
-/// parachain this collator is collating for. It is the job of the consensus implementation to
-/// decide if this specific collator should build a candidate for the given relay chain block. The
-/// consensus implementation could, for example, check whether this specific collator is part of a
-/// staked set.
-#[async_trait::async_trait]
-pub trait ParachainConsensus<B: BlockT>: Send + Sync + dyn_clone::DynClone {
-	/// Produce a new candidate at the given parent block and relay-parent blocks.
-	///
-	/// Should return `None` if the consensus implementation decided that it shouldn't build a
-	/// candidate or if there occurred any error.
-	///
-	/// # NOTE
-	///
-	/// It is expected that the block is already imported when the future resolves.
-	async fn produce_candidate(
-		&mut self,
-		parent: &B::Header,
-		relay_parent: PHash,
-		validation_data: &PersistedValidationData,
-	) -> Option<ParachainCandidate<B>>;
-}
-
-dyn_clone::clone_trait_object!(<B> ParachainConsensus<B> where B: BlockT);
-
-#[async_trait::async_trait]
-impl<B: BlockT> ParachainConsensus<B> for Box<dyn ParachainConsensus<B> + Send + Sync> {
-	async fn produce_candidate(
-		&mut self,
-		parent: &B::Header,
-		relay_parent: PHash,
-		validation_data: &PersistedValidationData,
-	) -> Option<ParachainCandidate<B>> {
-		(*self).produce_candidate(parent, relay_parent, validation_data).await
-	}
-}
-
 /// Parachain specific block import.
 ///
 /// Specialized block import for parachains. It supports to delay setting the best block until the

cumulus/client/consensus/common/src/tests.rs

@@ -22,7 +22,7 @@ use codec::Encode;
 use cumulus_client_pov_recovery::RecoveryKind;
 use cumulus_primitives_core::{
 	relay_chain::{BlockId, BlockNumber, CoreState},
-	CumulusDigestItem, InboundDownwardMessage, InboundHrmpMessage,
+	CumulusDigestItem, InboundDownwardMessage, InboundHrmpMessage, PersistedValidationData,
 };
 use cumulus_relay_chain_interface::{
 	CommittedCandidateReceipt, CoreIndex, OccupiedCoreAssumption, OverseerHandle, PHeader, ParaId,

cumulus/client/consensus/relay-chain/src/import_queue.rs

@@ -17,16 +17,9 @@
 
 use std::{marker::PhantomData, sync::Arc};
 
-use cumulus_client_consensus_common::ParachainBlockImportMarker;
-
-use sc_consensus::{
-	import_queue::{BasicQueue, Verifier as VerifierT},
-	BlockImport, BlockImportParams,
-};
+use sc_consensus::{import_queue::Verifier as VerifierT, BlockImportParams};
 use sp_api::ProvideRuntimeApi;
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
-use sp_blockchain::Result as ClientResult;
-use sp_consensus::error::Error as ConsensusError;
 use sp_inherents::CreateInherentDataProviders;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 
@@ -93,26 +86,3 @@ where
 		Ok(block_params)
 	}
 }
-
-/// Start an import queue for a Cumulus collator that does not uses any special authoring logic.
-pub fn import_queue<Client, Block: BlockT, I, CIDP>(
-	client: Arc<Client>,
-	block_import: I,
-	create_inherent_data_providers: CIDP,
-	spawner: &impl sp_core::traits::SpawnEssentialNamed,
-	registry: Option<&prometheus_endpoint::Registry>,
-) -> ClientResult<BasicQueue<Block>>
-where
-	I: BlockImport<Block, Error = ConsensusError>
-		+ ParachainBlockImportMarker
-		+ Send
-		+ Sync
-		+ 'static,
-	Client: ProvideRuntimeApi<Block> + Send + Sync + 'static,
-	<Client as ProvideRuntimeApi<Block>>::Api: BlockBuilderApi<Block>,
-	CIDP: CreateInherentDataProviders<Block, ()> + 'static,
-{
-	let verifier = Verifier::new(client, create_inherent_data_providers);
-
-	Ok(BasicQueue::new(verifier, Box::new(block_import), None, spawner, registry))
-}