fmt

Author: rphmeier

client/collator/src/service.rs

@@ -69,11 +69,7 @@ pub trait ServiceInterface<Block: BlockT> {
 	) -> oneshot::Sender<CollationSecondedSignal>;
 
 	/// Directly announce a block on the network.
-	fn announce_block(
-		&self,
-		block_hash: Block::Hash,
-		data: Option<Vec<u8>>,
-	);
+	fn announce_block(&self, block_hash: Block::Hash, data: Option<Vec<u8>>);
 }
 
 /// The [`CollatorService`] provides common utilities for parachain consensus and authoring.
@@ -113,7 +109,8 @@ where
 		announce_block: Arc<dyn Fn(Block::Hash, Option<Vec<u8>>) + Send + Sync>,
 		runtime_api: Arc<RA>,
 	) -> Self {
-		let wait_to_announce = Arc::new(Mutex::new(WaitToAnnounce::new(spawner, announce_block.clone())));
+		let wait_to_announce =
+			Arc::new(Mutex::new(WaitToAnnounce::new(spawner, announce_block.clone())));
 
 		Self { block_status, wait_to_announce, announce_block, runtime_api }
 	}
@@ -328,11 +325,7 @@ where
 		CollatorService::announce_with_barrier(self, block_hash)
 	}
 
-	fn announce_block(
-		&self,
-		block_hash: Block::Hash,
-		data: Option<Vec<u8>>,
-	) {
+	fn announce_block(&self, block_hash: Block::Hash, data: Option<Vec<u8>>) {
 		(self.announce_block)(block_hash, data)
 	}
 }

client/consensus/aura/src/collator.rs

@@ -26,7 +26,9 @@
 
 use codec::{Decode, Encode};
 use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface;
