Remove dispatch_result field (#1660)

* remove dispatch_result field

* fix benchmarks

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

@@ -194,7 +194,6 @@ mod tests {
 		let max_incoming_inbound_lane_data_proof_size =
 			bp_messages::InboundLaneData::<()>::encoded_size_hint_u32(
 				bp_millau::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX as _,
-				bp_millau::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX as _,
 			);
 		pallet_bridge_messages::ensure_able_to_receive_confirmation::<Weights>(
 			bp_millau::Millau::max_extrinsic_size(),

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

@@ -317,7 +317,6 @@ mod tests {
 			assert_eq!(
 				dispatch_result,
 				MessageDispatchResult {
-					dispatch_result: true,
 					unspent_weight: frame_support::weights::Weight::from_ref_time(0),
 					dispatch_fee_paid_during_dispatch: false,
 				}

bridges/bin/rialto-parachain/runtime/src/lib.rs

@@ -895,7 +895,6 @@ mod tests {
 			assert_eq!(
 				dispatch_result,
 				MessageDispatchResult {
-					dispatch_result: true,
 					unspent_weight: frame_support::weights::Weight::from_ref_time(0),
 					dispatch_fee_paid_during_dispatch: false,
 				}

bridges/bin/rialto/runtime/src/millau_messages.rs

@@ -192,7 +192,6 @@ mod tests {
 		let max_incoming_inbound_lane_data_proof_size =
 			bp_messages::InboundLaneData::<()>::encoded_size_hint_u32(
 				bp_rialto::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX as _,
-				bp_rialto::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX as _,
 			);
 		pallet_bridge_messages::ensure_able_to_receive_confirmation::<Weights>(
 			bp_rialto::Rialto::max_extrinsic_size(),

bridges/bin/rialto/runtime/src/xcm_config.rs

@@ -276,7 +276,6 @@ mod tests {
 			assert_eq!(
 				dispatch_result,
 				MessageDispatchResult {
-					dispatch_result: true,
 					unspent_weight: frame_support::weights::Weight::from_ref_time(0),
 					dispatch_fee_paid_during_dispatch: false,
 				}

bridges/bin/runtime-common/src/messages.rs

@@ -511,7 +511,7 @@ pub mod target {
 			};
 
 			let xcm_outcome = do_dispatch();
-			let dispatch_result = match xcm_outcome {
+			match xcm_outcome {
 				Ok(outcome) => {
 					log::trace!(
 						target: "runtime::bridge-dispatch",
@@ -520,7 +520,7 @@ pub mod target {
 						outcome,
 					);
 					match outcome.ensure_execution() {
-						Ok(_weight) => true,
+						Ok(_weight) => (),
 						Err(e) => {
 							log::error!(
 								target: "runtime::bridge-dispatch",
@@ -528,7 +528,6 @@ pub mod target {
 								message_id,
 								e,
 							);
-							false
 						},
 					}
 				},
@@ -539,12 +538,10 @@ pub mod target {
 						message_id,
 						e,
 					);
-					false
 				},
-			};
+			}
 
 			MessageDispatchResult {
-				dispatch_result,
 				unspent_weight: Weight::zero(),
 				dispatch_fee_paid_during_dispatch: false,
 			}

bridges/modules/messages/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2021"
 license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
 
 [dependencies]
-bitvec = { version = "1", default-features = false, features = ["alloc"] }
 codec = { package = "parity-scale-codec", version = "3.1.5", default-features = false }
 log = { version = "0.4.17", default-features = false }
 num-traits = { version = "0.2", default-features = false }

bridges/modules/messages/src/benchmarking.rs

@@ -311,7 +311,7 @@ benchmarks_instance_pallet! {
 			inbound_lane_data: InboundLaneData {
 				relayers: vec![UnrewardedRelayer {
 					relayer: relayer_id.clone(),
-					messages: DeliveredMessages::new(1, true),
+					messages: DeliveredMessages::new(1),
 				}].into_iter().collect(),
 				last_confirmed_nonce: 0,
 			},
@@ -342,8 +342,8 @@ benchmarks_instance_pallet! {
 			total_messages: 2,
 			last_delivered_nonce: 2,
 		};
-		let mut delivered_messages = DeliveredMessages::new(1, true);
-		delivered_messages.note_dispatched_message(true);
+		let mut delivered_messages = DeliveredMessages::new(1);
+		delivered_messages.note_dispatched_message();
 		let proof = T::prepare_message_delivery_proof(MessageDeliveryProofParams {
 			lane: T::bench_lane_id(),
 			inbound_lane_data: InboundLaneData {
@@ -387,11 +387,11 @@ benchmarks_instance_pallet! {
 				relayers: vec![
 					UnrewardedRelayer {
 						relayer: relayer1_id.clone(),
-						messages: DeliveredMessages::new(1, true),
+						messages: DeliveredMessages::new(1),
 					},
 					UnrewardedRelayer {
 						relayer: relayer2_id.clone(),
-						messages: DeliveredMessages::new(2, true),
+						messages: DeliveredMessages::new(2),
 					},
 				].into_iter().collect(),
 				last_confirmed_nonce: 0,
@@ -414,7 +414,7 @@ fn receive_messages<T: Config<I>, I: 'static>(nonce: MessageNonce) {
 	inbound_lane_storage.set_data(InboundLaneData {
 		relayers: vec![UnrewardedRelayer {
 			relayer: T::bridged_relayer_id(),
-			messages: DeliveredMessages::new(nonce, true),
+			messages: DeliveredMessages::new(nonce),
 		}]
 		.into_iter()
 		.collect(),

bridges/modules/messages/src/inbound_lane.rs

@@ -101,7 +101,6 @@ impl<T: Config<I>, I: 'static> MaxEncodedLen for StoredInboundLaneData<T, I> {
 	fn max_encoded_len() -> usize {
 		InboundLaneData::<T::InboundRelayer>::encoded_size_hint(
 			T::MaxUnrewardedRelayerEntriesAtInboundLane::get() as usize,
-			T::MaxUnconfirmedMessagesAtInboundLane::get() as usize,
 		)
 		.unwrap_or(usize::MAX)
 	}
@@ -150,10 +149,6 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		// overlap.
 		match data.relayers.front_mut() {
 			Some(entry) if entry.messages.begin < new_confirmed_nonce => {
-				entry.messages.dispatch_results = entry
-					.messages
-					.dispatch_results
-					.split_off((new_confirmed_nonce + 1 - entry.messages.begin) as _);
 				entry.messages.begin = new_confirmed_nonce + 1;
 			},
 			_ => {},
@@ -200,7 +195,7 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		// now let's update inbound lane storage
 		let push_new = match data.relayers.back_mut() {
 			Some(entry) if entry.relayer == *relayer_at_bridged_chain => {
-				entry.messages.note_dispatched_message(dispatch_result.dispatch_result);
+				entry.messages.note_dispatched_message();
 				false
 			},
 			_ => true,
@@ -208,7 +203,7 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		if push_new {
 			data.relayers.push_back(UnrewardedRelayer {
 				relayer: (*relayer_at_bridged_chain).clone(),
-				messages: DeliveredMessages::new(nonce, dispatch_result.dispatch_result),
+				messages: DeliveredMessages::new(nonce),
 			});
 		}
 		self.storage.set_data(data);

bridges/modules/messages/src/lib.rs

@@ -987,7 +987,7 @@ mod tests {
 					last_confirmed_nonce: 1,
 					relayers: vec![UnrewardedRelayer {
 						relayer: 0,
-						messages: DeliveredMessages::new(1, true),
+						messages: DeliveredMessages::new(1),
 					}]
 					.into_iter()
 					.collect(),
@@ -1007,7 +1007,7 @@ mod tests {
 				phase: Phase::Initialization,
 				event: TestEvent::Messages(Event::MessagesDelivered {
 					lane_id: TEST_LANE_ID,
-					messages: DeliveredMessages::new(1, true),
+					messages: DeliveredMessages::new(1),
 				}),
 				topics: vec![],
 			}],
@@ -1622,8 +1622,8 @@ mod tests {
 
 			// messages 1+2 are confirmed in 1 tx, message 3 in a separate tx
 			// dispatch of message 2 has failed
-			let mut delivered_messages_1_and_2 = DeliveredMessages::new(1, true);
-			delivered_messages_1_and_2.note_dispatched_message(false);
+			let mut delivered_messages_1_and_2 = DeliveredMessages::new(1);
+			delivered_messages_1_and_2.note_dispatched_message();
 			let messages_1_and_2_proof = Ok((
 				TEST_LANE_ID,
 				InboundLaneData {
@@ -1636,7 +1636,7 @@ mod tests {
 					.collect(),
 				},
 			));
-			let delivered_message_3 = DeliveredMessages::new(3, true);
+			let delivered_message_3 = DeliveredMessages::new(3);
 			let messages_3_proof = Ok((
 				TEST_LANE_ID,
 				InboundLaneData {

bridges/modules/messages/src/mock.rs

@@ -19,7 +19,6 @@
 
 use crate::{calc_relayers_rewards, Config};
 
-use bitvec::prelude::*;
 use bp_messages::{
 	source_chain::{LaneMessageVerifier, MessageDeliveryAndDispatchPayment, TargetHeaderChain},
 	target_chain::{
@@ -394,7 +393,6 @@ pub const fn message_payload(id: u64, declared_weight: u64) -> TestPayload {
 /// Returns message dispatch result with given unspent weight.
 pub const fn dispatch_result(unspent_weight: u64) -> MessageDispatchResult {
 	MessageDispatchResult {
-		dispatch_result: true,
 		unspent_weight: Weight::from_ref_time(unspent_weight),
 		dispatch_fee_paid_during_dispatch: true,
 	}
@@ -406,18 +404,7 @@ pub fn unrewarded_relayer(
 	end: MessageNonce,
 	relayer: TestRelayer,
 ) -> UnrewardedRelayer<TestRelayer> {
-	UnrewardedRelayer {
-		relayer,
-		messages: DeliveredMessages {
-			begin,
-			end,
-			dispatch_results: if end >= begin {
-				bitvec![u8, Msb0; 1; (end - begin + 1) as _]
-			} else {
-				Default::default()
-			},
-		},
-	}
+	UnrewardedRelayer { relayer, messages: DeliveredMessages { begin, end } }
 }
 
 /// Run pallet test.

bridges/modules/messages/src/outbound_lane.rs

@@ -18,10 +18,8 @@
 
 use crate::Config;
 
-use bitvec::prelude::*;
 use bp_messages::{
-	DeliveredMessages, DispatchResultsBitVec, LaneId, MessageNonce, MessagePayload,
-	OutboundLaneData, UnrewardedRelayer,
+	DeliveredMessages, LaneId, MessageNonce, MessagePayload, OutboundLaneData, UnrewardedRelayer,
 };
 use frame_support::{
 	weights::{RuntimeDbWeight, Weight},
@@ -67,9 +65,6 @@ pub enum ReceivalConfirmationResult {
 	/// 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.
-	InvalidNumberOfDispatchResults,
 	/// The chain has more messages that need to be confirmed than there is in the proof.
 	TryingToConfirmMoreMessagesThanExpected(MessageNonce),
 }
@@ -129,14 +124,9 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 			)
 		}
 
-		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,
-		};
+		if let Err(e) = ensure_unrewarded_relayers_are_correct(latest_delivered_nonce, relayers) {
+			return e
+		}
 
 		let prev_latest_received_nonce = data.latest_received_nonce;
 		data.latest_received_nonce = latest_delivered_nonce;
@@ -145,7 +135,6 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 		ReceivalConfirmationResult::ConfirmedMessages(DeliveredMessages {
 			begin: prev_latest_received_nonce + 1,
 			end: latest_delivered_nonce,
-			dispatch_results,
 		})
 	}
 
@@ -180,21 +169,14 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
 	}
 }
 
-/// Extract new dispatch results from the unrewarded relayers vec.
+/// Verifies unrewarded relayers vec.
 ///
 /// Returns `Err(_)` if unrewarded relayers vec contains invalid data, meaning that the bridged
 /// chain has invalid runtime storage.
-fn extract_dispatch_results<RelayerId>(
-	prev_latest_received_nonce: MessageNonce,
+fn ensure_unrewarded_relayers_are_correct<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
-	let mut received_dispatch_result =
-		BitVec::with_capacity((latest_received_nonce - prev_latest_received_nonce + 1) as _);
+) -> Result<(), ReceivalConfirmationResult> {
 	let mut last_entry_end: Option<MessageNonce> = None;
 	for entry in relayers {
 		// unrewarded relayer entry must have at least 1 unconfirmed message
@@ -219,33 +201,9 @@ fn extract_dispatch_results<RelayerId>(
 			// 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)
-		}
-
-		// 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_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
-		}
-
-		// 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..],
-		);
 	}
 
-	Ok(received_dispatch_result)
+	Ok(())
 }
 
 #[cfg(test)]
@@ -270,11 +228,7 @@ mod tests {
 	}
 
 	fn delivered_messages(nonces: RangeInclusive<MessageNonce>) -> DeliveredMessages {
-		DeliveredMessages {
-			begin: *nonces.start(),
-			end: *nonces.end(),
-			dispatch_results: bitvec![u8, Msb0; 1; (nonces.end() - nonces.start() + 1) as _],
-		}
+		DeliveredMessages { begin: *nonces.start(), end: *nonces.end() }
 	}
 
 	fn assert_3_messages_confirmation_fails(
@@ -407,20 +361,6 @@ mod tests {
 		);
 	}
 
-	#[test]
-	fn confirm_delivery_fails_if_number_of_dispatch_results_in_entry_is_invalid() {
-		let mut relayers: VecDeque<_> = unrewarded_relayers(1..=1)
-			.into_iter()
-			.chain(unrewarded_relayers(2..=2).into_iter())
-			.chain(unrewarded_relayers(3..=3).into_iter())
-			.collect();
-		relayers[0].messages.dispatch_results.clear();
-		assert_eq!(
-			assert_3_messages_confirmation_fails(3, &relayers),
-			ReceivalConfirmationResult::InvalidNumberOfDispatchResults,
-		);
-	}
-
 	#[test]
 	fn prune_messages_works() {
 		run_test(|| {

bridges/primitives/messages/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2021"
 license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
 
 [dependencies]
-bitvec = { version = "1", default-features = false, features = ["alloc"] }
 codec = { package = "parity-scale-codec", version = "3.1.5", default-features = false, features = ["derive", "bit-vec"] }
 impl-trait-for-tuples = "0.2"
 scale-info = { version = "2.1.1", default-features = false, features = ["bit-vec", "derive"] }
@@ -30,7 +29,6 @@ hex-literal = "0.3"
 [features]
 default = ["std"]
 std = [
-	"bitvec/std",
 	"bp-runtime/std",
 	"codec/std",
 	"frame-support/std",

bridges/primitives/messages/src/lib.rs

@@ -20,7 +20,6 @@
 // RuntimeApi generated functions
 #![allow(clippy::too_many_arguments)]
 
-use bitvec::prelude::*;
 use bp_runtime::{BasicOperatingMode, OperatingMode};
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::RuntimeDebug;
@@ -140,7 +139,7 @@ impl<RelayerId> InboundLaneData<RelayerId> {
 	/// size of each entry.
 	///
 	/// Returns `None` if size overflows `usize` limits.
-	pub fn encoded_size_hint(relayers_entries: usize, messages_count: usize) -> Option<usize>
+	pub fn encoded_size_hint(relayers_entries: usize) -> Option<usize>
 	where
 		RelayerId: MaxEncodedLen,
 	{
@@ -148,23 +147,18 @@ impl<RelayerId> InboundLaneData<RelayerId> {
 		let relayer_id_encoded_size = RelayerId::max_encoded_len();
 		let relayers_entry_size = relayer_id_encoded_size.checked_add(2 * message_nonce_size)?;
 		let relayers_size = relayers_entries.checked_mul(relayers_entry_size)?;
-		let dispatch_results_per_byte = 8;
-		let dispatch_result_size =
-			sp_std::cmp::max(relayers_entries, messages_count / dispatch_results_per_byte);
-		relayers_size
-			.checked_add(message_nonce_size)
-			.and_then(|result| result.checked_add(dispatch_result_size))
+		relayers_size.checked_add(message_nonce_size)
 	}
 
 	/// Returns the approximate size of the struct as u32, given a number of entries in the
 	/// `relayers` set and the size of each entry.
 	///
 	/// Returns `u32::MAX` if size overflows `u32` limits.
-	pub fn encoded_size_hint_u32(relayers_entries: usize, messages_count: usize) -> u32
+	pub fn encoded_size_hint_u32(relayers_entries: usize) -> u32
 	where
 		RelayerId: MaxEncodedLen,
 	{
-		Self::encoded_size_hint(relayers_entries, messages_count)
+		Self::encoded_size_hint(relayers_entries)
 			.and_then(|x| u32::try_from(x).ok())
 			.unwrap_or(u32::MAX)
 	}
@@ -204,9 +198,6 @@ pub struct InboundMessageDetails {
 	pub dispatch_weight: Weight,
 }
 
-/// Bit vector of message dispatch results.
-pub type DispatchResultsBitVec = BitVec<u8, Msb0>;
-
 /// Unrewarded relayer entry stored in the inbound lane data.
 ///
 /// This struct represents a continuous range of messages that have been delivered by the same
@@ -267,19 +258,13 @@ pub struct DeliveredMessages {
 	pub begin: MessageNonce,
 	/// Nonce of the last message that has been delivered (inclusive).
 	pub end: MessageNonce,
-	/// Dispatch result (`false`/`true`), returned by the message dispatcher for every
-	/// message in the `[begin; end]` range. See `dispatch_result` field of the
-	/// `bp_runtime::messages::MessageDispatchResult` structure for more information.
-	pub dispatch_results: DispatchResultsBitVec,
 }
 
 impl DeliveredMessages {
 	/// Create new `DeliveredMessages` struct that confirms delivery of single nonce with given
 	/// dispatch result.
-	pub fn new(nonce: MessageNonce, dispatch_result: bool) -> Self {
-		let mut dispatch_results = BitVec::with_capacity(1);
-		dispatch_results.push(dispatch_result);
-		DeliveredMessages { begin: nonce, end: nonce, dispatch_results }
+	pub fn new(nonce: MessageNonce) -> Self {
+		DeliveredMessages { begin: nonce, end: nonce }
 	}
 
 	/// Return total count of delivered messages.
@@ -292,30 +277,14 @@ impl DeliveredMessages {
 	}
 
 	/// Note new dispatched message.
-	pub fn note_dispatched_message(&mut self, dispatch_result: bool) {
+	pub fn note_dispatched_message(&mut self) {
 		self.end += 1;
-		self.dispatch_results.push(dispatch_result);
 	}
 
 	/// Returns true if delivered messages contain message with given nonce.
 	pub fn contains_message(&self, nonce: MessageNonce) -> bool {
 		(self.begin..=self.end).contains(&nonce)
 	}
-
-	/// Get dispatch result flag by message nonce.
-	///
-	/// Dispatch result flag must be interpreted using the knowledge of dispatch mechanism
-	/// at the target chain. See `dispatch_result` field of the
-	/// `bp_runtime::messages::MessageDispatchResult` structure for more information.
-	///
-	/// Panics if message nonce is not in the `begin..=end` range. Typically you'll first
-	/// check if message is within the range by calling `contains_message`.
-	pub fn message_dispatch_result(&self, nonce: MessageNonce) -> bool {
-		const INVALID_NONCE: &str = "Invalid nonce used to index dispatch_results";
-
-		let index = nonce.checked_sub(self.begin).expect(INVALID_NONCE) as usize;
-		*self.dispatch_results.get(index).expect(INVALID_NONCE)
-	}
 }
 
 /// Gist of `InboundLaneData::relayers` field used by runtime APIs.
@@ -386,10 +355,10 @@ mod tests {
 		assert_eq!(
 			total_unrewarded_messages(
 				&vec![
-					UnrewardedRelayer { relayer: 1, messages: DeliveredMessages::new(0, true) },
+					UnrewardedRelayer { relayer: 1, messages: DeliveredMessages::new(0) },
 					UnrewardedRelayer {
 						relayer: 2,
-						messages: DeliveredMessages::new(MessageNonce::MAX, true)
+						messages: DeliveredMessages::new(MessageNonce::MAX)
 					},
 				]
 				.into_iter()
@@ -410,21 +379,12 @@ mod tests {
 			(13u8, 128u8),
 		];
 		for (relayer_entries, messages_count) in test_cases {
-			let expected_size =
-				InboundLaneData::<u8>::encoded_size_hint(relayer_entries as _, messages_count as _);
+			let expected_size = InboundLaneData::<u8>::encoded_size_hint(relayer_entries as _);
 			let actual_size = InboundLaneData {
 				relayers: (1u8..=relayer_entries)
-					.map(|i| {
-						let mut entry = UnrewardedRelayer {
-							relayer: i,
-							messages: DeliveredMessages::new(i as _, true),
-						};
-						entry.messages.dispatch_results = bitvec![
-							u8, Msb0;
-							1;
-							(messages_count / relayer_entries) as _
-						];
-						entry
+					.map(|i| UnrewardedRelayer {
+						relayer: i,
+						messages: DeliveredMessages::new(i as _),
 					})
 					.collect(),
 				last_confirmed_nonce: messages_count as _,
@@ -444,15 +404,12 @@ mod tests {
 	}
 
 	#[test]
-	fn message_dispatch_result_works() {
-		let delivered_messages =
-			DeliveredMessages { begin: 100, end: 150, dispatch_results: bitvec![u8, Msb0; 1; 151] };
+	fn contains_result_works() {
+		let delivered_messages = DeliveredMessages { begin: 100, end: 150 };
 
 		assert!(!delivered_messages.contains_message(99));
 		assert!(delivered_messages.contains_message(100));
 		assert!(delivered_messages.contains_message(150));
 		assert!(!delivered_messages.contains_message(151));
-
-		assert!(delivered_messages.message_dispatch_result(125));
 	}
 }

bridges/primitives/messages/src/target_chain.rs

@@ -156,7 +156,6 @@ impl<AccountId> MessageDispatch<AccountId> for ForbidInboundMessages {
 
 	fn dispatch(_: &AccountId, _: DispatchMessage<Self::DispatchPayload>) -> MessageDispatchResult {
 		MessageDispatchResult {
-			dispatch_result: false,
 			unspent_weight: Weight::zero(),
 			dispatch_fee_paid_during_dispatch: false,
 		}

bridges/primitives/runtime/src/messages.rs

@@ -23,12 +23,6 @@ use scale_info::TypeInfo;
 /// Message dispatch result.
 #[derive(Encode, Decode, RuntimeDebug, Clone, PartialEq, Eq, TypeInfo)]
 pub struct MessageDispatchResult {
-	/// Dispatch result flag. This flag is relayed back to the source chain and, generally
-	/// speaking, may bring any (that fits in single bit) information from the dispatcher at
-	/// the target chain to the message submitter at the source chain. If you're using immediate
-	/// call dispatcher, then it'll be result of the dispatch - `true` if dispatch has succeeded
-	/// and `false` otherwise.
-	pub dispatch_result: bool,
 	/// Unspent dispatch weight. This weight that will be deducted from total delivery transaction
 	/// weight, thus reducing the transaction cost. This shall not be zero in (at least) two cases:
 	///