Match substrate's fmt (#1148)

* Alter gitlab.

* Use substrate's rustfmt.toml

* cargo +nightly fmt --all

* Fix spellcheck.

* cargo +nightly fmt --all

* format.

* Fix spellcheck and fmt

* fmt?

* Fix spellcheck

Co-authored-by: Tomasz Drwięga <tomasz@parity.io>

bridges/modules/messages/src/benchmarking.rs

@@ -16,15 +16,15 @@
 
 //! Messages pallet benchmarking.
 
-use crate::weights_ext::EXPECTED_DEFAULT_MESSAGE_LENGTH;
 use crate::{
-	inbound_lane::InboundLaneStorage, inbound_lane_storage, outbound_lane, outbound_lane::ReceivalConfirmationResult,
-	Call,
+	inbound_lane::InboundLaneStorage, inbound_lane_storage, outbound_lane,
+	outbound_lane::ReceivalConfirmationResult, weights_ext::EXPECTED_DEFAULT_MESSAGE_LENGTH, Call,
 };
 
 use bp_messages::{
-	source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, DeliveredMessages, InboundLaneData, LaneId,
-	MessageData, MessageNonce, OutboundLaneData, UnrewardedRelayer, UnrewardedRelayersState,
+	source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, DeliveredMessages,
+	InboundLaneData, LaneId, MessageData, MessageNonce, OutboundLaneData, UnrewardedRelayer,
+	UnrewardedRelayersState,
 };
 use bp_runtime::messages::DispatchFeePayment;
 use frame_benchmarking::{account, benchmarks_instance_pallet};
@@ -50,11 +50,11 @@ pub enum ProofSize {
 	/// The proof is expected to be minimal. If value size may be changed, then it is expected to
 	/// have given size.
 	Minimal(u32),
-	/// The proof is expected to have at least given size and grow by increasing number of trie nodes
-	/// included in the proof.
+	/// The proof is expected to have at least given size and grow by increasing number of trie
+	/// nodes included in the proof.
 	HasExtraNodes(u32),
-	/// The proof is expected to have at least given size and grow by increasing value that is stored
-	/// in the trie.
+	/// The proof is expected to have at least given size and grow by increasing value that is
+	/// stored in the trie.
 	HasLargeLeaf(u32),
 }
 
@@ -900,18 +900,12 @@ benchmarks_instance_pallet! {
 
 fn send_regular_message<T: Config<I>, I: 'static>() {
 	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
-	outbound_lane.send_message(MessageData {
-		payload: vec![],
-		fee: MESSAGE_FEE.into(),
-	});
+	outbound_lane.send_message(MessageData { payload: vec![], fee: MESSAGE_FEE.into() });
 }
 
 fn send_regular_message_with_payload<T: Config<I>, I: 'static>(payload: Vec<u8>) {
 	let mut outbound_lane = outbound_lane::<T, I>(T::bench_lane_id());
-	outbound_lane.send_message(MessageData {
-		payload,
-		fee: MESSAGE_FEE.into(),
-	});
+	outbound_lane.send_message(MessageData { payload, fee: MESSAGE_FEE.into() });
 }
 
 fn confirm_message_delivery<T: Config<I>, I: 'static>(nonce: MessageNonce) {
@@ -943,7 +937,10 @@ fn receive_messages<T: Config<I>, I: 'static>(nonce: MessageNonce) {
 	});
 }
 
