dispatch message weight for bridge messages

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

@@ -21,7 +21,8 @@
 
 use crate::{
 	messages::{
-		source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
+		source::FromBridgedChainMessagesDeliveryProof,
+		target::FromBridgedChainMessagesProof,
 		AccountIdOf, BridgedChain, HashOf, HasherOf, MessageBridge, ThisChain,
 	},
 	messages_generation::{
@@ -40,6 +41,39 @@ use pallet_bridge_messages::benchmarking::{MessageDeliveryProofParams, MessagePr
 use sp_runtime::traits::{Header, Zero};
 use sp_std::prelude::*;
 use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, TrieMut};
+use xcm::v3::prelude::*;
+
+/// Prepare inbound bridge message according to given message proof parameters.
+fn prepare_inbound_message(
+	params: &MessageProofParams,
+	destination: InteriorMultiLocation,
+) -> Vec<u8> {
+	// we only care about **this** message size when message proof needs to be `Minimal`
+	let expected_size = match params.size {
+		StorageProofSize::Minimal(size) => size as usize,
+		_ => 0,
+	};
+
+	// if we don't need a correct message, then we may just return some random blob
+	if !params.is_successful_dispatch_expected {
+		return vec![0u8; expected_size]
+	}
+
+	// else let's prepare successful message. For XCM bridge hubs, it is the message that
+	// will be pushed further to some XCM queue (XCMP/UMP)
+	let location = xcm::VersionedInteriorMultiLocation::V3(destination);
+	let location_encoded_size = location.encoded_size();
+
+	// we don't need to be super-precise with `expected_size` here
+	let xcm_size = expected_size.saturating_sub(location_encoded_size);
+	let xcm = xcm::VersionedXcm::<()>::V3(vec![Instruction::ClearOrigin; xcm_size].into());
+
+	// this is the `BridgeMessage` from polkadot xcm builder, but it has no constructor
+	// or public fields, so just tuple
+	// (double encoding, because `.encode()` is called on original Xcm BLOB when it is pushed
+	// to the storage)
+	(location, xcm).encode().encode()
+}
 
 /// Prepare proof of messages for the `receive_messages_proof` call.
 ///
@@ -51,6 +85,7 @@ use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, TrieMut};
 /// function.
 pub fn prepare_message_proof_from_grandpa_chain<R, FI, B>(
 	params: MessageProofParams,
+	message_destination: InteriorMultiLocation,
 ) -> (FromBridgedChainMessagesProof<HashOf<BridgedChain<B>>>, Weight)
 where
 	R: pallet_bridge_grandpa::Config<FI, BridgedChain = UnderlyingChainOf<BridgedChain<B>>>,
@@ -61,12 +96,9 @@ where
 	let (state_root, storage_proof) = prepare_messages_storage_proof::<B>(
 		params.lane,
 		params.message_nonces.clone(),
-		params.outbound_lane_data,
+		params.outbound_lane_data.clone(),
 		params.size,
-		match params.size {
-			StorageProofSize::Minimal(ref size) => vec![0u8; *size as _],
-			_ => vec![],
-		},
+		prepare_inbound_message(&params, message_destination),
 		encode_all_messages,
 		encode_lane_data,
 	);
@@ -82,7 +114,7 @@ where
 			nonces_start: *params.message_nonces.start(),
 			nonces_end: *params.message_nonces.end(),
 		},
-		Weight::zero(),
+		Weight::MAX / 1000,
 	)
 }
 
@@ -96,6 +128,7 @@ where
 /// `prepare_message_proof_from_grandpa_chain` function.
 pub fn prepare_message_proof_from_parachain<R, PI, B>(
 	params: MessageProofParams,
+	message_destination: InteriorMultiLocation,
 ) -> (FromBridgedChainMessagesProof<HashOf<BridgedChain<B>>>, Weight)
 where
 	R: pallet_bridge_parachains::Config<PI>,
@@ -107,12 +140,9 @@ where
 	let (state_root, storage_proof) = prepare_messages_storage_proof::<B>(
 		params.lane,
 		params.message_nonces.clone(),
-		params.outbound_lane_data,
+		params.outbound_lane_data.clone(),
 		params.size,
-		match params.size {
-			StorageProofSize::Minimal(ref size) => vec![0u8; *size as _],
-			_ => vec![],
-		},
+		prepare_inbound_message(&params, message_destination),
 		encode_all_messages,
 		encode_lane_data,
 	);
@@ -129,7 +159,7 @@ where
 			nonces_start: *params.message_nonces.start(),
 			nonces_end: *params.message_nonces.end(),
 		},
-		Weight::zero(),
+		Weight::MAX / 1000,
 	)
 }
 

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

@@ -28,8 +28,10 @@ use bp_messages::{
 };
 use bp_runtime::{messages::MessageDispatchResult, AccountIdOf, Chain};
 use codec::{Decode, Encode};
-use frame_support::{dispatch::Weight, traits::Get, CloneNoBound, EqNoBound, PartialEqNoBound};
+use frame_support::{dispatch::Weight, CloneNoBound, EqNoBound, PartialEqNoBound};
+use pallet_bridge_messages::WeightInfoExt as MessagesPalletWeights;
 use scale_info::TypeInfo;
