XCM ExportMessage benchmark support

runtime/kusama/src/lib.rs

@@ -2079,6 +2079,12 @@ sp_api::impl_runtime_apis! {
 					// Kusama doesn't support asset locking
 					Err(BenchmarkError::Skip)
 				}
+
+				fn export_message_origin_and_destination(
+				) -> Result<(MultiLocation, NetworkId, InteriorMultiLocation), BenchmarkError> {
+					// Kusama doesn't support exporting messages
+					Err(BenchmarkError::Skip)
+				}
 			}
 
 			let whitelist: Vec<TrackedStorageKey> = vec![

runtime/kusama/src/weights/xcm/mod.rs

@@ -243,7 +243,8 @@ impl<RuntimeCall> XcmWeightInfo<RuntimeCall> for KusamaXcmWeight<RuntimeCall> {
 		Weight::MAX
 	}
 	fn export_message(_: &NetworkId, _: &Junctions, _: &Xcm<()>) -> Weight {
-		Weight::MAX // todo fix
+		// Kusama relay should not support export message operations
+		Weight::MAX
 	}
 	fn lock_asset(_: &MultiAsset, _: &MultiLocation) -> Weight {
 		// Kusama does not currently support asset locking operations

runtime/rococo/src/lib.rs

@@ -2087,6 +2087,12 @@ sp_api::impl_runtime_apis! {
 					// Rococo doesn't support asset locking
 					Err(BenchmarkError::Skip)
 				}
+
+				fn export_message_origin_and_destination(
+				) -> Result<(MultiLocation, NetworkId, InteriorMultiLocation), BenchmarkError> {
+					// Rococo doesn't support exporting messages
+					Err(BenchmarkError::Skip)
+				}
 			}
 
 			let whitelist: Vec<TrackedStorageKey> = vec![

runtime/rococo/src/weights/xcm/mod.rs

@@ -243,7 +243,8 @@ impl<RuntimeCall> XcmWeightInfo<RuntimeCall> for RococoXcmWeight<RuntimeCall> {
 		Weight::MAX
 	}
 	fn export_message(_: &NetworkId, _: &Junctions, _: &Xcm<()>) -> Weight {
-		Weight::MAX // todo fix
+		// Rococo relay should not support export message operations
+		Weight::MAX
 	}
 	fn lock_asset(_: &MultiAsset, _: &MultiLocation) -> Weight {
 		// Rococo does not currently support asset locking operations

runtime/westend/src/lib.rs

@@ -1741,8 +1741,8 @@ sp_api::impl_runtime_apis! {
 			impl runtime_parachains::disputes::slashing::benchmarking::Config for Runtime {}
 
 			use xcm::latest::{
-				AssetId::*, Fungibility::*, Junction, Junctions::*, MultiAsset, MultiAssets,
-				MultiLocation, Response,
+				AssetId::*, Fungibility::*, InteriorMultiLocation, Junction, Junctions::*,
+				MultiAsset, MultiAssets, MultiLocation, NetworkId, Response,
 			};
 			use xcm_config::{Westmint, TokenLocation};
 
@@ -1818,6 +1818,12 @@ sp_api::impl_runtime_apis! {
 					// Westend doesn't support asset locking
 					Err(BenchmarkError::Skip)
 				}
+
+				fn export_message_origin_and_destination(
+				) -> Result<(MultiLocation, NetworkId, InteriorMultiLocation), BenchmarkError> {
+					// Westend doesn't support exporting messages
+					Err(BenchmarkError::Skip)
+				}
 			}
 
 			type XcmBalances = pallet_xcm_benchmarks::fungible::Pallet::<Runtime>;

runtime/westend/src/weights/xcm/mod.rs

@@ -246,7 +246,7 @@ impl<RuntimeCall> XcmWeightInfo<RuntimeCall> for WestendXcmWeight<RuntimeCall> {
 		Weight::MAX
 	}
 	fn export_message(_: &NetworkId, _: &Junctions, _: &Xcm<()>) -> Weight {
-		// Westend does not currently support export message operations
+		// Westend relay should not support export message operations
 		Weight::MAX
 	}
 	fn lock_asset(_: &MultiAsset, _: &MultiLocation) -> Weight {

xcm/pallet-xcm-benchmarks/src/generic/benchmarking.rs

@@ -496,6 +496,27 @@ benchmarks! {
 		assert_eq!(executor.origin(), &Some(X1(alias).relative_to(&universal_location)));
 	}
 
+	export_message {
+		let x in 1 .. 1000;
+		// The `inner_xcm` influences `ExportMessage` total weight based on
+		// `inner_xcm.encoded_size()`, so for this benchmark use smallest encoded instruction
+		// to approximate weight per "unit" of encoded size; then actual weight can be estimated
+		// to be `inner_xcm.encoded_size() * benchmarked_unit`.
+		// Use `ClearOrigin` as the small encoded instruction.
+		let inner_xcm = Xcm(vec![ClearOrigin; x as usize]);
+		// Get `origin`, `network` and `destination` from configured runtime.
+		let (origin, network, destination) = T::export_message_origin_and_destination()?;
+		let mut executor = new_executor::<T>(origin);
+		let xcm = Xcm(vec![ExportMessage {
+			network, destination, xcm: inner_xcm,
+		}]);
+	}: {
+		executor.bench_process(xcm)?;
+	} verify {
+		// The execute completing successfully is as good as we can check.
+		// TODO: Potentially add new trait to XcmSender to detect a queued outgoing message. #4426
+	}
+
 	set_fees_mode {
 		let mut executor = new_executor::<T>(Default::default());
 		executor.set_fees_mode(FeesMode { jit_withdraw: false });

xcm/pallet-xcm-benchmarks/src/generic/mock.rs

@@ -186,6 +186,12 @@ impl generic::Config for Test {
 		let assets: MultiAsset = (Concrete(Here.into()), 100).into();
 		Ok((Default::default(), Default::default(), assets))
 	}
+
+	fn export_message_origin_and_destination(
+	) -> Result<(MultiLocation, NetworkId, InteriorMultiLocation), BenchmarkError> {
+		// No MessageExporter in tests
+		Err(BenchmarkError::Skip)
+	}
 }
 
 pub fn new_test_ext() -> sp_io::TestExternalities {

xcm/pallet-xcm-benchmarks/src/generic/mod.rs

@@ -28,7 +28,10 @@ pub mod pallet {
 		dispatch::{Dispatchable, GetDispatchInfo},
 		pallet_prelude::Encode,
 	};
-	use xcm::latest::{Junction, MultiAsset, MultiAssets, MultiLocation, Response};
+	use xcm::latest::{
+		InteriorMultiLocation, Junction, MultiAsset, MultiAssets, MultiLocation, NetworkId,
+		Response,
+	};
 
 	#[pallet::config]
 	pub trait Config<I: 'static = ()>: frame_system::Config + crate::Config {
@@ -71,6 +74,12 @@ pub mod pallet {
 
 		/// Return an unlocker, owner and assets that can be locked and unlocked.
 		fn unlockable_asset() -> Result<(MultiLocation, MultiLocation, MultiAsset), BenchmarkError>;
+
+		/// A `(MultiLocation, NetworkId, InteriorMultiLocation)` we can successfully export message to.
+		///
+		/// If set to `Err`, benchmarks which rely on `export_message` will be skipped.
+		fn export_message_origin_and_destination(
+		) -> Result<(MultiLocation, NetworkId, InteriorMultiLocation), BenchmarkError>;
 	}
 
 	#[pallet::pallet]

xcm/xcm-executor/src/lib.rs

@@ -820,7 +820,7 @@ impl<Config: config::Config> XcmExecutor<Config> {
 				Ok(())
 			},
 			ExportMessage { network, destination, xcm } => {
-				// The actual message send to the bridge for forwarding is prepended with `UniversalOrigin`
+				// The actual message sent to the bridge for forwarding is prepended with `UniversalOrigin`
 				// and `DescendOrigin` in order to ensure that the message is executed with this Origin.
 				//
 				// Prepend the desired message with instructions which effectively rewrite the origin.

xcm/xcm-executor/src/traits/export.rs

@@ -31,7 +31,7 @@ use xcm::latest::prelude::*;
 /// destination must accept the local location to represent that location or the operation will
 /// fail.
 pub trait ExportXcm {
-	/// Intermediate value which connects the two phaases of the export operation.
+	/// Intermediate value which connects the two phases of the export operation.
 	type Ticket;
 
 	/// Check whether the given `message` is deliverable to the given `destination` on `network`,