-fn ensure_relayer_rewarded<T: Config<I>, I: 'static>(relayer_id: &T::AccountId, old_balance: &T::OutboundMessageFee) {
+fn ensure_relayer_rewarded<T: Config<I>, I: 'static>(
+	relayer_id: &T::AccountId,
+	old_balance: &T::OutboundMessageFee,
+) {
 	let new_balance = T::account_balance(relayer_id);
 	assert!(
 		new_balance > *old_balance,

bridges/modules/messages/src/inbound_lane.rs

@@ -18,7 +18,8 @@
 
 use bp_messages::{
 	target_chain::{DispatchMessage, DispatchMessageData, MessageDispatch},
-	DeliveredMessages, InboundLaneData, LaneId, MessageKey, MessageNonce, OutboundLaneData, UnrewardedRelayer,
+	DeliveredMessages, InboundLaneData, LaneId, MessageKey, MessageNonce, OutboundLaneData,
+	UnrewardedRelayer,
 };
 use bp_runtime::messages::MessageDispatchResult;
 use frame_support::RuntimeDebug;
@@ -71,16 +72,19 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 	}
 
 	/// Receive state of the corresponding outbound lane.
-	pub fn receive_state_update(&mut self, outbound_lane_data: OutboundLaneData) -> Option<MessageNonce> {
+	pub fn receive_state_update(
+		&mut self,
+		outbound_lane_data: OutboundLaneData,
+	) -> Option<MessageNonce> {
 		let mut data = self.storage.data();
 		let last_delivered_nonce = data.last_delivered_nonce();
 
 		if outbound_lane_data.latest_received_nonce > last_delivered_nonce {
 			// this is something that should never happen if proofs are correct
-			return None;
+			return None
 		}
 		if outbound_lane_data.latest_received_nonce <= data.last_confirmed_nonce {
-			return None;
+			return None
 		}
 
 		let new_confirmed_nonce = outbound_lane_data.latest_received_nonce;
@@ -95,7 +99,8 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 			data.relayers.pop_front();
 		}
 		// Secondly, update the next record with lower nonce equal to new confirmed nonce if needed.
-		// Note: There will be max. 1 record to update as we don't allow messages from relayers to overlap.
+		// Note: There will be max. 1 record to update as we don't allow messages from relayers to
+		// overlap.
 		match data.relayers.front_mut() {
 			Some(entry) if entry.messages.begin < new_confirmed_nonce => {
 				entry.messages.dispatch_results = entry
@@ -103,8 +108,8 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 					.dispatch_results
 					.split_off((new_confirmed_nonce + 1 - entry.messages.begin) as _);
 				entry.messages.begin = new_confirmed_nonce + 1;
-			}
-			_ => {}
+			},
+			_ => {},
 		}
 
 		self.storage.set_data(data);
@@ -122,28 +127,25 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		let mut data = self.storage.data();
 		let is_correct_message = nonce == data.last_delivered_nonce() + 1;
 		if !is_correct_message {
-			return ReceivalResult::InvalidNonce;
+			return ReceivalResult::InvalidNonce
 		}
 
 		// if there are more unrewarded relayer entries than we may accept, reject this message
 		if data.relayers.len() as MessageNonce >= self.storage.max_unrewarded_relayer_entries() {
-			return ReceivalResult::TooManyUnrewardedRelayers;
+			return ReceivalResult::TooManyUnrewardedRelayers
 		}
 
 		// if there are more unconfirmed messages than we may accept, reject this message
 		let unconfirmed_messages_count = nonce.saturating_sub(data.last_confirmed_nonce);
 		if unconfirmed_messages_count > self.storage.max_unconfirmed_messages() {
-			return ReceivalResult::TooManyUnconfirmedMessages;
+			return ReceivalResult::TooManyUnconfirmedMessages
 		}
 
 		// then, dispatch message
 		let dispatch_result = P::dispatch(
 			relayer_at_this_chain,
 			DispatchMessage {
-				key: MessageKey {
-					lane_id: self.storage.id(),
-					nonce,
-				},
+				key: MessageKey { lane_id: self.storage.id(), nonce },
 				data: message_data,
 			},
 		);
@@ -153,7 +155,7 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 			Some(entry) if entry.relayer == *relayer_at_bridged_chain => {
 				entry.messages.note_dispatched_message(dispatch_result.dispatch_result);
 				false
-			}
+			},
 			_ => true,
 		};
 		if push_new {
@@ -174,8 +176,9 @@ mod tests {
 	use crate::{
 		inbound_lane,
 		mock::{
-			dispatch_result, message_data, run_test, unrewarded_relayer, TestMessageDispatch, TestRuntime,
-			REGULAR_PAYLOAD, TEST_LANE_ID, TEST_RELAYER_A, TEST_RELAYER_B, TEST_RELAYER_C,
+			dispatch_result, message_data, run_test, unrewarded_relayer, TestMessageDispatch,
+			TestRuntime, REGULAR_PAYLOAD, TEST_LANE_ID, TEST_RELAYER_A, TEST_RELAYER_B,
+			TEST_RELAYER_C,
 		},
 		RuntimeInboundLaneStorage,
 	};
@@ -284,16 +287,10 @@ mod tests {
 			let mut seed_storage_data = lane.storage.data();
 			// Prepare data
 			seed_storage_data.last_confirmed_nonce = 0;
-			seed_storage_data
-				.relayers
-				.push_back(unrewarded_relayer(1, 1, TEST_RELAYER_A));
+			seed_storage_data.relayers.push_back(unrewarded_relayer(1, 1, TEST_RELAYER_A));
 			// Simulate messages batch (2, 3, 4) from relayer #2
-			seed_storage_data
-				.relayers
-				.push_back(unrewarded_relayer(2, 4, TEST_RELAYER_B));
-			seed_storage_data
-				.relayers
-				.push_back(unrewarded_relayer(5, 5, TEST_RELAYER_C));
+			seed_storage_data.relayers.push_back(unrewarded_relayer(2, 4, TEST_RELAYER_B));
+			seed_storage_data.relayers.push_back(unrewarded_relayer(5, 5, TEST_RELAYER_C));
 			lane.storage.set_data(seed_storage_data);
 			// Check
 			assert_eq!(
@@ -335,7 +332,8 @@ mod tests {
 	fn fails_to_receive_messages_above_unrewarded_relayer_entries_limit_per_lane() {
 		run_test(|| {
 			let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
-			let max_nonce = <TestRuntime as crate::Config>::MaxUnrewardedRelayerEntriesAtInboundLane::get();
+			let max_nonce =
+				<TestRuntime as crate::Config>::MaxUnrewardedRelayerEntriesAtInboundLane::get();
 			for current_nonce in 1..max_nonce + 1 {
 				assert_eq!(
 					lane.receive_message::<TestMessageDispatch, _>(
@@ -374,7 +372,8 @@ mod tests {
 	fn fails_to_receive_messages_above_unconfirmed_messages_limit_per_lane() {
 		run_test(|| {
 			let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
-			let max_nonce = <TestRuntime as crate::Config>::MaxUnconfirmedMessagesAtInboundLane::get();
+			let max_nonce =
+				<TestRuntime as crate::Config>::MaxUnconfirmedMessagesAtInboundLane::get();
 			for current_nonce in 1..=max_nonce {
 				assert_eq!(
 					lane.receive_message::<TestMessageDispatch, _>(

bridges/modules/messages/src/instant_payments.rs

@@ -46,7 +46,8 @@ pub struct InstantCurrencyPayments<T, Currency, GetConfirmationFee, RootAccount>
 	_phantom: sp_std::marker::PhantomData<(T, Currency, GetConfirmationFee, RootAccount)>,
 }
 
-impl<T, Currency, GetConfirmationFee, RootAccount> MessageDeliveryAndDispatchPayment<T::AccountId, Currency::Balance>
+impl<T, Currency, GetConfirmationFee, RootAccount>
+	MessageDeliveryAndDispatchPayment<T::AccountId, Currency::Balance>
 	for InstantCurrencyPayments<T, Currency, GetConfirmationFee, RootAccount>
 where
 	T: frame_system::Config,
@@ -118,26 +119,31 @@ fn pay_relayers_rewards<Currency, AccountId>(
 			// If delivery confirmation is submitted by other relayer, let's deduct confirmation fee
 			// from relayer reward.
 			//
-			// If confirmation fee has been increased (or if it was the only component of message fee),
-			// then messages relayer may receive zero reward.
+			// If confirmation fee has been increased (or if it was the only component of message
+			// fee), then messages relayer may receive zero reward.
 			let mut confirmation_reward = confirmation_fee.saturating_mul(reward.messages.into());
 			if confirmation_reward > relayer_reward {
 				confirmation_reward = relayer_reward;
 			}
 			relayer_reward = relayer_reward.saturating_sub(confirmation_reward);
-			confirmation_relayer_reward = confirmation_relayer_reward.saturating_add(confirmation_reward);
+			confirmation_relayer_reward =
+				confirmation_relayer_reward.saturating_add(confirmation_reward);
 		} else {
 			// If delivery confirmation is submitted by this relayer, let's add confirmation fee
 			// from other relayers to this relayer reward.
 			confirmation_relayer_reward = confirmation_relayer_reward.saturating_add(reward.reward);
-			continue;
+			continue
 		}
 
 		pay_relayer_reward::<Currency, _>(relayer_fund_account, &relayer, relayer_reward);
 	}
 
 	// finally - pay reward to confirmation relayer
-	pay_relayer_reward::<Currency, _>(relayer_fund_account, confirmation_relayer, confirmation_relayer_reward);
+	pay_relayer_reward::<Currency, _>(
+		relayer_fund_account,
+		confirmation_relayer,
+		confirmation_relayer_reward,
+	);
 }
 
 /// Transfer funds from relayers fund account to given relayer.
@@ -150,7 +156,7 @@ fn pay_relayer_reward<Currency, AccountId>(
 	Currency: CurrencyT<AccountId>,
 {
 	if reward.is_zero() {
-		return;
+		return
 	}
 
 	let pay_result = Currency::transfer(
@@ -193,20 +199,8 @@ mod tests {
 
 	fn relayers_rewards() -> RelayersRewards<TestAccountId, TestBalance> {
 		vec![
-			(
-				RELAYER_1,
-				RelayerRewards {
-					reward: 100,
-					messages: 2,
-				},
-			),
-			(
-				RELAYER_2,
-				RelayerRewards {
-					reward: 100,
-					messages: 3,
-				},
-			),
+			(RELAYER_1, RelayerRewards { reward: 100, messages: 2 }),
+			(RELAYER_2, RelayerRewards { reward: 100, messages: 3 }),
 		]
 		.into_iter()
 		.collect()
@@ -215,7 +209,12 @@ mod tests {
 	#[test]
 	fn confirmation_relayer_is_rewarded_if_it_has_also_delivered_messages() {
 		run_test(|| {
-			pay_relayers_rewards::<Balances, _>(&RELAYER_2, relayers_rewards(), &RELAYERS_FUND_ACCOUNT, 10);
+			pay_relayers_rewards::<Balances, _>(
+				&RELAYER_2,
+				relayers_rewards(),
+				&RELAYERS_FUND_ACCOUNT,
+				10,
+			);
 
 			assert_eq!(Balances::free_balance(&RELAYER_1), 80);
 			assert_eq!(Balances::free_balance(&RELAYER_2), 120);
@@ -225,7 +224,12 @@ mod tests {
 	#[test]
 	fn confirmation_relayer_is_rewarded_if_it_has_not_delivered_any_delivered_messages() {
 		run_test(|| {
-			pay_relayers_rewards::<Balances, _>(&RELAYER_3, relayers_rewards(), &RELAYERS_FUND_ACCOUNT, 10);
+			pay_relayers_rewards::<Balances, _>(
+				&RELAYER_3,
+				relayers_rewards(),
+				&RELAYERS_FUND_ACCOUNT,
+				10,
+			);
 
 			assert_eq!(Balances::free_balance(&RELAYER_1), 80);
 			assert_eq!(Balances::free_balance(&RELAYER_2), 70);
@@ -236,7 +240,12 @@ mod tests {
 	#[test]
 	fn only_confirmation_relayer_is_rewarded_if_confirmation_fee_has_significantly_increased() {
 		run_test(|| {
-			pay_relayers_rewards::<Balances, _>(&RELAYER_3, relayers_rewards(), &RELAYERS_FUND_ACCOUNT, 1000);
+			pay_relayers_rewards::<Balances, _>(
+				&RELAYER_3,
+				relayers_rewards(),
+				&RELAYERS_FUND_ACCOUNT,
+				1000,
+			);
 
 			assert_eq!(Balances::free_balance(&RELAYER_1), 0);
 			assert_eq!(Balances::free_balance(&RELAYER_2), 0);

bridges/modules/messages/src/mock.rs

@@ -22,12 +22,14 @@ use crate::Config;
 use bitvec::prelude::*;
 use bp_messages::{
 	source_chain::{
-		LaneMessageVerifier, MessageDeliveryAndDispatchPayment, OnDeliveryConfirmed, OnMessageAccepted,
-		RelayersRewards, Sender, TargetHeaderChain,
+		LaneMessageVerifier, MessageDeliveryAndDispatchPayment, OnDeliveryConfirmed,
+		OnMessageAccepted, RelayersRewards, Sender, TargetHeaderChain,
 	},
-	target_chain::{DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages, SourceHeaderChain},
-	DeliveredMessages, InboundLaneData, LaneId, Message, MessageData, MessageKey, MessageNonce, OutboundLaneData,
-	Parameter as MessagesParameter, UnrewardedRelayer,
+	target_chain::{
+		DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages, SourceHeaderChain,
+	},
+	DeliveredMessages, InboundLaneData, LaneId, Message, MessageData, MessageKey, MessageNonce,
+	OutboundLaneData, Parameter as MessagesParameter, UnrewardedRelayer,
 };
 use bp_runtime::{messages::MessageDispatchResult, Size};
 use codec::{Decode, Encode};
@@ -53,8 +55,8 @@ pub struct TestPayload {
 	pub declared_weight: Weight,
 	/// Message dispatch result.
 	///
-	/// Note: in correct code `dispatch_result.unspent_weight` will always be <= `declared_weight`, but for test
-	/// purposes we'll be making it larger than `declared_weight` sometimes.
+	/// Note: in correct code `dispatch_result.unspent_weight` will always be <= `declared_weight`,
+	/// but for test purposes we'll be making it larger than `declared_weight` sometimes.
 	pub dispatch_result: MessageDispatchResult,
 	/// Extra bytes that affect payload size.
 	pub extra: Vec<u8>,
@@ -153,7 +155,8 @@ pub enum TestMessagesParameter {
 impl MessagesParameter for TestMessagesParameter {
 	fn save(&self) {
 		match *self {
-			TestMessagesParameter::TokenConversionRate(conversion_rate) => TokenConversionRate::set(&conversion_rate),
+			TestMessagesParameter::TokenConversionRate(conversion_rate) =>
+				TokenConversionRate::set(&conversion_rate),
 		}
 	}
 }
@@ -235,14 +238,12 @@ impl From<Result<Vec<Message<TestMessageFee>>, ()>> for TestMessagesProof {
 	fn from(result: Result<Vec<Message<TestMessageFee>>, ()>) -> Self {
 		Self {
 			result: result.map(|messages| {
-				let mut messages_by_lane: BTreeMap<LaneId, ProvedLaneMessages<Message<TestMessageFee>>> =
-					BTreeMap::new();
+				let mut messages_by_lane: BTreeMap<
+					LaneId,
+					ProvedLaneMessages<Message<TestMessageFee>>,
+				> = BTreeMap::new();
 				for message in messages {
-					messages_by_lane
-						.entry(message.key.lane_id)
-						.or_default()
-						.messages
-						.push(message);
+					messages_by_lane.entry(message.key.lane_id).or_default().messages.push(message);
 				}
 				messages_by_lane.into_iter().collect()
 			}),
@@ -318,7 +319,8 @@ impl TestMessageDeliveryAndDispatchPayment {
 
 	/// Returns true if given fee has been paid by given submitter.
 	pub fn is_fee_paid(submitter: AccountId, fee: TestMessageFee) -> bool {
-		frame_support::storage::unhashed::get(b":message-fee:") == Some((Sender::Signed(submitter), fee))
+		frame_support::storage::unhashed::get(b":message-fee:") ==
+			Some((Sender::Signed(submitter), fee))
 	}
 
 	/// Returns true if given relayer has been rewarded with given balance. The reward-paid flag is
@@ -329,7 +331,9 @@ impl TestMessageDeliveryAndDispatchPayment {
 	}
 }
 
-impl MessageDeliveryAndDispatchPayment<AccountId, TestMessageFee> for TestMessageDeliveryAndDispatchPayment {
+impl MessageDeliveryAndDispatchPayment<AccountId, TestMessageFee>
+	for TestMessageDeliveryAndDispatchPayment
+{
 	type Error = &'static str;
 
 	fn pay_delivery_and_dispatch_fee(
@@ -338,7 +342,7 @@ impl MessageDeliveryAndDispatchPayment<AccountId, TestMessageFee> for TestMessag
 		_relayer_fund_account: &AccountId,
 	) -> Result<(), Self::Error> {
 		if frame_support::storage::unhashed::get(b":reject-message-fee:") == Some(true) {
-			return Err(TEST_ERROR);
+			return Err(TEST_ERROR)
 		}
 
 		frame_support::storage::unhashed::put(b":message-fee:", &(submitter, fee));
@@ -382,7 +386,8 @@ impl OnMessageAccepted for TestOnMessageAccepted {
 	fn on_messages_accepted(lane: &LaneId, message: &MessageNonce) -> Weight {
 		let key = (b"TestOnMessageAccepted", lane, message).encode();
 		frame_support::storage::unhashed::put(&key, &true);
-		Self::get_consumed_weight_per_message().unwrap_or_else(|| DbWeight::get().reads_writes(1, 1))
+		Self::get_consumed_weight_per_message()
+			.unwrap_or_else(|| DbWeight::get().reads_writes(1, 1))
 	}
 }
 
@@ -451,10 +456,7 @@ impl SourceHeaderChain<TestMessageFee> for TestSourceHeaderChain {
 		proof: Self::MessagesProof,
 		_messages_count: u32,
 	) -> Result<ProvedMessages<Message<TestMessageFee>>, Self::Error> {
-		proof
-			.result
-			.map(|proof| proof.into_iter().collect())
-			.map_err(|_| TEST_ERROR)
+		proof.result.map(|proof| proof.into_iter().collect()).map_err(|_| TEST_ERROR)
 	}
 }
 
@@ -485,31 +487,17 @@ impl MessageDispatch<AccountId, TestMessageFee> for TestMessageDispatch {
 
 /// Return test lane message with given nonce and payload.
 pub fn message(nonce: MessageNonce, payload: TestPayload) -> Message<TestMessageFee> {
-	Message {
-		key: MessageKey {
-			lane_id: TEST_LANE_ID,
-			nonce,
-		},
-		data: message_data(payload),
-	}
+	Message { key: MessageKey { lane_id: TEST_LANE_ID, nonce }, data: message_data(payload) }
 }
 
 /// Constructs message payload using given arguments and zero unspent weight.
 pub const fn message_payload(id: u64, declared_weight: Weight) -> TestPayload {
-	TestPayload {
-		id,
-		declared_weight,
-		dispatch_result: dispatch_result(0),
-		extra: Vec::new(),
-	}
+	TestPayload { id, declared_weight, dispatch_result: dispatch_result(0), extra: Vec::new() }
 }
 
 /// Return message data with valid fee for given payload.
 pub fn message_data(payload: TestPayload) -> MessageData<TestMessageFee> {
-	MessageData {
-		payload: payload.encode(),
-		fee: 1,
-	}
+	MessageData { payload: payload.encode(), fee: 1 }
 }
 
 /// Returns message dispatch result with given unspent weight.
@@ -543,14 +531,10 @@ pub fn unrewarded_relayer(
 
 /// Run pallet test.
 pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
-	let mut t = frame_system::GenesisConfig::default()
-		.build_storage::<TestRuntime>()
+	let mut t = frame_system::GenesisConfig::default().build_storage::<TestRuntime>().unwrap();
+	pallet_balances::GenesisConfig::<TestRuntime> { balances: vec![(ENDOWED_ACCOUNT, 1_000_000)] }
+		.assimilate_storage(&mut t)
 		.unwrap();
-	pallet_balances::GenesisConfig::<TestRuntime> {
-		balances: vec![(ENDOWED_ACCOUNT, 1_000_000)],
-	}
-	.assimilate_storage(&mut t)
-	.unwrap();
 	let mut ext = sp_io::TestExternalities::new(t);
 	ext.execute_with(test)
 }

bridges/modules/messages/src/outbound_lane.rs

@@ -18,7 +18,8 @@
 
 use bitvec::prelude::*;
 use bp_messages::{
-	DeliveredMessages, DispatchResultsBitVec, LaneId, MessageData, MessageNonce, OutboundLaneData, UnrewardedRelayer,
+	DeliveredMessages, DispatchResultsBitVec, LaneId, MessageData, MessageNonce, OutboundLaneData,
+	UnrewardedRelayer,
 };
 use frame_support::RuntimeDebug;
 use sp_std::collections::vec_deque::VecDeque;
@@ -57,11 +58,11 @@ pub enum ReceivalConfirmationResult {
 	/// The unrewarded relayers vec contains an empty entry. May be a result of invalid bridged
 	/// chain storage.
 	EmptyUnrewardedRelayerEntry,
-	/// The unrewarded relayers vec contains non-consecutive entries. May be a result of invalid bridged
-	/// chain storage.
+	/// The unrewarded relayers vec contains non-consecutive entries. May be a result of invalid
+	/// bridged chain storage.
 	NonConsecutiveUnrewardedRelayerEntries,
-	/// The unrewarded relayers vec contains entry with mismatched number of dispatch results. May be
-	/// a result of invalid bridged chain storage.
+	/// The unrewarded relayers vec contains entry with mismatched number of dispatch results. May
+	/// be a result of invalid bridged chain storage.
 	InvalidNumberOfDispatchResults,
 	/// The chain has more messages that need to be confirmed than there is in the proof.
 	TryingToConfirmMoreMessagesThanExpected(MessageNonce),
@@ -106,27 +107,30 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 	) -> ReceivalConfirmationResult {
 		let mut data = self.storage.data();
 		if latest_delivered_nonce <= data.latest_received_nonce {
-			return ReceivalConfirmationResult::NoNewConfirmations;
+			return ReceivalConfirmationResult::NoNewConfirmations
 		}
 		if latest_delivered_nonce > data.latest_generated_nonce {
-			return ReceivalConfirmationResult::FailedToConfirmFutureMessages;
+			return ReceivalConfirmationResult::FailedToConfirmFutureMessages
 		}
 		if latest_delivered_nonce - data.latest_received_nonce > max_allowed_messages {
-			// that the relayer has declared correct number of messages that the proof contains (it is
-			// checked outside of the function). But it may happen (but only if this/bridged chain storage is
-			// corrupted, though) that the actual number of confirmed messages if larger than declared.
-			// This would mean that 'reward loop' will take more time than the weight formula accounts,
-			// so we can't allow that.
+			// that the relayer has declared correct number of messages that the proof contains (it
+			// is checked outside of the function). But it may happen (but only if this/bridged
+			// chain storage is corrupted, though) that the actual number of confirmed messages if
+			// larger than declared. This would mean that 'reward loop' will take more time than the
+			// weight formula accounts, so we can't allow that.
 			return ReceivalConfirmationResult::TryingToConfirmMoreMessagesThanExpected(
 				latest_delivered_nonce - data.latest_received_nonce,
-			);
+			)
 		}
 
-		let dispatch_results =
-			match extract_dispatch_results(data.latest_received_nonce, latest_delivered_nonce, relayers) {
-				Ok(dispatch_results) => dispatch_results,
-				Err(extract_error) => return extract_error,
-			};
+		let dispatch_results = match extract_dispatch_results(
+			data.latest_received_nonce,
+			latest_delivered_nonce,
+			relayers,
+		) {
+			Ok(dispatch_results) => dispatch_results,
+			Err(extract_error) => return extract_error,
+		};
 
 		let prev_latest_received_nonce = data.latest_received_nonce;
 		data.latest_received_nonce = latest_delivered_nonce;
@@ -146,7 +150,9 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 		let mut pruned_messages = 0;
 		let mut anything_changed = false;
 		let mut data = self.storage.data();
-		while pruned_messages < max_messages_to_prune && data.oldest_unpruned_nonce <= data.latest_received_nonce {
+		while pruned_messages < max_messages_to_prune &&
+			data.oldest_unpruned_nonce <= data.latest_received_nonce
+		{
 			self.storage.remove_message(&data.oldest_unpruned_nonce);
 
 			anything_changed = true;
@@ -171,9 +177,10 @@ fn extract_dispatch_results<RelayerId>(
 	latest_received_nonce: MessageNonce,
 	relayers: &VecDeque<UnrewardedRelayer<RelayerId>>,
 ) -> Result<DispatchResultsBitVec, ReceivalConfirmationResult> {
-	// the only caller of this functions checks that the prev_latest_received_nonce..=latest_received_nonce
-	// is valid, so we're ready to accept messages in this range
-	// => with_capacity call must succeed here or we'll be unable to receive confirmations at all
+	// the only caller of this functions checks that the
+	// prev_latest_received_nonce..=latest_received_nonce is valid, so we're ready to accept
+	// messages in this range => with_capacity call must succeed here or we'll be unable to receive
+	// confirmations at all
 	let mut received_dispatch_result =
 		BitVec::with_capacity((latest_received_nonce - prev_latest_received_nonce + 1) as _);
 	let mut last_entry_end: Option<MessageNonce> = None;
@@ -181,43 +188,48 @@ fn extract_dispatch_results<RelayerId>(
 		// unrewarded relayer entry must have at least 1 unconfirmed message
 		// (guaranteed by the `InboundLane::receive_message()`)
 		if entry.messages.end < entry.messages.begin {
-			return Err(ReceivalConfirmationResult::EmptyUnrewardedRelayerEntry);
+			return Err(ReceivalConfirmationResult::EmptyUnrewardedRelayerEntry)
 		}
 		// every entry must confirm range of messages that follows previous entry range
 		// (guaranteed by the `InboundLane::receive_message()`)
 		if let Some(last_entry_end) = last_entry_end {
 			let expected_entry_begin = last_entry_end.checked_add(1);
 			if expected_entry_begin != Some(entry.messages.begin) {
-				return Err(ReceivalConfirmationResult::NonConsecutiveUnrewardedRelayerEntries);
+				return Err(ReceivalConfirmationResult::NonConsecutiveUnrewardedRelayerEntries)
 			}
 		}
 		last_entry_end = Some(entry.messages.end);
 		// entry can't confirm messages larger than `inbound_lane_data.latest_received_nonce()`
 		// (guaranteed by the `InboundLane::receive_message()`)
 		if entry.messages.end > latest_received_nonce {
-			// technically this will be detected in the next loop iteration as `InvalidNumberOfDispatchResults`
-			// but to guarantee safety of loop operations below this is detected now
-			return Err(ReceivalConfirmationResult::FailedToConfirmFutureMessages);
+			// technically this will be detected in the next loop iteration as
+			// `InvalidNumberOfDispatchResults` but to guarantee safety of loop operations below
+			// this is detected now
+			return Err(ReceivalConfirmationResult::FailedToConfirmFutureMessages)
 		}
 		// entry must have single dispatch result for every message
 		// (guaranteed by the `InboundLane::receive_message()`)
-		if entry.messages.dispatch_results.len() as MessageNonce != entry.messages.end - entry.messages.begin + 1 {
-			return Err(ReceivalConfirmationResult::InvalidNumberOfDispatchResults);
+		if entry.messages.dispatch_results.len() as MessageNonce !=
+			entry.messages.end - entry.messages.begin + 1
+		{
+			return Err(ReceivalConfirmationResult::InvalidNumberOfDispatchResults)
 		}
 
 		// now we know that the entry is valid
 		// => let's check if it brings new confirmations
-		let new_messages_begin = sp_std::cmp::max(entry.messages.begin, prev_latest_received_nonce + 1);
+		let new_messages_begin =
+			sp_std::cmp::max(entry.messages.begin, prev_latest_received_nonce + 1);
 		let new_messages_end = sp_std::cmp::min(entry.messages.end, latest_received_nonce);
 		let new_messages_range = new_messages_begin..=new_messages_end;
 		if new_messages_range.is_empty() {
-			continue;
+			continue
 		}
 
 		// now we know that entry brings new confirmations
 		// => let's extract dispatch results
 		received_dispatch_result.extend_from_bitslice(
-			&entry.messages.dispatch_results[(new_messages_begin - entry.messages.begin) as usize..],
+			&entry.messages.dispatch_results
+				[(new_messages_begin - entry.messages.begin) as usize..],
 		);
 	}
 
@@ -228,12 +240,17 @@ fn extract_dispatch_results<RelayerId>(
 mod tests {
 	use super::*;
 	use crate::{
-		mock::{message_data, run_test, unrewarded_relayer, TestRelayer, TestRuntime, REGULAR_PAYLOAD, TEST_LANE_ID},
+		mock::{
+			message_data, run_test, unrewarded_relayer, TestRelayer, TestRuntime, REGULAR_PAYLOAD,
+			TEST_LANE_ID,
+		},
 		outbound_lane,
 	};
 	use sp_std::ops::RangeInclusive;
 
-	fn unrewarded_relayers(nonces: RangeInclusive<MessageNonce>) -> VecDeque<UnrewardedRelayer<TestRelayer>> {
+	fn unrewarded_relayers(
+		nonces: RangeInclusive<MessageNonce>,
+	) -> VecDeque<UnrewardedRelayer<TestRelayer>> {
 		vec![unrewarded_relayer(*nonces.start(), *nonces.end(), 0)]
 			.into_iter()
 			.collect()

bridges/modules/messages/src/weights_ext.rs

@@ -25,8 +25,8 @@ use frame_support::weights::{RuntimeDbWeight, Weight};
 /// Size of the message being delivered in benchmarks.
 pub const EXPECTED_DEFAULT_MESSAGE_LENGTH: u32 = 128;
 
-/// We assume that size of signed extensions on all our chains and size of all 'small' arguments of calls
-/// we're checking here would fit 1KB.
+/// We assume that size of signed extensions on all our chains and size of all 'small' arguments of
+/// calls we're checking here would fit 1KB.
 const SIGNED_EXTENSIONS_SIZE: u32 = 1024;
 
 /// Number of extra bytes (excluding size of storage value itself) of storage proof, built at
@@ -54,12 +54,15 @@ pub fn ensure_weights_are_correct<W: WeightInfoExt>(
 
 	// verify that the hardcoded value covers `receive_messages_proof` weight
 	let actual_single_regular_message_delivery_tx_weight = W::receive_messages_proof_weight(
-		&PreComputedSize((EXPECTED_DEFAULT_MESSAGE_LENGTH + W::expected_extra_storage_proof_size()) as usize),
+		&PreComputedSize(
+			(EXPECTED_DEFAULT_MESSAGE_LENGTH + W::expected_extra_storage_proof_size()) as usize,
+		),
 		1,
 		0,
 	);
 	assert!(
-		actual_single_regular_message_delivery_tx_weight <= expected_default_message_delivery_tx_weight,
+		actual_single_regular_message_delivery_tx_weight <=
+			expected_default_message_delivery_tx_weight,
 		"Default message delivery transaction weight {} is larger than expected weight {}",
 		actual_single_regular_message_delivery_tx_weight,
 		expected_default_message_delivery_tx_weight,
@@ -91,7 +94,8 @@ pub fn ensure_weights_are_correct<W: WeightInfoExt>(
 		db_weight,
 	);
 	assert!(
-		actual_messages_delivery_confirmation_tx_weight <= expected_messages_delivery_confirmation_tx_weight,
+		actual_messages_delivery_confirmation_tx_weight <=
+			expected_messages_delivery_confirmation_tx_weight,
 		"Messages delivery confirmation transaction weight {} is larger than expected weight {}",
 		actual_messages_delivery_confirmation_tx_weight,
 		expected_messages_delivery_confirmation_tx_weight,
@@ -115,7 +119,8 @@ pub fn ensure_able_to_receive_message<W: WeightInfoExt>(
 	max_incoming_message_dispatch_weight: Weight,
 ) {
 	// verify that we're able to receive proof of maximal-size message
-	let max_delivery_transaction_size = max_incoming_message_proof_size.saturating_add(SIGNED_EXTENSIONS_SIZE);
+	let max_delivery_transaction_size =
+		max_incoming_message_proof_size.saturating_add(SIGNED_EXTENSIONS_SIZE);
 	assert!(
 		max_delivery_transaction_size <= max_extrinsic_size,
 		"Size of maximal message delivery transaction {} + {} is larger than maximal possible transaction size {}",
@@ -126,7 +131,9 @@ pub fn ensure_able_to_receive_message<W: WeightInfoExt>(
 
 	// verify that we're able to receive proof of maximal-size message with maximal dispatch weight
 	let max_delivery_transaction_dispatch_weight = W::receive_messages_proof_weight(
-		&PreComputedSize((max_incoming_message_proof_size + W::expected_extra_storage_proof_size()) as usize),
+		&PreComputedSize(
+			(max_incoming_message_proof_size + W::expected_extra_storage_proof_size()) as usize,
+		),
 		1,
 		max_incoming_message_dispatch_weight,
 	);
@@ -158,7 +165,8 @@ pub fn ensure_able_to_receive_confirmation<W: WeightInfoExt>(
 		max_extrinsic_size,
 	);
 
-	// verify that we're able to reward maximal number of relayers that have delivered maximal number of messages
+	// verify that we're able to reward maximal number of relayers that have delivered maximal
+	// number of messages
 	let max_confirmation_transaction_dispatch_weight = W::receive_messages_delivery_proof_weight(
 		&PreComputedSize(max_inbound_lane_data_proof_size_from_peer_chain as usize),
 		&UnrewardedRelayersState {
@@ -200,10 +208,15 @@ pub trait WeightInfoExt: WeightInfo {
 	}
 
 	/// Weight of message delivery extrinsic.
-	fn receive_messages_proof_weight(proof: &impl Size, messages_count: u32, dispatch_weight: Weight) -> Weight {
+	fn receive_messages_proof_weight(
+		proof: &impl Size,
+		messages_count: u32,
+		dispatch_weight: Weight,
+	) -> Weight {
 		// basic components of extrinsic weight
 		let transaction_overhead = Self::receive_messages_proof_overhead();
-		let outbound_state_delivery_weight = Self::receive_messages_proof_outbound_lane_state_overhead();
+		let outbound_state_delivery_weight =
+			Self::receive_messages_proof_outbound_lane_state_overhead();
 		let messages_delivery_weight =
 			Self::receive_messages_proof_messages_overhead(MessageNonce::from(messages_count));
 		let messages_dispatch_weight = dispatch_weight;
@@ -213,8 +226,9 @@ pub trait WeightInfoExt: WeightInfo {
 			.saturating_mul(messages_count.saturating_sub(1))
 			.saturating_add(Self::expected_extra_storage_proof_size());
 		let actual_proof_size = proof.size_hint();
-		let proof_size_overhead =
-			Self::storage_proof_size_overhead(actual_proof_size.saturating_sub(expected_proof_size));
+		let proof_size_overhead = Self::storage_proof_size_overhead(
+			actual_proof_size.saturating_sub(expected_proof_size),
+		);
 
 		transaction_overhead
 			.saturating_add(outbound_state_delivery_weight)
@@ -231,17 +245,21 @@ pub trait WeightInfoExt: WeightInfo {
 	) -> Weight {
 		// basic components of extrinsic weight
 		let transaction_overhead = Self::receive_messages_delivery_proof_overhead();
-		let messages_overhead = Self::receive_messages_delivery_proof_messages_overhead(relayers_state.total_messages);
-		let relayers_overhead =
-			Self::receive_messages_delivery_proof_relayers_overhead(relayers_state.unrewarded_relayer_entries);
+		let messages_overhead =
+			Self::receive_messages_delivery_proof_messages_overhead(relayers_state.total_messages);
+		let relayers_overhead = Self::receive_messages_delivery_proof_relayers_overhead(
+			relayers_state.unrewarded_relayer_entries,
+		);
 
 		// proof size overhead weight
 		let expected_proof_size = Self::expected_extra_storage_proof_size();
 		let actual_proof_size = proof.size_hint();
-		let proof_size_overhead =
-			Self::storage_proof_size_overhead(actual_proof_size.saturating_sub(expected_proof_size));
+		let proof_size_overhead = Self::storage_proof_size_overhead(
+			actual_proof_size.saturating_sub(expected_proof_size),
+		);
 
-		// and cost of calling `OnDeliveryConfirmed::on_messages_delivered()` for every confirmed message
+		// and cost of calling `OnDeliveryConfirmed::on_messages_delivered()` for every confirmed
+		// message
 		let callback_overhead = relayers_state
 			.total_messages
 			.saturating_mul(Self::single_message_callback_overhead(db_weight));
@@ -260,22 +278,26 @@ pub trait WeightInfoExt: WeightInfo {
 		Self::send_minimal_message_worst_case()
 	}
 
-	/// Returns weight that needs to be accounted when message of given size is sent (`send_message`).
+	/// Returns weight that needs to be accounted when message of given size is sent
+	/// (`send_message`).
 	fn send_message_size_overhead(message_size: u32) -> Weight {
 		let message_size_in_kb = (1024u64 + message_size as u64) / 1024;
-		let single_kb_weight = (Self::send_16_kb_message_worst_case() - Self::send_1_kb_message_worst_case()) / 15;
+		let single_kb_weight =
+			(Self::send_16_kb_message_worst_case() - Self::send_1_kb_message_worst_case()) / 15;
 		message_size_in_kb * single_kb_weight
 	}
 
 	/// Returns weight overhead of message delivery transaction (`receive_messages_proof`).
 	fn receive_messages_proof_overhead() -> Weight {
-		let weight_of_two_messages_and_two_tx_overheads = Self::receive_single_message_proof().saturating_mul(2);
+		let weight_of_two_messages_and_two_tx_overheads =
+			Self::receive_single_message_proof().saturating_mul(2);
 		let weight_of_two_messages_and_single_tx_overhead = Self::receive_two_messages_proof();
-		weight_of_two_messages_and_two_tx_overheads.saturating_sub(weight_of_two_messages_and_single_tx_overhead)
+		weight_of_two_messages_and_two_tx_overheads
+			.saturating_sub(weight_of_two_messages_and_single_tx_overhead)
 	}
 
-	/// Returns weight that needs to be accounted when receiving given a number of messages with message
-	/// delivery transaction (`receive_messages_proof`).
+	/// Returns weight that needs to be accounted when receiving given a number of messages with
+	/// message delivery transaction (`receive_messages_proof`).
 	fn receive_messages_proof_messages_overhead(messages: MessageNonce) -> Weight {
 		let weight_of_two_messages_and_single_tx_overhead = Self::receive_two_messages_proof();
 		let weight_of_single_message_and_single_tx_overhead = Self::receive_single_message_proof();
@@ -284,27 +306,31 @@ pub trait WeightInfoExt: WeightInfo {
 			.saturating_mul(messages as Weight)
 	}
 
-	/// Returns weight that needs to be accounted when message delivery transaction (`receive_messages_proof`)
-	/// is carrying outbound lane state proof.
+	/// Returns weight that needs to be accounted when message delivery transaction
+	/// (`receive_messages_proof`) is carrying outbound lane state proof.
 	fn receive_messages_proof_outbound_lane_state_overhead() -> Weight {
-		let weight_of_single_message_and_lane_state = Self::receive_single_message_proof_with_outbound_lane_state();
+		let weight_of_single_message_and_lane_state =
+			Self::receive_single_message_proof_with_outbound_lane_state();
 		let weight_of_single_message = Self::receive_single_message_proof();
 		weight_of_single_message_and_lane_state.saturating_sub(weight_of_single_message)
 	}
 
-	/// Returns weight overhead of delivery confirmation transaction (`receive_messages_delivery_proof`).
+	/// Returns weight overhead of delivery confirmation transaction
+	/// (`receive_messages_delivery_proof`).
 	fn receive_messages_delivery_proof_overhead() -> Weight {
 		let weight_of_two_messages_and_two_tx_overheads =
 			Self::receive_delivery_proof_for_single_message().saturating_mul(2);
 		let weight_of_two_messages_and_single_tx_overhead =
 			Self::receive_delivery_proof_for_two_messages_by_single_relayer();
-		weight_of_two_messages_and_two_tx_overheads.saturating_sub(weight_of_two_messages_and_single_tx_overhead)
+		weight_of_two_messages_and_two_tx_overheads
+			.saturating_sub(weight_of_two_messages_and_single_tx_overhead)
 	}
 
 	/// Returns weight that needs to be accounted when receiving confirmations for given a number of
 	/// messages with delivery confirmation transaction (`receive_messages_delivery_proof`).
 	fn receive_messages_delivery_proof_messages_overhead(messages: MessageNonce) -> Weight {
-		let weight_of_two_messages = Self::receive_delivery_proof_for_two_messages_by_single_relayer();
+		let weight_of_two_messages =
+			Self::receive_delivery_proof_for_two_messages_by_single_relayer();
 		let weight_of_single_message = Self::receive_delivery_proof_for_single_message();
 		weight_of_two_messages
 			.saturating_sub(weight_of_single_message)
@@ -314,7 +340,8 @@ pub trait WeightInfoExt: WeightInfo {
 	/// Returns weight that needs to be accounted when receiving confirmations for given a number of
 	/// relayers entries with delivery confirmation transaction (`receive_messages_delivery_proof`).
 	fn receive_messages_delivery_proof_relayers_overhead(relayers: MessageNonce) -> Weight {
-		let weight_of_two_messages_by_two_relayers = Self::receive_delivery_proof_for_two_messages_by_two_relayers();
+		let weight_of_two_messages_by_two_relayers =
+			Self::receive_delivery_proof_for_two_messages_by_two_relayers();
 		let weight_of_two_messages_by_single_relayer =
 			Self::receive_delivery_proof_for_two_messages_by_single_relayer();
 		weight_of_two_messages_by_two_relayers
@@ -322,8 +349,8 @@ pub trait WeightInfoExt: WeightInfo {
 			.saturating_mul(relayers as Weight)
 	}
 
-	/// Returns weight that needs to be accounted when storage proof of given size is received (either in
-	/// `receive_messages_proof` or `receive_messages_delivery_proof`).
+	/// Returns weight that needs to be accounted when storage proof of given size is received
+	/// (either in `receive_messages_proof` or `receive_messages_delivery_proof`).
 	///
 	/// **IMPORTANT**: this overhead is already included in the 'base' transaction cost - e.g. proof
 	/// size depends on messages count or number of entries in the unrewarded relayers set. So this
@@ -332,23 +359,26 @@ pub trait WeightInfoExt: WeightInfo {
 	/// is less than that cost).
 	fn storage_proof_size_overhead(proof_size: u32) -> Weight {
 		let proof_size_in_bytes = proof_size as Weight;
-		let byte_weight =
-			(Self::receive_single_message_proof_16_kb() - Self::receive_single_message_proof_1_kb()) / (15 * 1024);
+		let byte_weight = (Self::receive_single_message_proof_16_kb() -
+			Self::receive_single_message_proof_1_kb()) /
+			(15 * 1024);
 		proof_size_in_bytes * byte_weight
 	}
 
 	/// Returns weight of the pay-dispatch-fee operation for inbound messages.
 	///
-	/// This function may return zero if runtime doesn't support pay-dispatch-fee-at-target-chain option.
+	/// This function may return zero if runtime doesn't support pay-dispatch-fee-at-target-chain
+	/// option.
 	fn pay_inbound_dispatch_fee_overhead() -> Weight {
-		Self::receive_single_message_proof().saturating_sub(Self::receive_single_prepaid_message_proof())
+		Self::receive_single_message_proof()
+			.saturating_sub(Self::receive_single_prepaid_message_proof())
 	}
 
 	/// Returns pre-dispatch weight of single callback call.
 	///
 	/// When benchmarking the weight please take into consideration both the `OnMessageAccepted` and
-	/// `OnDeliveryConfirmed` callbacks. The method should return the greater of the two, because it's
-	/// used to estimate the weight in both contexts.
+	/// `OnDeliveryConfirmed` callbacks. The method should return the greater of the two, because
+	/// it's used to estimate the weight in both contexts.
 	fn single_message_callback_overhead(db_weight: RuntimeDbWeight) -> Weight {
 		db_weight.reads_writes(1, 1)
 	}