Backport changes from polkadot-sdk (#2899)

* Fix spelling mistakes across the whole repository (#3808)

**Update:** Pushed additional changes based on the review comments.

**This pull request fixes various spelling mistakes in this
repository.**

Most of the changes are contained in the first **3** commits:

- `Fix spelling mistakes in comments and docs`

- `Fix spelling mistakes in test names`

- `Fix spelling mistakes in error messages, panic messages, logs and
tracing`

Other source code spelling mistakes are separated into individual
commits for easier reviewing:

- `Fix the spelling of 'authority'`

- `Fix the spelling of 'REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY'`

- `Fix the spelling of 'prev_enqueud_messages'`

- `Fix the spelling of 'endpoint'`

- `Fix the spelling of 'children'`

- `Fix the spelling of 'PenpalSiblingSovereignAccount'`

- `Fix the spelling of 'PenpalSudoAccount'`

- `Fix the spelling of 'insufficient'`

- `Fix the spelling of 'PalletXcmExtrinsicsBenchmark'`

- `Fix the spelling of 'subtracted'`

- `Fix the spelling of 'CandidatePendingAvailability'`

- `Fix the spelling of 'exclusive'`

- `Fix the spelling of 'until'`

- `Fix the spelling of 'discriminator'`

- `Fix the spelling of 'nonexistent'`

- `Fix the spelling of 'subsystem'`

- `Fix the spelling of 'indices'`

- `Fix the spelling of 'committed'`

- `Fix the spelling of 'topology'`

- `Fix the spelling of 'response'`

- `Fix the spelling of 'beneficiary'`

- `Fix the spelling of 'formatted'`

- `Fix the spelling of 'UNKNOWN_PROOF_REQUEST'`

- `Fix the spelling of 'succeeded'`

- `Fix the spelling of 'reopened'`

- `Fix the spelling of 'proposer'`

- `Fix the spelling of 'InstantiationNonce'`

- `Fix the spelling of 'depositor'`

- `Fix the spelling of 'expiration'`

- `Fix the spelling of 'phantom'`

- `Fix the spelling of 'AggregatedKeyValue'`

- `Fix the spelling of 'randomness'`

- `Fix the spelling of 'defendant'`

- `Fix the spelling of 'AquaticMammal'`

- `Fix the spelling of 'transactions'`

- `Fix the spelling of 'PassingTracingSubscriber'`

- `Fix the spelling of 'TxSignaturePayload'`

- `Fix the spelling of 'versioning'`

- `Fix the spelling of 'descendant'`

- `Fix the spelling of 'overridden'`

- `Fix the spelling of 'network'`

Let me know if this structure is adequate.

**Note:** The usage of the words `Merkle`, `Merkelize`, `Merklization`,
`Merkelization`, `Merkleization`, is somewhat inconsistent but I left it
as it is.

~~**Note:** In some places the term `Receival` is used to refer to
message reception, IMO `Reception` is the correct word here, but I left
it as it is.~~

~~**Note:** In some places the term `Overlayed` is used instead of the
more acceptable version `Overlaid` but I also left it as it is.~~

~~**Note:** In some places the term `Applyable` is used instead of the
correct version `Applicable` but I also left it as it is.~~

**Note:** Some usage of British vs American english e.g. `judgement` vs
`judgment`, `initialise` vs `initialize`, `optimise` vs `optimize` etc.
are both present in different places, but I suppose that's
understandable given the number of contributors.

~~**Note:** There is a spelling mistake in `.github/CODEOWNERS` but it
triggers errors in CI when I make changes to it, so I left it as it
is.~~

(cherry picked from commit 002d9260f9)

* Fix

---------

Co-authored-by: Dcompoze <contact@dcsoftware.xyz>

bridges/modules/messages/src/inbound_lane.rs

@@ -21,7 +21,7 @@ use crate::Config;
 use bp_messages::{
 	target_chain::{DispatchMessage, DispatchMessageData, MessageDispatch},
 	DeliveredMessages, InboundLaneData, LaneId, MessageKey, MessageNonce, OutboundLaneData,
-	ReceivalResult, UnrewardedRelayer,
+	ReceptionResult, UnrewardedRelayer,
 };
 use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
 use frame_support::traits::Get;
@@ -170,21 +170,21 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		relayer_at_bridged_chain: &S::Relayer,
 		nonce: MessageNonce,
 		message_data: DispatchMessageData<Dispatch::DispatchPayload>,
-	) -> ReceivalResult<Dispatch::DispatchLevelResult> {
+	) -> ReceptionResult<Dispatch::DispatchLevelResult> {
 		let mut data = self.storage.get_or_init_data();
 		if Some(nonce) != data.last_delivered_nonce().checked_add(1) {
-			return ReceivalResult::InvalidNonce
+			return ReceptionResult::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 ReceptionResult::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 ReceptionResult::TooManyUnconfirmedMessages
 		}
 
 		// then, dispatch message
@@ -207,7 +207,7 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		};
 		self.storage.set_data(data);
 
-		ReceivalResult::Dispatched(dispatch_result)
+		ReceptionResult::Dispatched(dispatch_result)
 	}
 }
 
