Small cosmetic changes

Signed-off-by: Serban Iorga <serban@parity.io>

bridges/bin/millau/runtime/src/lib.rs

@@ -847,11 +847,10 @@ impl_runtime_apis! {
 		fn best_finalized() -> Option<(bp_rialto::BlockNumber, bp_rialto::Hash)> {
 			// the parachains finality pallet is never decoding parachain heads, so it is
 			// only done in the integration code
-			use bp_rialto_parachain::RIALTO_PARACHAIN_ID;
 			let encoded_head = pallet_bridge_parachains::Pallet::<
 				Runtime,
 				WithRialtoParachainsInstance,
-			>::best_parachain_head(RIALTO_PARACHAIN_ID.into())?;
+			>::best_parachain_head(bp_rialto_parachain::RIALTO_PARACHAIN_ID.into())?;
 			let head = bp_rialto_parachain::Header::decode(&mut &encoded_head.0[..]).ok()?;
 			Some((*head.number(), head.hash()))
 		}

bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs

@@ -433,42 +433,30 @@ where
 	ParaNumber: Copy + PartialOrd + Zero,
 	RelayNumber: Copy + Debug + Ord,
 {
-	// this switch is responsible for processing `RelayingRelayHeader` state
-	match state {
-		RelayState::Idle | RelayState::RelayingParaHeader(_) => (),
-		RelayState::RelayingRelayHeader(relay_header_number) => {
-			if data.relay_header_at_target < relay_header_number {
-				// required relay header hasn't yet been relayed
-				return RelayState::RelayingRelayHeader(relay_header_number)
-			}
-
-			// we may switch to `RelayingParaHeader` if parachain head is available
-			if let Some(para_header_at_relay_header_at_target) =
-				data.para_header_at_relay_header_at_target.clone()
-			{
-				state = RelayState::RelayingParaHeader(para_header_at_relay_header_at_target);
-			} else {
-				// otherwise, we'd need to restart (this may happen only if parachain has been
-				// deregistered)
-				state = RelayState::Idle;
-			}
-		},
+	// Process the `RelayingRelayHeader` state.
+	if let &RelayState::RelayingRelayHeader(relay_header_number) = &state {
+		if data.relay_header_at_target < relay_header_number {
+			// The required relay header hasn't yet been relayed. Ask / wait for it.
+			return state
+		}
+
+		// We may switch to `RelayingParaHeader` if parachain head is available.
+		state = data
+			.para_header_at_relay_header_at_target
+			.clone()
+			.map_or(RelayState::Idle, RelayState::RelayingParaHeader);
 	}
 
-	// this switch is responsible for processing `RelayingParaHeader` state
-	let para_header_at_target_or_zero = data.para_header_at_target.unwrap_or_else(Zero::zero);
-	match state {
-		RelayState::Idle => (),
-		RelayState::RelayingRelayHeader(_) => unreachable!("processed by previous match; qed"),
-		RelayState::RelayingParaHeader(para_header_id) => {
-			if para_header_at_target_or_zero < para_header_id.0 {
-				// parachain header hasn't yet been relayed
-				return RelayState::RelayingParaHeader(para_header_id)
-			}
-		},
+	// Process the `RelayingParaHeader` state.
+	if let RelayState::RelayingParaHeader(para_header_id) = &state {
+		let para_header_at_target_or_zero = data.para_header_at_target.unwrap_or_else(Zero::zero);
+		if para_header_at_target_or_zero < para_header_id.0 {
+			// The required parachain header hasn't yet been relayed. Ask / wait for it.
+			return state
+		}
 	}
 
-	// if we haven't read para head from the source, we can't yet do anyhting
+	// if we haven't read para head from the source, we can't yet do anything
 	let para_header_at_source = match data.para_header_at_source {
 		Some(ref para_header_at_source) => para_header_at_source.clone(),
 		None => return RelayState::Idle,