+use sp_runtime::SaturatedConversion;
 use xcm_builder::{DispatchBlob, DispatchBlobError, HaulBlob, HaulBlobError};
 
 /// Plain "XCM" payload, which we transfer through bridge
@@ -44,38 +46,36 @@ pub enum XcmBlobMessageDispatchResult {
 }
 
 /// [`XcmBlobMessageDispatch`] is responsible for dispatching received messages
-pub struct XcmBlobMessageDispatch<
-	SourceBridgeHubChain,
-	TargetBridgeHubChain,
-	DispatchBlob,
-	DispatchBlobWeigher,
-> {
+pub struct XcmBlobMessageDispatch<SourceBridgeHubChain, TargetBridgeHubChain, DispatchBlob, Weights>
+{
 	_marker: sp_std::marker::PhantomData<(
 		SourceBridgeHubChain,
 		TargetBridgeHubChain,
 		DispatchBlob,
-		DispatchBlobWeigher,
+		Weights,
 	)>,
 }
 
 impl<
+		'a,
 		SourceBridgeHubChain: Chain,
 		TargetBridgeHubChain: Chain,
 		BlobDispatcher: DispatchBlob,
-		DispatchBlobWeigher: Get<Weight>,
+		Weights: MessagesPalletWeights,
 	> MessageDispatch<AccountIdOf<SourceBridgeHubChain>>
-	for XcmBlobMessageDispatch<
-		SourceBridgeHubChain,
-		TargetBridgeHubChain,
-		BlobDispatcher,
-		DispatchBlobWeigher,
-	>
+	for XcmBlobMessageDispatch<SourceBridgeHubChain, TargetBridgeHubChain, BlobDispatcher, Weights>
 {
 	type DispatchPayload = XcmAsPlainPayload;
 	type DispatchLevelResult = XcmBlobMessageDispatchResult;
 
-	fn dispatch_weight(_message: &mut DispatchMessage<Self::DispatchPayload>) -> Weight {
-		DispatchBlobWeigher::get()
+	fn dispatch_weight(message: &mut DispatchMessage<Self::DispatchPayload>) -> Weight {
+		match message.data.payload {
+			Ok(ref payload) => {
+				let payload_size = payload.encoded_size().saturated_into();
+				Weights::message_dispatch_weight(payload_size)
+			},
+			Err(_) => Weight::zero(),
+		}
 	}
 
 	fn dispatch(
@@ -92,7 +92,6 @@ impl<
 					message.key.nonce
 				);
 				return MessageDispatchResult {
-					// TODO:check-parameter - setup uspent_weight? https://github.com/paritytech/polkadot/issues/6629
 					unspent_weight: Weight::zero(),
 					dispatch_level_result: XcmBlobMessageDispatchResult::InvalidPayload,
 				}
@@ -128,11 +127,7 @@ impl<
 				XcmBlobMessageDispatchResult::NotDispatched(e)
 			},
 		};
-		MessageDispatchResult {
-			// TODO:check-parameter - setup uspent_weight?  https://github.com/paritytech/polkadot/issues/6629
-			unspent_weight: Weight::zero(),
-			dispatch_level_result,
-		}
+		MessageDispatchResult { unspent_weight: Weight::zero(), dispatch_level_result }
 	}
 }
 
@@ -159,23 +154,24 @@ impl<HaulerOrigin, H: XcmBlobHauler<MessageSenderOrigin = HaulerOrigin>> HaulBlo
 {
 	fn haul_blob(blob: sp_std::prelude::Vec<u8>) -> Result<(), HaulBlobError> {
 		let lane = H::xcm_lane();
-		let result = H::MessageSender::send_message(H::message_sender_origin(), lane, blob);
-		let result = result
-			.map(|artifacts| (lane, artifacts.nonce).using_encoded(sp_io::hashing::blake2_256));
-		match &result {
-			Ok(result) => log::info!(
-				target: crate::LOG_TARGET_BRIDGE_DISPATCH,
-				"haul_blob result - ok: {:?} on lane: {:?}",
-				result,
-				lane
-			),
-			Err(error) => log::error!(
-				target: crate::LOG_TARGET_BRIDGE_DISPATCH,
-				"haul_blob result - error: {:?} on lane: {:?}",
-				error,
-				lane
-			),
-		};
-		result.map(|_| ()).map_err(|_| HaulBlobError::Transport("MessageSenderError"))
+		H::MessageSender::send_message(H::message_sender_origin(), lane, blob)
+			.map(|artifacts| (lane, artifacts.nonce).using_encoded(sp_io::hashing::blake2_256))
+			.map(|result| {
+				log::info!(
+					target: crate::LOG_TARGET_BRIDGE_DISPATCH,
+					"haul_blob result - ok: {:?} on lane: {:?}",
+					result,
+					lane
+				)
+			})
+			.map_err(|error| {
+				log::error!(
+					target: crate::LOG_TARGET_BRIDGE_DISPATCH,
+					"haul_blob result - error: {:?} on lane: {:?}",
+					error,
+					lane
+				);
+				HaulBlobError::Transport("MessageSenderError")
+			})
 	}
 }