@@ -235,7 +235,7 @@ mod tests {
 				nonce,
 				inbound_message_data(REGULAR_PAYLOAD)
 			),
-			ReceivalResult::Dispatched(dispatch_result(0))
+			ReceptionResult::Dispatched(dispatch_result(0))
 		);
 	}
 
@@ -362,7 +362,7 @@ mod tests {
 					10,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::InvalidNonce
+				ReceptionResult::InvalidNonce
 			);
 			assert_eq!(lane.storage.get_or_init_data().last_delivered_nonce(), 0);
 		});
@@ -381,7 +381,7 @@ mod tests {
 						current_nonce,
 						inbound_message_data(REGULAR_PAYLOAD)
 					),
-					ReceivalResult::Dispatched(dispatch_result(0))
+					ReceptionResult::Dispatched(dispatch_result(0))
 				);
 			}
 			// Fails to dispatch new message from different than latest relayer.
@@ -391,7 +391,7 @@ mod tests {
 					max_nonce + 1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::TooManyUnrewardedRelayers,
+				ReceptionResult::TooManyUnrewardedRelayers,
 			);
 			// Fails to dispatch new messages from latest relayer. Prevents griefing attacks.
 			assert_eq!(
@@ -400,7 +400,7 @@ mod tests {
 					max_nonce + 1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::TooManyUnrewardedRelayers,
+				ReceptionResult::TooManyUnrewardedRelayers,
 			);
 		});
 	}
@@ -417,7 +417,7 @@ mod tests {
 						current_nonce,
 						inbound_message_data(REGULAR_PAYLOAD)
 					),
-					ReceivalResult::Dispatched(dispatch_result(0))
+					ReceptionResult::Dispatched(dispatch_result(0))
 				);
 			}
 			// Fails to dispatch new message from different than latest relayer.
@@ -427,7 +427,7 @@ mod tests {
 					max_nonce + 1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::TooManyUnconfirmedMessages,
+				ReceptionResult::TooManyUnconfirmedMessages,
 			);
 			// Fails to dispatch new messages from latest relayer.
 			assert_eq!(
@@ -436,7 +436,7 @@ mod tests {
 					max_nonce + 1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::TooManyUnconfirmedMessages,
+				ReceptionResult::TooManyUnconfirmedMessages,
 			);
 		});
 	}
@@ -451,7 +451,7 @@ mod tests {
 					1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::Dispatched(dispatch_result(0))
+				ReceptionResult::Dispatched(dispatch_result(0))
 			);
 			assert_eq!(
 				lane.receive_message::<TestMessageDispatch>(
@@ -459,7 +459,7 @@ mod tests {
 					2,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::Dispatched(dispatch_result(0))
+				ReceptionResult::Dispatched(dispatch_result(0))
 			);
 			assert_eq!(
 				lane.receive_message::<TestMessageDispatch>(
@@ -467,7 +467,7 @@ mod tests {
 					3,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::Dispatched(dispatch_result(0))
+				ReceptionResult::Dispatched(dispatch_result(0))
 			);
 			assert_eq!(
 				lane.storage.get_or_init_data().relayers,
@@ -490,7 +490,7 @@ mod tests {
 					1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::Dispatched(dispatch_result(0))
+				ReceptionResult::Dispatched(dispatch_result(0))
 			);
 			assert_eq!(
 				lane.receive_message::<TestMessageDispatch>(
@@ -498,7 +498,7 @@ mod tests {
 					1,
 					inbound_message_data(REGULAR_PAYLOAD)
 				),
-				ReceivalResult::InvalidNonce,
+				ReceptionResult::InvalidNonce,
 			);
 		});
 	}
@@ -524,7 +524,7 @@ mod tests {
 					1,
 					inbound_message_data(payload)
 				),
-				ReceivalResult::Dispatched(dispatch_result(1))
+				ReceptionResult::Dispatched(dispatch_result(1))
 			);
 		});
 	}

