check inherents and equivocations in import_block

cumulus/client/consensus/aura/src/collators/basic.rs

@@ -23,6 +23,7 @@
 //!
 //! For more information about AuRa, the Substrate crate should be checked.
 
+use super::ValidatingBlockImport;
 use codec::{Codec, Decode};
 use cumulus_client_collator::{
 	relay_chain_driven::CollationRequest, service::ServiceInterface as CollatorServiceInterface,
@@ -39,8 +40,10 @@ use polkadot_primitives::{CollatorPair, Id as ParaId, ValidationCode};
 use futures::{channel::mpsc::Receiver, prelude::*};
 use sc_client_api::{backend::AuxStore, BlockBackend, BlockOf};
 use sc_consensus::BlockImport;
+use sc_consensus_slots::InherentDataProviderExt;
 use sp_api::{CallApiAt, ProvideRuntimeApi};
 use sp_application_crypto::AppPublic;
+use sp_block_builder::BlockBuilder;
 use sp_blockchain::HeaderBackend;
 use sp_consensus_aura::AuraApi;
 use sp_core::crypto::Pair;
@@ -101,14 +104,15 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	Client::Api: AuraApi<Block, P::Public> + CollectCollationInfo<Block>,
+	Client::Api: BlockBuilder<Block> + AuraApi<Block, P::Public> + CollectCollationInfo<Block>,
 	RClient: RelayChainInterface + Send + Clone + 'static,
-	CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
-	CIDP::InherentDataProviders: Send,
+	CIDP: CreateInherentDataProviders<Block, ()> + Clone + Send + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
 	BI: BlockImport<Block> + ParachainBlockImportMarker + Send + Sync + 'static,
+	BI::Error: Into<sp_consensus::Error>,
 	Proposer: ProposerInterface<Block> + Send + Sync + 'static,
 	CS: CollatorServiceInterface<Block> + Send + Sync + 'static,
-	P: Pair,
+	P: Pair + Sync + Send + 'static,
 	P::Public: AppPublic + Member + Codec,
 	P::Signature: TryFrom<Vec<u8>> + Member + Codec,
 {
@@ -126,8 +130,14 @@ where
 
 		let mut collator = {
 			let params = collator_util::Params {
-				create_inherent_data_providers: params.create_inherent_data_providers,
-				block_import: params.block_import,
+				create_inherent_data_providers: params.create_inherent_data_providers.clone(),
+				block_import: ValidatingBlockImport::<_, _, _, _, P>::new(
+					params.block_import,
+					params.para_client.clone(),
+					params.create_inherent_data_providers.clone(),
+					true,
+					Default::default(),
+				),
 				relay_client: params.relay_client.clone(),
 				keystore: params.keystore.clone(),
 				para_id: params.para_id,

cumulus/client/consensus/aura/src/collators/lookahead.rs

@@ -32,6 +32,7 @@
 //! The main limitation is block propagation time - i.e. the new blocks created by an author
 //! must be propagated to the next author before their turn.
 
+use super::ValidatingBlockImport;
 use codec::{Codec, Encode};
 use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface;
 use cumulus_client_consensus_common::{self as consensus_common, ParachainBlockImportMarker};
@@ -46,6 +47,8 @@ use polkadot_overseer::Handle as OverseerHandle;
 use polkadot_primitives::{
 	vstaging::DEFAULT_CLAIM_QUEUE_OFFSET, CollatorPair, Id as ParaId, OccupiedCoreAssumption,
 };
+use sc_consensus_slots::InherentDataProviderExt;
+use sp_block_builder::BlockBuilder;
 
 use crate::{collator as collator_util, export_pov_to_path};
 use futures::prelude::*;
@@ -114,17 +117,20 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	Client::Api:
-		AuraApi<Block, P::Public> + CollectCollationInfo<Block> + AuraUnincludedSegmentApi<Block>,
+	Client::Api: BlockBuilder<Block>
+		+ AuraApi<Block, P::Public>
+		+ CollectCollationInfo<Block>
+		+ AuraUnincludedSegmentApi<Block>,
 	Backend: sc_client_api::Backend<Block> + 'static,
 	RClient: RelayChainInterface + Clone + 'static,
-	CIDP: CreateInherentDataProviders<Block, ()> + 'static,
-	CIDP::InherentDataProviders: Send,
+	CIDP: CreateInherentDataProviders<Block, ()> + Clone + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
 	BI: BlockImport<Block> + ParachainBlockImportMarker + Send + Sync + 'static,
+	BI::Error: Into<sp_consensus::Error>,
 	Proposer: ProposerInterface<Block> + Send + Sync + 'static,
 	CS: CollatorServiceInterface<Block> + Send + Sync + 'static,
 	CHP: consensus_common::ValidationCodeHashProvider<Block::Hash> + Send + 'static,
-	P: Pair,
+	P: Pair + Send + Sync + 'static,
 	P::Public: AppPublic + Member + Codec,
 	P::Signature: TryFrom<Vec<u8>> + Member + Codec,
 {
@@ -166,17 +172,20 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	Client::Api:
-		AuraApi<Block, P::Public> + CollectCollationInfo<Block> + AuraUnincludedSegmentApi<Block>,
+	Client::Api: BlockBuilder<Block>
+		+ AuraApi<Block, P::Public>
+		+ CollectCollationInfo<Block>
+		+ AuraUnincludedSegmentApi<Block>,
 	Backend: sc_client_api::Backend<Block> + 'static,
 	RClient: RelayChainInterface + Clone + 'static,
-	CIDP: CreateInherentDataProviders<Block, ()> + 'static,
-	CIDP::InherentDataProviders: Send,
+	CIDP: CreateInherentDataProviders<Block, ()> + Clone + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
 	BI: BlockImport<Block> + ParachainBlockImportMarker + Send + Sync + 'static,
+	BI::Error: Into<sp_consensus::Error>,
 	Proposer: ProposerInterface<Block> + Send + Sync + 'static,
 	CS: CollatorServiceInterface<Block> + Send + Sync + 'static,
 	CHP: consensus_common::ValidationCodeHashProvider<Block::Hash> + Send + 'static,
-	P: Pair,
+	P: Pair + Send + Sync + 'static,
 	P::Public: AppPublic + Member + Codec,
 	P::Signature: TryFrom<Vec<u8>> + Member + Codec,
 {
@@ -205,8 +214,14 @@ where
 
 		let mut collator = {
 			let params = collator_util::Params {
-				create_inherent_data_providers: params.create_inherent_data_providers,
-				block_import: params.block_import,
+				create_inherent_data_providers: params.create_inherent_data_providers.clone(),
+				block_import: ValidatingBlockImport::<_, _, _, _, P>::new(
+					params.block_import,
+					params.para_client.clone(),
+					params.create_inherent_data_providers.clone(),
+					true,
+					Default::default(),
+				),
 				relay_client: params.relay_client.clone(),
 				keystore: params.keystore.clone(),
 				para_id: params.para_id,

cumulus/client/consensus/aura/src/collators/mod.rs

@@ -21,9 +21,14 @@
 //! included parachain block, as well as the [`lookahead`] collator, which prospectively
 //! builds on parachain blocks which have not yet been included in the relay chain.
 
-use crate::collator::SlotClaim;
+use std::sync::Arc;
+
+use crate::{collator::SlotClaim, LOG_TARGET};
+use async_trait::async_trait;
 use codec::Codec;
-use cumulus_client_consensus_common::{self as consensus_common, ParentSearchParams};
+use cumulus_client_consensus_common::{
+	self as consensus_common, ParachainBlockImportMarker, ParentSearchParams,
+};
 use cumulus_primitives_aura::{AuraUnincludedSegmentApi, Slot};
 use cumulus_primitives_core::{relay_chain::Hash as ParaHash, BlockT, ClaimQueueOffset};
 use cumulus_relay_chain_interface::RelayChainInterface;
@@ -33,10 +38,16 @@ use polkadot_primitives::{
 	CoreIndex, Hash as RelayHash, Id as ParaId, OccupiedCoreAssumption, ValidationCodeHash,
 	DEFAULT_SCHEDULING_LOOKAHEAD,
 };
-use sc_consensus_aura::{standalone as aura_internal, AuraApi};
-use sp_api::{ApiExt, ProvideRuntimeApi, RuntimeApiInfo};
+use sc_consensus::{BlockCheckParams, BlockImport, BlockImportParams, ImportResult};
+use sc_consensus_aura::{find_pre_digest, standalone as aura_internal, AuraApi, CompatibilityMode};
+use sc_consensus_slots::InherentDataProviderExt;
+use sp_api::{ApiExt, Core, ProvideRuntimeApi, RuntimeApiInfo};
+use sp_block_builder::BlockBuilder;
+use sp_consensus_aura::inherents::AuraInherentData;
 use sp_core::Pair;
+use sp_inherents::InherentDataProvider;
 use sp_keystore::KeystorePtr;
+use sp_runtime::traits::{Header, NumberFor};
 use sp_timestamp::Timestamp;
 
 pub mod basic;
@@ -270,6 +281,174 @@ where
 		.map(|parent| (included_block, parent))
 }
 
+struct ValidatingBlockImport<BI, Client, CIDP, N, P> {
+	inner: BI,
+	client: Arc<Client>,
+	create_inherent_data_providers: CIDP,
+	check_for_equivocation: bool,
+	compatibility_mode: CompatibilityMode<N>,
+	_phantom: std::marker::PhantomData<P>,
+}
+
+impl<BI, Client, CIDP, N, P> ValidatingBlockImport<BI, Client, CIDP, N, P> {
+	pub fn new(
+		inner: BI,
+		client: Arc<Client>,
+		create_inherent_data_providers: CIDP,
+		check_for_equivocation: bool,
+		compatibility_mode: CompatibilityMode<N>,
+	) -> Self {
+		Self {
+			inner,
+			client,
+			create_inherent_data_providers,
+			check_for_equivocation,
+			compatibility_mode,
+			_phantom: Default::default(),
+		}
+	}
+}
+
+#[async_trait]
+impl<Block, BI, Client, CIDP, P> BlockImport<Block>
+	for ValidatingBlockImport<BI, Client, CIDP, NumberFor<Block>, P>
+where
+	Block: BlockT,
+	BI: BlockImport<Block> + Sync,
+	BI::Error: Into<sp_consensus::Error>,
+	Client: ProvideRuntimeApi<Block> + sc_client_api::backend::AuxStore + Send + Sync,
+	Client::Api: Core<Block> + BlockBuilder<Block> + AuraApi<Block, <P as Pair>::Public>,
+	P: Pair + Sync,
+	P::Public: Codec + std::fmt::Debug,
+	P::Signature: Codec,
+	CIDP: sp_inherents::CreateInherentDataProviders<Block, ()> + Send,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
+{
+	type Error = sp_consensus::Error;
+
+	async fn check_block(
+		&self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.check_block(block).await.map_err(Into::into)
+	}
+
+	async fn import_block(
+		&self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		validate_block_import::<_, _, P, _>(
+			&mut block,
+			self.client.as_ref(),
+			&self.create_inherent_data_providers,
+			self.check_for_equivocation,
+			&self.compatibility_mode,
+		)
+		.await?;
+		self.inner.import_block(block).await.map_err(Into::into)
+	}
+}
+
+impl<BI, Client, CIDP, N, P> ParachainBlockImportMarker
+	for ValidatingBlockImport<BI, Client, CIDP, N, P>
+{
+}
+
+async fn validate_block_import<Block, Client, P, CIDP>(
+	params: &mut sc_consensus::BlockImportParams<Block>,
+	client: &Client,
+	create_inherent_data_providers: &CIDP,
+	check_for_equivocation: bool,
+	compatibility_mode: &CompatibilityMode<NumberFor<Block>>,
+) -> Result<(), sp_consensus::Error>
+where
+	Block: BlockT,
+	Client: ProvideRuntimeApi<Block> + sc_client_api::backend::AuxStore + Send + Sync,
+	Client::Api: Core<Block> + BlockBuilder<Block> + AuraApi<Block, <P as Pair>::Public>,
+	P: Pair + Sync,
+	P::Public: Codec + std::fmt::Debug,
+	P::Signature: Codec,
+	CIDP: sp_inherents::CreateInherentDataProviders<Block, ()> + Send,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
+{
+	let slot = find_pre_digest::<Block, P::Signature>(&params.header)
+		.map_err(|e| sp_consensus::Error::Other(Box::new(e)))?;
+	let parent_hash = *params.header.parent_hash();
+	let create_inherent_data_providers = create_inherent_data_providers
+		.create_inherent_data_providers(parent_hash, ())
+		.await
+		.map_err(sp_consensus::Error::Other)?;
+
+	// Check inherents.
+	// if the body is passed through, we need to use the runtime
+	// to check that the internally-set timestamp in the inherents
+	// actually matches the slot set in the seal.
+	if let Some(inner_body) = params.body.take() {
+		let new_block = Block::new(params.header.clone(), inner_body);
+		if client
+			.runtime_api()
+			.has_api_with::<dyn BlockBuilder<Block>, _>(parent_hash, |v| v >= 2)
+			.map_err(|e| sp_consensus::Error::Other(Box::new(e)))?
+		{
+			let mut inherent_data = create_inherent_data_providers
+				.create_inherent_data()
+				.await
+				.map_err(|e| sp_consensus::Error::Other(Box::new(e)))?;
+			inherent_data.aura_replace_inherent_data(slot);
+			let inherent_res = client
+				.runtime_api()
+				.check_inherents(parent_hash, new_block.clone(), inherent_data)
+				.map_err(|e| sp_consensus::Error::Other(Box::new(e)))?;
+
+			if !inherent_res.ok() {
+				for (i, e) in inherent_res.into_errors() {
+					match create_inherent_data_providers.try_handle_error(&i, &e).await {
+						Some(res) => res.map_err(|e| sp_consensus::Error::InvalidInherents(e))?,
+						None => return Err(sp_consensus::Error::InvalidInherentsUnhandled(i)),
+					}
+				}
+			}
+		}
+		let (_, inner_body) = new_block.deconstruct();
+		params.body = Some(inner_body);
+	}
+
+	// Check for equivocation.
+	let authorities = sc_consensus_aura::authorities::<<P as Pair>::Public, _, _>(
+		client,
+		parent_hash,
+		*params.header.number(),
+		compatibility_mode,
+	)
+	.map_err(|e| sp_consensus::Error::Other(Box::new(e)))?;
+	let slot_now = create_inherent_data_providers.slot();
+	let expected_author = sc_consensus_aura::standalone::slot_author::<P>(slot, &authorities);
+	if let (true, Some(expected)) = (check_for_equivocation, expected_author) {
+		if let Some(equivocation_proof) = sc_consensus_slots::check_equivocation(
+			client,
+			// we add one to allow for some small drift.
+			// FIXME #1019 in the future, alter this queue to allow deferring of
+			// headers
+			slot_now + 1,
+			slot,
+			&params.header,
+			expected,
+		)
+		.map_err(|e| sp_consensus::Error::Other(Box::new(e)))?
+		{
+			tracing::info!(
+				target: LOG_TARGET,
+				"Slot author is equivocating at slot {} with headers {:?} and {:?}",
+				slot,
+				equivocation_proof.first_header.hash(),
+				equivocation_proof.second_header.hash(),
+			);
+		}
+	}
+
+	Ok(())
+}
+
 #[cfg(test)]
 mod tests {
 	use crate::collators::can_build_upon;