Dry run xcms on bridge hubs to get forwarded xcms across the W<>R bridge

bridges/modules/messages/Cargo.toml

@@ -15,19 +15,23 @@ codec = { workspace = true }
 log = { workspace = true }
 scale-info = { features = ["derive"], workspace = true }
 
-# Bridge dependencies
+# Bridge dependencies.
 bp-header-chain = { workspace = true }
 bp-messages = { workspace = true }
 bp-runtime = { workspace = true }
 
-# Substrate Dependencies
+# Substrate dependencies.
 frame-benchmarking = { optional = true, workspace = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 sp-trie = { optional = true, workspace = true }
 
+# Polkadot dependencies.
+xcm = { workspace = true, package = "staging-xcm" }
+xcm-builder = { workspace = true, package = "staging-xcm-builder" }
+
 [dev-dependencies]
 bp-runtime = { features = ["test-helpers"], workspace = true }
 bp-test-utils = { workspace = true }

bridges/modules/messages/src/lib.rs

@@ -60,9 +60,9 @@ use bp_messages::{
 		DeliveryPayments, DispatchMessage, FromBridgedChainMessagesProof, MessageDispatch,
 		ProvedLaneMessages, ProvedMessages,
 	},
-	ChainWithMessages, DeliveredMessages, InboundLaneData, InboundMessageDetails, MessageKey,
-	MessageNonce, MessagePayload, MessagesOperatingMode, OutboundLaneData, OutboundMessageDetails,
-	UnrewardedRelayersState, VerificationError,
+	ChainWithMessages, DeliveredMessages, InboundLaneData, InboundMessageDetails, LaneState,
+	MessageKey, MessageNonce, MessagePayload, MessagesOperatingMode, OutboundLaneData,
+	OutboundMessageDetails, UnrewardedRelayersState, VerificationError,
 };
 use bp_runtime::{
 	AccountIdOf, BasicOperatingMode, HashOf, OwnedBridgeModule, PreComputedSize, RangeInclusiveExt,
@@ -71,6 +71,8 @@ use bp_runtime::{
 use codec::{Decode, Encode};
 use frame_support::{dispatch::PostDispatchInfo, ensure, fail, traits::Get, DefaultNoBound};
 use sp_std::{marker::PhantomData, prelude::*};
+use xcm::prelude::*;
+use xcm_builder::{BridgeMessage, InspectMessageQueues};
 
 mod call_ext;
 mod inbound_lane;
@@ -666,6 +668,56 @@ pub mod pallet {
 	}
 }
 
+impl<T: Config<I>, I: 'static> InspectMessageQueues for Pallet<T, I> {
+	fn clear_messages() {
+		// Best effort.
+		let _ = OutboundMessages::<T, I>::clear(u32::MAX, None);
+		// Need to reset the lane data because it's checked in some tests
+		// after sending a message.
+		OutboundLanes::<T, I>::translate::<(), _>(|_, _| {
+			Some(OutboundLaneData {
+				oldest_unpruned_nonce: 0,
+				latest_received_nonce: 0,
+				latest_generated_nonce: 0,
+				state: LaneState::Opened,
+			})
+		});
+	}
+
+	fn get_messages() -> Vec<(VersionedLocation, Vec<VersionedXcm<()>>)> {
+		use xcm::prelude::*;
+
+		let mut messages: Vec<(VersionedLocation, VersionedXcm<()>)> =
+			OutboundMessages::<T, I>::iter()
+				.map(|(_key, message)| {
+					let mut data = &message[..];
+					let payload = StoredMessagePayload::<T, I>::decode(&mut data).unwrap();
+					let BridgeMessage { universal_dest, message } =
+						BridgeMessage::decode(&mut &payload[..]).unwrap();
+					let destination_latest: InteriorLocation = universal_dest.try_into().unwrap();
+					let destination: VersionedLocation =
+						Location::new(0, destination_latest).into();
+					(destination, message)
+				})
+				.collect();
+		messages.sort_by(|a, b| a.0.cmp(&b.0));
+
+		let mut result: Vec<(VersionedLocation, Vec<VersionedXcm<()>>)> = Vec::new();
+		for (destination, message) in messages.into_iter() {
+			if let Some((last_destination, vector)) = result.last_mut() {
+				if *last_destination == destination {
+					vector.push(message);
+					continue;
+				}
+			}
+
+			result.push((destination, vec![message]));
+		}
+
+		result
+	}
+}
+
 /// Structure, containing a validated message payload and all the info required
 /// to send it on the bridge.
 #[derive(Debug, PartialEq, Eq)]

cumulus/parachains/integration-tests/emulated/common/src/macros.rs

