Improve xcm-simulator

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

@@ -17,7 +17,8 @@
 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]);
@@ -79,12 +80,14 @@ pub fn para_ext(para_id: u32) -> sp_io::TestExternalities {
 
 pub fn relay_ext() -> sp_io::TestExternalities {
 	use relay_chain::{Runtime, System};
+	let para_account_a: relay_chain::AccountId = ParaId::from(1).into_account();
 
 	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_a, INITIAL_BALANCE)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
 
 	let mut ext = sp_io::TestExternalities::new(t);
 	ext.execute_with(|| System::set_block_number(1));
@@ -99,16 +102,23 @@ mod tests {
 	use super::*;
 
 	use codec::Encode;
-	use frame_support::assert_ok;
+	use frame_support::{assert_ok, weights::Weight};
 	use xcm::v0::{
+		prelude::OnlyChild,
 		Junction::{self, Parachain, Parent},
 		MultiAsset::*,
 		MultiLocation::*,
-		NetworkId, OriginKind,
+		NetworkId, Order, OriginKind,
 		Xcm::*,
 	};
 	use xcm_simulator::TestExt;
 
+	// Helper function for forming buy execution message
+	fn buy_execution<C>(debt: Weight) -> Order<C> {
+		use xcm::opaque::v0::prelude::*;
+		Order::BuyExecution { fees: All, weight: 0, debt, halt_on_error: false, xcm: vec![] }
+	}
+
 	#[test]
 	fn dmp() {
 		MockNet::reset();
@@ -190,8 +200,12 @@ mod tests {
 		});
 	}
 
+	/// 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(|| {
@@ -202,6 +216,8 @@ mod tests {
 				vec![ConcreteFungible { id: Null, amount: 123 }],
 				123,
 			));
+			let para_account_a = ParaId::from(1).into_account();
+			assert_eq!(parachain::Balances::free_balance(&para_account_a), INITIAL_BALANCE + 123);
 		});
 
 		ParaA::execute_with(|| {
@@ -212,4 +228,120 @@ mod tests {
 			);
 		});
 	}