bridges/modules/messages/src/lib.rs

@@ -47,7 +47,7 @@ pub use weights_ext::{
 
 use crate::{
 	inbound_lane::{InboundLane, InboundLaneStorage},
-	outbound_lane::{OutboundLane, OutboundLaneStorage, ReceivalConfirmationError},
+	outbound_lane::{OutboundLane, OutboundLaneStorage, ReceptionConfirmationError},
 };
 
 use bp_messages::{
@@ -90,7 +90,7 @@ pub const LOG_TARGET: &str = "runtime::bridge-messages";
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-	use bp_messages::{ReceivalResult, ReceivedMessages};
+	use bp_messages::{ReceivedMessages, ReceptionResult};
 	use bp_runtime::RangeInclusiveExt;
 	use frame_support::pallet_prelude::*;
 	use frame_system::pallet_prelude::*;
@@ -376,13 +376,13 @@ pub mod pallet {
 					// delivery transaction cost anyway. And base cost covers everything except
 					// dispatch, so we have a balance here.
 					let unspent_weight = match &receival_result {
-						ReceivalResult::Dispatched(dispatch_result) => {
+						ReceptionResult::Dispatched(dispatch_result) => {
 							valid_messages += 1;
 							dispatch_result.unspent_weight
 						},
-						ReceivalResult::InvalidNonce |
-						ReceivalResult::TooManyUnrewardedRelayers |
-						ReceivalResult::TooManyUnconfirmedMessages => message_dispatch_weight,
+						ReceptionResult::InvalidNonce |
+						ReceptionResult::TooManyUnrewardedRelayers |
+						ReceptionResult::TooManyUnconfirmedMessages => message_dispatch_weight,
 					};
 					lane_messages_received_status.push(message.key.nonce, receival_result);
 
@@ -455,7 +455,7 @@ pub mod pallet {
 					last_delivered_nonce,
 					&lane_data.relayers,
 				)
-				.map_err(Error::<T, I>::ReceivalConfirmation)?;
+				.map_err(Error::<T, I>::ReceptionConfirmation)?;
 
 			if let Some(confirmed_messages) = confirmed_messages {
 				// emit 'delivered' event
@@ -563,7 +563,7 @@ pub mod pallet {
 		/// The message someone is trying to work with (i.e. increase fee) is not yet sent.
 		MessageIsNotYetSent,
 		/// Error confirming messages receival.
-		ReceivalConfirmation(ReceivalConfirmationError),
+		ReceptionConfirmation(ReceptionConfirmationError),
 		/// Error generated by the `OwnedBridgeModule` trait.
 		BridgeModule(bp_runtime::OwnedBridgeModuleError),
 	}
@@ -923,7 +923,7 @@ mod tests {
 			PAYLOAD_REJECTED_BY_TARGET_CHAIN, REGULAR_PAYLOAD, TEST_LANE_ID, TEST_LANE_ID_2,
 			TEST_LANE_ID_3, TEST_RELAYER_A, TEST_RELAYER_B,
 		},
-		outbound_lane::ReceivalConfirmationError,
+		outbound_lane::ReceptionConfirmationError,
 	};
 	use bp_messages::{
 		source_chain::MessagesBridge, BridgeMessagesCall, UnrewardedRelayer,
@@ -950,11 +950,11 @@ mod tests {
 
 		let outbound_lane = outbound_lane::<TestRuntime, ()>(lane_id);
 		let message_nonce = outbound_lane.data().latest_generated_nonce + 1;
-		let prev_enqueud_messages = outbound_lane.data().queued_messages().saturating_len();
+		let prev_enqueued_messages = outbound_lane.data().queued_messages().saturating_len();
 		let valid_message = Pallet::<TestRuntime, ()>::validate_message(lane_id, &REGULAR_PAYLOAD)
 			.expect("validate_message has failed");
 		let artifacts = Pallet::<TestRuntime, ()>::send_message(valid_message);
-		assert_eq!(artifacts.enqueued_messages, prev_enqueud_messages + 1);
+		assert_eq!(artifacts.enqueued_messages, prev_enqueued_messages + 1);
 
 		// check event with assigned nonce
 		assert_eq!(
@@ -1541,7 +1541,7 @@ mod tests {
 	}
 
 	#[test]
-	fn actual_dispatch_weight_does_not_overlow() {
+	fn actual_dispatch_weight_does_not_overflow() {
 		run_test(|| {
 			let message1 = message(1, message_payload(0, u64::MAX / 2));
 			let message2 = message(2, message_payload(0, u64::MAX / 2));
@@ -1775,7 +1775,7 @@ mod tests {
 			//    returns `last_confirmed_nonce`;
 			// 3) it means that we're going to confirm delivery of messages 1..=1;
 			// 4) so the number of declared messages (see `UnrewardedRelayersState`) is `0` and
-			//    numer of actually confirmed messages is `1`.
+			//    number of actually confirmed messages is `1`.
 			assert_noop!(
 				Pallet::<TestRuntime>::receive_messages_delivery_proof(
 					RuntimeOrigin::signed(1),
@@ -1785,8 +1785,8 @@ mod tests {
 					))),
 					UnrewardedRelayersState { last_delivered_nonce: 1, ..Default::default() },
 				),
-				Error::<TestRuntime, ()>::ReceivalConfirmation(
-					ReceivalConfirmationError::TryingToConfirmMoreMessagesThanExpected
+				Error::<TestRuntime, ()>::ReceptionConfirmation(
+					ReceptionConfirmationError::TryingToConfirmMoreMessagesThanExpected
 				),
 			);
 		});

bridges/modules/messages/src/outbound_lane.rs

@@ -53,7 +53,7 @@ pub type StoredMessagePayload<T, I> = BoundedVec<u8, <T as Config<I>>::MaximalOu
 
 /// Result of messages receival confirmation.
 #[derive(Encode, Decode, RuntimeDebug, PartialEq, Eq, PalletError, TypeInfo)]
-pub enum ReceivalConfirmationError {
+pub enum ReceptionConfirmationError {
 	/// Bridged chain is trying to confirm more messages than we have generated. May be a result
 	/// of invalid bridged chain storage.
 	FailedToConfirmFutureMessages,
@@ -103,7 +103,7 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 		max_allowed_messages: MessageNonce,
 		latest_delivered_nonce: MessageNonce,
 		relayers: &VecDeque<UnrewardedRelayer<RelayerId>>,
-	) -> Result<Option<DeliveredMessages>, ReceivalConfirmationError> {
+	) -> Result<Option<DeliveredMessages>, ReceptionConfirmationError> {
 		let mut data = self.storage.data();
 		let confirmed_messages = DeliveredMessages {
 			begin: data.latest_received_nonce.saturating_add(1),
@@ -113,7 +113,7 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 			return Ok(None)
 		}
 		if confirmed_messages.end > data.latest_generated_nonce {
-			return Err(ReceivalConfirmationError::FailedToConfirmFutureMessages)
+			return Err(ReceptionConfirmationError::FailedToConfirmFutureMessages)
 		}
 		if confirmed_messages.total_messages() > max_allowed_messages {
 			// that the relayer has declared correct number of messages that the proof contains (it
@@ -127,7 +127,7 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 				confirmed_messages.total_messages(),
 				max_allowed_messages,
 			);
-			return Err(ReceivalConfirmationError::TryingToConfirmMoreMessagesThanExpected)
+			return Err(ReceptionConfirmationError::TryingToConfirmMoreMessagesThanExpected)
 		}
 
 		ensure_unrewarded_relayers_are_correct(confirmed_messages.end, relayers)?;
@@ -176,24 +176,24 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 fn ensure_unrewarded_relayers_are_correct<RelayerId>(
 	latest_received_nonce: MessageNonce,
 	relayers: &VecDeque<UnrewardedRelayer<RelayerId>>,
-) -> Result<(), ReceivalConfirmationError> {
+) -> Result<(), ReceptionConfirmationError> {
 	let mut expected_entry_begin = relayers.front().map(|entry| entry.messages.begin);
 	for entry in relayers {
 		// 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(ReceivalConfirmationError::EmptyUnrewardedRelayerEntry)
+			return Err(ReceptionConfirmationError::EmptyUnrewardedRelayerEntry)
 		}
 		// every entry must confirm range of messages that follows previous entry range
 		// (guaranteed by the `InboundLane::receive_message()`)
 		if expected_entry_begin != Some(entry.messages.begin) {
-			return Err(ReceivalConfirmationError::NonConsecutiveUnrewardedRelayerEntries)
+			return Err(ReceptionConfirmationError::NonConsecutiveUnrewardedRelayerEntries)
 		}
 		expected_entry_begin = entry.messages.end.checked_add(1);
 		// 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 {
-			return Err(ReceivalConfirmationError::FailedToConfirmFutureMessages)
+			return Err(ReceptionConfirmationError::FailedToConfirmFutureMessages)
 		}
 	}
 
@@ -228,7 +228,7 @@ mod tests {
 	fn assert_3_messages_confirmation_fails(
 		latest_received_nonce: MessageNonce,
 		relayers: &VecDeque<UnrewardedRelayer<TestRelayer>>,
-	) -> Result<Option<DeliveredMessages>, ReceivalConfirmationError> {
+	) -> Result<Option<DeliveredMessages>, ReceptionConfirmationError> {
 		run_test(|| {
 			let mut lane = outbound_lane::<TestRuntime, _>(TEST_LANE_ID);
 			lane.send_message(outbound_message_data(REGULAR_PAYLOAD));
@@ -299,7 +299,7 @@ mod tests {
 	fn confirm_delivery_rejects_nonce_larger_than_last_generated() {
 		assert_eq!(
 			assert_3_messages_confirmation_fails(10, &unrewarded_relayers(1..=10),),
-			Err(ReceivalConfirmationError::FailedToConfirmFutureMessages),
+			Err(ReceptionConfirmationError::FailedToConfirmFutureMessages),
 		);
 	}
 
@@ -314,7 +314,7 @@ mod tests {
 					.chain(unrewarded_relayers(3..=3).into_iter())
 					.collect(),
 			),
-			Err(ReceivalConfirmationError::FailedToConfirmFutureMessages),
+			Err(ReceptionConfirmationError::FailedToConfirmFutureMessages),
 		);
 	}
 
@@ -330,7 +330,7 @@ mod tests {
 					.chain(unrewarded_relayers(2..=3).into_iter())
 					.collect(),
 			),
-			Err(ReceivalConfirmationError::EmptyUnrewardedRelayerEntry),
+			Err(ReceptionConfirmationError::EmptyUnrewardedRelayerEntry),
 		);
 	}
 
@@ -345,7 +345,7 @@ mod tests {
 					.chain(unrewarded_relayers(2..=2).into_iter())
 					.collect(),
 			),
-			Err(ReceivalConfirmationError::NonConsecutiveUnrewardedRelayerEntries),
+			Err(ReceptionConfirmationError::NonConsecutiveUnrewardedRelayerEntries),
 		);
 	}
 
@@ -409,11 +409,11 @@ mod tests {
 			lane.send_message(outbound_message_data(REGULAR_PAYLOAD));
 			assert_eq!(
 				lane.confirm_delivery(0, 3, &unrewarded_relayers(1..=3)),
-				Err(ReceivalConfirmationError::TryingToConfirmMoreMessagesThanExpected),
+				Err(ReceptionConfirmationError::TryingToConfirmMoreMessagesThanExpected),
 			);
 			assert_eq!(
 				lane.confirm_delivery(2, 3, &unrewarded_relayers(1..=3)),
-				Err(ReceivalConfirmationError::TryingToConfirmMoreMessagesThanExpected),
+				Err(ReceptionConfirmationError::TryingToConfirmMoreMessagesThanExpected),
 			);
 			assert_eq!(
 				lane.confirm_delivery(3, 3, &unrewarded_relayers(1..=3)),