Improve xcm-simulator

runtime/parachains/src/ump.rs

@@ -42,15 +42,16 @@ pub use pallet::*;
 /// It is possible that by the time the message is sank the origin parachain was offboarded. It is
 /// up to the implementer to check that if it cares.
 pub trait UmpSink {
-	/// Process an incoming upward message and return the amount of weight it consumed, or `None` if
-	/// it did not begin processing a message since it would otherwise exceed `max_weight`.
+	/// Process an incoming upward message and return the amount of weight it consumed, or
+	/// `Err(message_id, required_weight)` if it did not begin processing a message since it would
+	/// otherwise exceed `max_weight`.
 	///
 	/// See the trait docs for more details.
 	fn process_upward_message(origin: ParaId, msg: &[u8], max_weight: Weight) -> Result<Weight, (MessageId, Weight)>;
 }
 
 /// An implementation of a sink that just swallows the message without consuming any weight. Returns
-/// `Some(0)` indicating that no messages existed for it to process.
+/// `Ok(0)` indicating that no messages existed for it to process.
 impl UmpSink for () {
 	fn process_upward_message(_: ParaId, _: &[u8], _: Weight) -> Result<Weight, (MessageId, Weight)> {
 		Ok(0)

xcm/xcm-simulator/example/src/lib.rs

@@ -17,11 +17,10 @@
 mod parachain;
 mod relay_chain;
 
-use sp_runtime::AccountId32;
+use polkadot_parachain::primitives::Id as ParaId;
+use sp_runtime::{traits::AccountIdConversion, AccountId32};
 use xcm_simulator::{decl_test_network, decl_test_parachain, decl_test_relay_chain};
 
-pub const ALICE: AccountId32 = AccountId32::new([0u8; 32]);
-
 decl_test_parachain! {
 	pub struct ParaA {
 		Runtime = parachain::Runtime,
@@ -58,8 +57,13 @@ decl_test_network! {
 	}
 }
 
+pub const ALICE: AccountId32 = AccountId32::new([0u8; 32]);
 pub const INITIAL_BALANCE: u128 = 1_000_000_000;
 
+pub fn para_account_id(id: u32) -> relay_chain::AccountId {
+	ParaId::from(id).into_account()
+}
+
 pub fn para_ext(para_id: u32) -> sp_io::TestExternalities {
 	use parachain::{MsgQueue, Runtime, System};
 
@@ -81,10 +85,11 @@ pub fn relay_ext() -> sp_io::TestExternalities {
 	use relay_chain::{Runtime, System};
 
 	let mut t = frame_system::GenesisConfig::default().build_storage::<Runtime>().unwrap();
-
-	pallet_balances::GenesisConfig::<Runtime> { balances: vec![(ALICE, INITIAL_BALANCE)] }
-		.assimilate_storage(&mut t)
-		.unwrap();
+	pallet_balances::GenesisConfig::<Runtime> {
+		balances: vec![(ALICE, INITIAL_BALANCE), (para_account_id(1), INITIAL_BALANCE)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
 
 	let mut ext = sp_io::TestExternalities::new(t);
 	ext.execute_with(|| System::set_block_number(1));
@@ -99,24 +104,30 @@ mod tests {
 	use super::*;
 
 	use codec::Encode;
-	use frame_support::assert_ok;
+	use frame_support::{assert_ok, weights::Weight};
 	use xcm::v0::{
 		Junction::{self, Parachain, Parent},
 		MultiAsset::*,
 		MultiLocation::*,
-		NetworkId, OriginKind,
+		NetworkId, Order, OriginKind,
+		Response::Assets,
 		Xcm::*,
 	};
 	use xcm_simulator::TestExt;
 
+	// Helper function for forming buy execution message
+	fn buy_execution<C>(debt: Weight) -> Order<C> {
+		Order::BuyExecution { fees: All, weight: 0, debt, halt_on_error: false, xcm: vec![] }
+	}
+
 	#[test]
 	fn dmp() {
 		MockNet::reset();
 
 		let remark = parachain::Call::System(
 			frame_system::Call::<parachain::Runtime>::remark_with_event(vec![1, 2, 3]),
 		);
-		Relay::execute_with(|| {
+		Relay::execute_and_dispatch_xcm(|| {
 			assert_ok!(RelayChainPalletXcm::send_xcm(
 				Null,
 				X1(Parachain(1)),
@@ -128,7 +139,7 @@ mod tests {
 			));
 		});
 
-		ParaA::execute_with(|| {
+		ParaA::execute_and_dispatch_xcm(|| {
 			use parachain::{Event, System};
 			assert!(System::events()
 				.iter()
@@ -143,7 +154,7 @@ mod tests {
 		let remark = relay_chain::Call::System(
 			frame_system::Call::<relay_chain::Runtime>::remark_with_event(vec![1, 2, 3]),
 		);
-		ParaA::execute_with(|| {
+		ParaA::execute_and_dispatch_xcm(|| {
 			assert_ok!(ParachainPalletXcm::send_xcm(
 				Null,
 				X1(Parent),
@@ -155,7 +166,7 @@ mod tests {
 			));
 		});
 
-		Relay::execute_with(|| {
+		Relay::execute_and_dispatch_xcm(|| {
 			use relay_chain::{Event, System};
 			assert!(System::events()
 				.iter()
@@ -170,7 +181,7 @@ mod tests {
 		let remark = parachain::Call::System(
 			frame_system::Call::<parachain::Runtime>::remark_with_event(vec![1, 2, 3]),
 		);
-		ParaA::execute_with(|| {
+		ParaA::execute_and_dispatch_xcm(|| {
 			assert_ok!(ParachainPalletXcm::send_xcm(
 				Null,
 				X2(Parent, Parachain(2)),
@@ -182,33 +193,148 @@ mod tests {
 			));
 		});
 
-		ParaB::execute_with(|| {
+		ParaB::execute_and_dispatch_xcm(|| {
 			use parachain::{Event, System};
 			assert!(System::events()
 				.iter()
 				.any(|r| matches!(r.event, Event::System(frame_system::Event::Remarked(_, _)))));
 		});
 	}
 
+	/// Scenario:
+	/// A user Alice sends funds from the relaychain to a parachain.
+	///
+	/// Asserts that the correct XCM is sent and the balances are set as expected.
 	#[test]
-	fn reserve_transfer() {
+	fn reserve_transfer_assets() {
 		MockNet::reset();
 
-		Relay::execute_with(|| {
+		let withdraw_amount = 123;
+		let max_weight_for_execution = 10;
+
+		Relay::execute_and_dispatch_xcm(|| {
 			assert_ok!(RelayChainPalletXcm::reserve_transfer_assets(
 				relay_chain::Origin::signed(ALICE),
 				X1(Parachain(1)),
 				X1(Junction::AccountId32 { network: NetworkId::Any, id: ALICE.into() }),
-				vec![ConcreteFungible { id: Null, amount: 123 }],
-				123,
+				vec![ConcreteFungible { id: Null, amount: withdraw_amount }],
+				max_weight_for_execution,
 			));
+			assert_eq!(
+				parachain::Balances::free_balance(&para_account_id(1)),
+				INITIAL_BALANCE + withdraw_amount
+			);
 		});
 
-		ParaA::execute_with(|| {
-			// free execution, full amount received
+		ParaA::execute_and_dispatch_xcm(|| {
+			// Check message received
+			let expected_message = (
+				X1(Parent),
+				ReserveAssetDeposit {
+					assets: vec![ConcreteFungible { id: X1(Parent), amount: withdraw_amount }],
+					effects: vec![
+						buy_execution(max_weight_for_execution),
+						Order::DepositAsset {
+							assets: vec![All],
+							dest: X1(Junction::AccountId32 {
+								network: NetworkId::Any,
+								id: ALICE.into(),
+							}),
+						},
+					],
+				},
+			);
+			assert_eq!(parachain::MsgQueue::received_dmp(), vec![expected_message]);
+			// Check message execution with full amount received
 			assert_eq!(
 				pallet_balances::Pallet::<parachain::Runtime>::free_balance(&ALICE),
-				INITIAL_BALANCE + 123
+				INITIAL_BALANCE + withdraw_amount
+			);
+		});
+	}
+
+	/// Scenario:
+	/// A parachain transfers funds on the relay chain to another parachain account.
+	///
+	/// Asserts that the parachain accounts are updated as expected.
+	#[test]
+	fn withdraw_and_deposit() {
+		MockNet::reset();
+
+		let send_amount = 10;
+		let weight_for_execution = 3 * relay_chain::BaseXcmWeight::get();
+
+		ParaA::execute_and_dispatch_xcm(|| {
+			let message = WithdrawAsset {
+				assets: vec![ConcreteFungible { id: Null, amount: send_amount }],
+				effects: vec![
+					buy_execution(weight_for_execution),
+					Order::DepositAsset { assets: vec![All], dest: Parachain(2).into() },
+				],
+			};
+			// Send withdraw and deposit
+			assert_ok!(ParachainPalletXcm::send_xcm(Null, X1(Parent), message.clone()));
+		});
+
+		Relay::execute_and_dispatch_xcm(|| {
+			assert_eq!(
+				relay_chain::Balances::free_balance(para_account_id(1)),
+				INITIAL_BALANCE - send_amount
+			);
+			assert_eq!(relay_chain::Balances::free_balance(para_account_id(2)), send_amount);
+		});
+	}
+
+	/// Scenario:
+	/// A parachain wants to be notified that a transfer worked correctly.
+	/// It sends a `QueryHolding` after the deposit to get notified on success.
+	///
+	/// Asserts that the balances are updated correctly and the expected XCM is sent.
+	#[test]
+	fn query_holding() {
+		MockNet::reset();
+
+		let send_amount = 10;
+		let weight_for_execution = 3 * relay_chain::BaseXcmWeight::get();
+		let query_id_set = 1234;
+
+		// Send a message which fully succeeds on the relay chain
+		ParaA::execute_and_dispatch_xcm(|| {
+			let message = WithdrawAsset {
+				assets: vec![ConcreteFungible { id: Null, amount: send_amount }],
+				effects: vec![
+					buy_execution(weight_for_execution),
+					Order::DepositAsset { assets: vec![All], dest: Parachain(2).into() },
+					Order::QueryHolding {
+						query_id: query_id_set,
+						dest: Parachain(1).into(),
+						assets: vec![All],
+					},
+				],
+			};
+			// Send withdraw and deposit with query holding
+			assert_ok!(ParachainPalletXcm::send_xcm(Null, X1(Parent), message.clone(),));
+		});
+
+		// Check that transfer was executed
+		Relay::execute_and_dispatch_xcm(|| {
+			// Withdraw executed
+			assert_eq!(
+				relay_chain::Balances::free_balance(para_account_id(1)),
+				INITIAL_BALANCE - send_amount
+			);
+			// Deposit executed
+			assert_eq!(relay_chain::Balances::free_balance(para_account_id(2)), send_amount);
+		});
+
+		// Check that QueryResponse message was received
+		ParaA::execute_and_dispatch_xcm(|| {
+			assert_eq!(
+				parachain::MsgQueue::received_dmp(),
+				vec![(
+					X1(Parent),
+					QueryResponse { query_id: query_id_set, response: Assets(vec![]) }
+				)]
 			);
 		});
 	}

xcm/xcm-simulator/example/src/parachain.rs

@@ -175,6 +175,12 @@ pub mod mock_msg_queue {
 	#[pallet::getter(fn parachain_id)]
 	pub(super) type ParachainId<T: Config> = StorageValue<_, ParaId, ValueQuery>;
 
+	#[pallet::storage]
+	#[pallet::getter(fn received_dmp)]
+	/// A queue of received DMP messages
+	pub(super) type ReceivedDmp<T: Config> =
+		StorageValue<_, Vec<(MultiLocation, Xcm<T::Call>)>, ValueQuery>;
+
 	impl<T: Config> Get<ParaId> for Pallet<T> {
 		fn get() -> ParaId {
 			Self::parachain_id()
@@ -187,7 +193,7 @@ pub mod mock_msg_queue {
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
 		// XCMP
-		/// Some XCM was executed ok.
+		/// Some XCM was executed OK.
 		Success(Option<T::Hash>),
 		/// Some XCM failed.
 		Fail(Option<T::Hash>, XcmError),
@@ -275,7 +281,8 @@ pub mod mock_msg_queue {
 						Self::deposit_event(Event::UnsupportedVersion(id));
 					},
 					Ok(Ok(x)) => {
-						let outcome = T::XcmExecutor::execute_xcm(Parent.into(), x, limit);
+						let outcome = T::XcmExecutor::execute_xcm(Parent.into(), x.clone(), limit);
+						<ReceivedDmp<T>>::mutate(|y| y.push((Parent.into(), x)));
 						Self::deposit_event(Event::ExecutedDownward(id, outcome));
 					},
 				}