+
+	/// Scenario:
+	/// A parachain transfers funds on the relaychain to another parachain's account.
+	///
+	/// Asserts that the parachain accounts are updated as expected.
+	#[test]
+	fn withdraw_and_deposit() {
+		MockNet::reset();
+
+		ParaA::execute_with(|| {
+			let amount = 10;
+			let weight = 3 * relay_chain::BaseXcmWeight::get();
+			let message = WithdrawAsset {
+				assets: vec![ConcreteFungible { id: Null, amount }],
+				effects: vec![
+					buy_execution(weight),
+					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_with(|| {
+			let amount = 10;
+			let para_account_a: relay_chain::AccountId = ParaId::from(1).into_account();
+			assert_eq!(
+				relay_chain::Balances::free_balance(para_account_a),
+				INITIAL_BALANCE - amount
+			);
+			let para_account_b: relay_chain::AccountId = ParaId::from(2).into_account();
+			assert_eq!(relay_chain::Balances::free_balance(para_account_b), 10);
+		});
+	}
+
+	/// 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();
+
+		// First send a message which fails on the relay chain
+		ParaA::execute_with(|| {
+			let amount = 10;
+			let weight = 3 * relay_chain::BaseXcmWeight::get();
+			//let para_account_b: relay_chain::AccountId = ParaId::from(2).into_account();
+			let query_id = 1234;
+			let message = WithdrawAsset {
+				assets: vec![ConcreteFungible { id: Null, amount }],
+				effects: vec![
+					buy_execution(weight),
+					Order::DepositAsset {
+						assets: vec![All],
+						dest: OnlyChild.into(), // invalid destination
+					},
+					// is not triggered becasue the deposit fails
+					Order::QueryHolding { query_id, dest: Parachain(2).into(), assets: vec![All] },
+				],
+			};
+			// Send withdraw and deposit with query holding
+			assert_ok!(ParachainPalletXcm::send_xcm(Null, X1(Parent), message.clone(),));
+		});
+
+		// Check that no transfer was executed and no response message was sent
+		Relay::execute_with(|| {
+			let amount = 10;
+			let para_account_a: relay_chain::AccountId = ParaId::from(1).into_account();
+			// withdraw did execute
+			assert_eq!(
+				relay_chain::Balances::free_balance(para_account_a),
+				INITIAL_BALANCE - amount
+			);
+			// but deposit did not execute
+			let para_account_b: relay_chain::AccountId = ParaId::from(2).into_account();
+			assert_eq!(relay_chain::Balances::free_balance(para_account_b), 0);
+			assert_eq!(relay_chain::sent_xcm(), vec![]);
+		});
+
+		// Now send a message which fully succeeds on the relay chain
+		ParaA::execute_with(|| {
+			let amount = 10;
+			let weight = 3 * relay_chain::BaseXcmWeight::get();
+			let query_id = 1234;
+			let message = WithdrawAsset {
+				assets: vec![ConcreteFungible { id: Null, amount }],
+				effects: vec![
+					buy_execution(weight),
+					Order::DepositAsset {
+						assets: vec![All],
+						dest: Parachain(2).into(), // valid destination
+					},
+					Order::QueryHolding { query_id, dest: Parachain(2).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 and response message was sent
+		Relay::execute_with(|| {
+			let spent = 20;
+			let para_account_a: relay_chain::AccountId = ParaId::from(1).into_account();
+			// withdraw did execute
+			assert_eq!(
+				relay_chain::Balances::free_balance(para_account_a),
+				INITIAL_BALANCE - spent
+			);
+			// and deposit did execute
+			let para_account_b: relay_chain::AccountId = ParaId::from(2).into_account();
+			assert_eq!(relay_chain::Balances::free_balance(para_account_b), 10);
+			assert_eq!(relay_chain::sent_xcm(), vec![]);
+		});
+	}
 }

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

@@ -26,7 +26,11 @@ use sp_runtime::{testing::Header, traits::IdentityLookup, AccountId32};
 
 use polkadot_parachain::primitives::Id as ParaId;
 use polkadot_runtime_parachains::{configuration, origin, shared, ump};
-use xcm::v0::{MultiAsset, MultiLocation, NetworkId};
+use sp_std::cell::RefCell;
+use xcm::{
+	opaque::v0::{Result as XcmResult, SendXcm, Xcm},
+	v0::{MultiAsset, MultiLocation, NetworkId},
+};
 use xcm_builder::{
 	AccountId32Aliases, AllowUnpaidExecutionFrom, ChildParachainAsNative,
 	ChildParachainConvertsVia, ChildSystemParachainAsSuperuser,
@@ -120,6 +124,20 @@ parameter_types! {
 pub type XcmRouter = super::RelayChainXcmRouter;
 pub type Barrier = AllowUnpaidExecutionFrom<All<MultiLocation>>;
 
+thread_local! {
+	pub static SENT_XCM: RefCell<Vec<(MultiLocation, Xcm)>> = RefCell::new(Vec::new());
+}
+pub(crate) fn sent_xcm() -> Vec<(MultiLocation, Xcm)> {
+	SENT_XCM.with(|q| (*q.borrow()).clone())
+}
+pub struct TestSendXcm;
+impl SendXcm for TestSendXcm {
+	fn send_xcm(dest: MultiLocation, msg: Xcm) -> XcmResult {
+		SENT_XCM.with(|q| q.borrow_mut().push((dest, msg)));
+		Ok(())
+	}
+}
+
 pub struct XcmConfig;
 impl Config for XcmConfig {
 	type Call = Call;
@@ -140,7 +158,7 @@ pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, KusamaNe
 impl pallet_xcm::Config for Runtime {
 	type Event = Event;
 	type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
-	type XcmRouter = XcmRouter;
+	type XcmRouter = (XcmRouter, TestSendXcm);
 	// Anyone can execute XCM messages locally...
 	type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
 	type XcmExecuteFilter = ();