@@ -406,7 +406,7 @@ macro_rules! test_chain_can_claim_assets {
 
 #[macro_export]
 macro_rules! test_dry_run_transfer_across_pk_bridge {
-	( $sender_asset_hub:ty, $sender_bridge_hub:ty, $destination:expr ) => {
+	( $destination_network_id:ty, $sender_asset_hub:ty, $sender_bridge_hub:ty, $destination:expr, $destination_bridge_hub:expr ) => {
 		$crate::macros::paste::paste! {
 			use frame_support::{dispatch::RawOrigin, traits::fungible};
 			use sp_runtime::AccountId32;
@@ -418,10 +418,13 @@ macro_rules! test_dry_run_transfer_across_pk_bridge {
 			let initial_balance = transfer_amount * 10;
 
 			// Bridge setup.
+			$sender_bridge_hub::fund_para_sovereign($sender_asset_hub::para_id(), 10_000_000_000_000u128);
 			$sender_asset_hub::force_xcm_version($destination, XCM_VERSION);
+			$sender_bridge_hub::force_xcm_version($destination_bridge_hub, XCM_VERSION);
 			open_bridge_between_asset_hub_rococo_and_asset_hub_westend();
 
-			<$sender_asset_hub as TestExt>::execute_with(|| {
+			let mut remote_message = VersionedXcm::from(Xcm::<()>::new());
+			$sender_asset_hub::execute_with(|| {
 				type Runtime = <$sender_asset_hub as Chain>::Runtime;
 				type RuntimeCall = <$sender_asset_hub as Chain>::RuntimeCall;
 				type OriginCaller = <$sender_asset_hub as Chain>::OriginCaller;
@@ -446,7 +449,23 @@ macro_rules! test_dry_run_transfer_across_pk_bridge {
 				// We assert the dry run succeeds and sends only one message to the local bridge hub.
 				assert!(result.execution_result.is_ok());
 				assert_eq!(result.forwarded_xcms.len(), 1);
-				assert_eq!(result.forwarded_xcms[0].0, VersionedLocation::from(Location::new(1, [Parachain($sender_bridge_hub::para_id().into())])));
+				let (destination, messages) = result.forwarded_xcms[0].clone();
+				assert_eq!(destination, VersionedLocation::from(Location::new(1, [Parachain($sender_bridge_hub::para_id().into())])));
+				assert_eq!(messages.len(), 1);
+				remote_message = messages[0].clone();
+			});
+
+			$sender_bridge_hub::execute_with(|| {
+				type Runtime = <$sender_bridge_hub as Chain>::Runtime;
+				type RuntimeCall = <$sender_bridge_hub as Chain>::RuntimeCall;
+				type OriginCaller = <$sender_bridge_hub as Chain>::OriginCaller;
+
+				let xcm_program =
+					VersionedXcm::from(Xcm::<RuntimeCall>::from(remote_message.clone().try_into().unwrap()));
+				let asset_hub_as_seen_by_bridge_hub = $sender_bridge_hub::sibling_location_of($sender_asset_hub::para_id());
+				let result = Runtime::dry_run_xcm(asset_hub_as_seen_by_bridge_hub.clone().into(), xcm_program).unwrap();
+				assert_eq!(result.forwarded_xcms.len(), 1);
+				assert_eq!(result.forwarded_xcms[0].0, VersionedLocation::from(Location::new(0, [GlobalConsensus(NetworkId::$destination_network_id), Parachain($sender_asset_hub::para_id().into())])));
 			});
 		}
 	};

cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/asset_transfers.rs

@@ -538,8 +538,10 @@ fn send_back_wnds_from_penpal_rococo_through_asset_hub_rococo_to_asset_hub_weste
 #[test]
 fn dry_run_transfer_to_westend_sends_xcm_to_bridge_hub() {
 	test_dry_run_transfer_across_pk_bridge!(
+		Westend,
 		AssetHubRococo,
 		BridgeHubRococo,
-		asset_hub_westend_location()
+		asset_hub_westend_location(),
+		bridge_hub_westend_location()
 	);
 }

cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/asset_transfers.rs

@@ -558,8 +558,10 @@ fn send_back_rocs_from_penpal_westend_through_asset_hub_westend_to_asset_hub_roc
 #[test]
 fn dry_run_transfer_to_rococo_sends_xcm_to_bridge_hub() {
 	test_dry_run_transfer_across_pk_bridge!(
+		Rococo,
 		AssetHubWestend,
 		BridgeHubWestend,
-		asset_hub_rococo_location()
+		asset_hub_rococo_location(),
+		bridge_hub_rococo_location()
 	);
 }

cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs

@@ -869,7 +869,7 @@ impl_runtime_apis! {
 		}
 
 		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+			PolkadotXcm::dry_run_xcm::<Runtime, (xcm_config::XcmRouter, BridgeWestendMessages), RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
 		}
 	}
 

cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs

@@ -801,7 +801,7 @@ impl_runtime_apis! {
 		}
 
 		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+			PolkadotXcm::dry_run_xcm::<Runtime, (xcm_config::XcmRouter, BridgeRococoMessages), RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
 		}
 	}
 

polkadot/xcm/pallet-xcm/src/lib.rs

@@ -2559,7 +2559,10 @@ impl<T: Config> Pallet<T> {
 			XcmDryRunApiError::VersionedConversionFailed
 		})?;
 		let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256);
-		frame_system::Pallet::<Runtime>::reset_events(); // To make sure we only record events from current call.
+		// Clear other messages in queues...
+		Router::clear_messages();
+		// ...and reset events to make sure we only record events from current call.
+		frame_system::Pallet::<Runtime>::reset_events();
 		let result = xcm_executor::XcmExecutor::<XcmConfig>::prepare_and_execute(
 			origin_location,
 			xcm,

prdoc/pr_6002.prdoc

@@ -0,0 +1,22 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Dry run xcms on bridge hubs to get forwarded xcms across the W<>R bridge
+
+doc:
+  - audience: Runtime User
+    description: |
+      It's now possible to dry-run XCMs on Bridge Hubs and get the forwarded XCM to the other
+      side of the W<>R bridge.
+
+crates:
+  - name: pallet-bridge-messages
+    bump: patch
+  - name: emulated-integration-tests-common
+    bump: patch
+  - name: bridge-hub-rococo-runtime
+    bump: patch
+  - name: bridge-hub-westend-runtime
+    bump: patch
+  - name: pallet-xcm
+    bump: patch