-use cumulus_client_consensus_common::{self as consensus_common, ParachainBlockImportMarker, ParachainCandidate};
+use cumulus_client_consensus_common::{
+	self as consensus_common, ParachainBlockImportMarker, ParachainCandidate,
+};
 use cumulus_client_consensus_proposer::ProposerInterface;
 use cumulus_primitives_core::{
 	relay_chain::Hash as PHash, DigestItem, ParachainBlockData, PersistedValidationData,
@@ -253,16 +255,13 @@ impl<Pub> SlotClaim<Pub> {
 	///
 	/// This does not check whether the author actually owns the slot or the timestamp
 	/// falls within the slot.
-	pub fn unchecked<P>(author_pub: Pub, slot: Slot, timestamp: Timestamp) -> Self where
+	pub fn unchecked<P>(author_pub: Pub, slot: Slot, timestamp: Timestamp) -> Self
+	where
 		P: Pair<Public = Pub>,
 		P::Public: Encode + Decode,
-		P::Signature: Encode + Decode
+		P::Signature: Encode + Decode,
 	{
-		SlotClaim {
-			author_pub,
-			timestamp,
-			pre_digest: aura_internal::pre_digest::<P>(slot),
-		}
+		SlotClaim { author_pub, timestamp, pre_digest: aura_internal::pre_digest::<P>(slot) }
 	}
 
 	/// Get the author's public key.

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

@@ -181,30 +181,34 @@ pub async fn run<Block, P, BI, CIDP, Client, RClient, SO, Proposer, CS>(
 		};
 
 		let (parachain_inherent_data, other_inherent_data) = try_request!(
-			collator.create_inherent_data(
-				*request.relay_parent(),
-				&validation_data,
-				parent_hash,
-				claim.timestamp(),
-			).await
+			collator
+				.create_inherent_data(
+					*request.relay_parent(),
+					&validation_data,
+					parent_hash,
+					claim.timestamp(),
+				)
+				.await
 		);
 
 		let (collation, _, post_hash) = try_request!(
-			collator.collate(
-				&parent_header,
-				&claim,
-				None,
-				(parachain_inherent_data, other_inherent_data),
-				// TODO [https://github.com/paritytech/cumulus/issues/2439]
-				// We should call out to a pluggable interface that provides
-				// the proposal duration.
-				Duration::from_millis(500),
-				// 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.
-				(validation_data.max_pov_size / 2) as usize,
-			).await
+			collator
+				.collate(
+					&parent_header,
+					&claim,
+					None,
+					(parachain_inherent_data, other_inherent_data),
+					// TODO [https://github.com/paritytech/cumulus/issues/2439]
+					// We should call out to a pluggable interface that provides
+					// the proposal duration.
+					Duration::from_millis(500),
+					// 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.
+					(validation_data.max_pov_size / 2) as usize,
+				)
+				.await
 		);
 
 		let result_sender = Some(collator.collator_service().announce_with_barrier(post_hash));

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

@@ -34,8 +34,7 @@
 use codec::{Decode, Encode};
 use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface;
 use cumulus_client_consensus_common::{
-	self as consensus_common,
-	ParachainBlockImportMarker, ParachainCandidate, ParentSearchParams,
+	self as consensus_common, ParachainBlockImportMarker, ParachainCandidate, ParentSearchParams,
 };
 use cumulus_client_consensus_proposer::ProposerInterface;
 use cumulus_primitives_core::{
@@ -46,7 +45,9 @@ use cumulus_relay_chain_interface::RelayChainInterface;
 
 use polkadot_node_primitives::{CollationResult, MaybeCompressedPoV};
 use polkadot_overseer::Handle as OverseerHandle;
-use polkadot_primitives::{Block as PBlock, CollatorPair, Header as PHeader, Id as ParaId, OccupiedCoreAssumption};
+use polkadot_primitives::{
+	Block as PBlock, CollatorPair, Header as PHeader, Id as ParaId, OccupiedCoreAssumption,
+};
 
 use futures::prelude::*;
 use sc_client_api::{backend::AuxStore, BlockBackend, BlockOf};
@@ -163,17 +164,21 @@ pub async fn run<Block, P, BI, CIDP, Client, Backend, RClient, SO, Proposer, CS>
 		// TODO [now]: get asynchronous backing parameters from the relay-chain
 		// runtime. why? for the parent search parameters.
 
-		let max_pov_size  = match params.relay_client.persisted_validation_data(
-			relay_parent,
-			params.para_id,
-			OccupiedCoreAssumption::Included,
-		).await {
+		let max_pov_size = match params
+			.relay_client
+			.persisted_validation_data(
+				relay_parent,
+				params.para_id,
+				OccupiedCoreAssumption::Included,
+			)
+			.await
+		{
 			Ok(None) => continue,
 			Ok(Some(pvd)) => pvd.max_pov_size,
 			Err(err) => {
 				tracing::error!(target: crate::LOG_TARGET, ?err, "Failed to gather information from relay-client");
-				continue;
-			}
+				continue
+			},
 		};
 
 		let (slot_now, timestamp) = match consensus_common::relay_slot_and_timestamp(
@@ -220,14 +225,16 @@ pub async fn run<Block, P, BI, CIDP, Client, Backend, RClient, SO, Proposer, CS>
 
 		let para_client = &*params.para_client;
 		let keystore = &params.keystore;
-		let can_build_upon = |block_hash| can_build_upon::<_, _, P>(
-			slot_now,
-			timestamp,
-			block_hash,
-			included_block,
-			para_client,
-			&keystore,
-		);
+		let can_build_upon = |block_hash| {
+			can_build_upon::<_, _, P>(
+				slot_now,
+				timestamp,
+				block_hash,
+				included_block,
+				para_client,
+				&keystore,
+			)
+		};
 
 		// Sort by depth, ascending, to choose the longest chain.
 		//
@@ -258,31 +265,37 @@ pub async fn run<Block, P, BI, CIDP, Client, Backend, RClient, SO, Proposer, CS>
 
 			// Build and announce collations recursively until
 			// `can_build_upon` fails or building a collation fails.
-			let (parachain_inherent_data, other_inherent_data) = match collator.create_inherent_data(
-				relay_parent,
-				&validation_data,
-				parent_hash,
-				slot_claim.timestamp(),
-			).await {
+			let (parachain_inherent_data, other_inherent_data) = match collator
+				.create_inherent_data(
+					relay_parent,
+					&validation_data,
+					parent_hash,
+					slot_claim.timestamp(),
+				)
+				.await
+			{
 				Err(err) => {
 					tracing::error!(target: crate::LOG_TARGET, ?err);
-					break;
+					break
 				},
 				Ok(x) => x,
 			};
 
-			match collator.collate(
-				&parent_header,
-				&slot_claim,
-				None,
-				(parachain_inherent_data, other_inherent_data),
-				params.authoring_duration,
-				// 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.
-				(validation_data.max_pov_size / 2) as usize,
-			).await {
+			match collator
+				.collate(
+					&parent_header,
+					&slot_claim,
+					None,
+					(parachain_inherent_data, other_inherent_data),
+					params.authoring_duration,
+					// 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.
+					(validation_data.max_pov_size / 2) as usize,
+				)
+				.await
+			{
 				Ok((collation, block_data, new_block_hash)) => {
 					parent_hash = new_block_hash;
 					parent_header = block_data.into_header();
@@ -293,11 +306,11 @@ pub async fn run<Block, P, BI, CIDP, Client, Backend, RClient, SO, Proposer, CS>
 
 					// TODO [https://github.com/paritytech/polkadot/issues/5056]:
 					// announce collation to relay-chain validators.
-				}
+				},
 				Err(err) => {
 					tracing::error!(target: crate::LOG_TARGET, ?err);
-					break;
-				}
+					break
+				},
 			}
 		}
 	}

client/consensus/common/src/lib.rs

@@ -15,16 +15,18 @@
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
 use codec::Decode;
-use polkadot_primitives::{Block as PBlock, Hash as PHash, Header as PHeader, PersistedValidationData};
+use polkadot_primitives::{
+	Block as PBlock, Hash as PHash, Header as PHeader, PersistedValidationData,
+};
 
 use cumulus_primitives_core::{relay_chain::OccupiedCoreAssumption, ParaId};
 use cumulus_relay_chain_interface::{RelayChainError, RelayChainInterface};
 
 use sc_client_api::Backend;
 use sc_consensus::{shared_data::SharedData, BlockImport, ImportResult};
 use sp_consensus_slots::{Slot, SlotDuration};
-use sp_timestamp::Timestamp;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use sp_timestamp::Timestamp;
 
 use std::sync::Arc;
 
@@ -358,10 +360,12 @@ pub fn relay_slot_and_timestamp(
 	relay_parent_header: &PHeader,
 	relay_chain_slot_duration: SlotDuration,
 ) -> Option<(Slot, Timestamp)> {
-	sc_consensus_babe::find_pre_digest::<PBlock>(relay_parent_header).map(|babe_pre_digest| {
-		let slot = babe_pre_digest.slot();
-		let t = Timestamp::new(relay_chain_slot_duration.as_millis() * *slot);
-
-		(slot, t)
-	}).ok()
+	sc_consensus_babe::find_pre_digest::<PBlock>(relay_parent_header)
+		.map(|babe_pre_digest| {
+			let slot = babe_pre_digest.slot();
+			let t = Timestamp::new(relay_chain_slot_duration.as_millis() * *slot);
+
+			(slot, t)
+		})
+		.ok()
 }

client/network/src/lib.rs

@@ -89,14 +89,13 @@ impl BlockAnnounceData {
 	///
 	/// This will not check the signature, for this you should use [`BlockAnnounceData::check_signature`].
 	fn validate(&self, encoded_header: Vec<u8>) -> Result<(), Validation> {
-		let candidate_hash = if let CompactStatement::Seconded(h) =
-			self.statement.unchecked_payload()
-		{
-			h
-		} else {
-			tracing::debug!(target: LOG_TARGET, "`CompactStatement` isn't the candidate variant!",);
-			return Err(Validation::Failure { disconnect: true })
-		};
+		let candidate_hash =
+			if let CompactStatement::Seconded(h) = self.statement.unchecked_payload() {
+				h
+			} else {
+				tracing::debug!(target: LOG_TARGET, "`CompactStatement` isn't the candidate variant!",);
+				return Err(Validation::Failure { disconnect: true })
+			};
 
 		if *candidate_hash != self.receipt.hash() {
 			tracing::debug!(
@@ -188,7 +187,8 @@ impl TryFrom<&'_ CollationSecondedSignal> for BlockAnnounceData {
 
 /// A type alias for the [`RequireSecondedInBlockAnnounce`] validator.
 #[deprecated = "This has been renamed to RequireSecondedInBlockAnnounce"]
-pub type BlockAnnounceValidator<Block, RCInterface> = RequireSecondedInBlockAnnounce<Block, RCInterface>;
+pub type BlockAnnounceValidator<Block, RCInterface> =
+	RequireSecondedInBlockAnnounce<Block, RCInterface>;
 
 /// Parachain specific block announce validator.
 ///
@@ -342,9 +342,9 @@ where
 			let relay_chain_is_syncing = relay_chain_interface
 				.is_major_syncing()
 				.await
-				.map_err(|e| {
-					tracing::error!(target: LOG_TARGET, "Unable to determine sync status. {}", e)
-				})
+				.map_err(
+					|e| tracing::error!(target: LOG_TARGET, "Unable to determine sync status. {}", e),
+				)
 				.unwrap_or(false);
 
 			if relay_chain_is_syncing {