asset-hub-westend-integration-tests: add more asset transfers tests (#2488)

Just adds more tests.

cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml

@@ -38,4 +38,5 @@ asset-test-utils = { path = "../../../../../runtimes/assets/test-utils" }
 cumulus-pallet-dmp-queue = { default-features = false, path = "../../../../../../pallets/dmp-queue" }
 cumulus-pallet-parachain-system = { default-features = false, path = "../../../../../../pallets/parachain-system" }
 emulated-integration-tests-common = { path = "../../../common", default-features = false}
+penpal-runtime = { path = "../../../../../runtimes/testing/penpal" }
 westend-system-emulated-network ={ path = "../../../networks/westend-system" }

cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/lib.rs

@@ -47,11 +47,12 @@ pub use westend_system_emulated_network::{
 	asset_hub_westend_emulated_chain::{
 		genesis::ED as ASSET_HUB_WESTEND_ED, AssetHubWestendParaPallet as AssetHubWestendPallet,
 	},
-	penpal_emulated_chain::PenpalAParaPallet as PenpalAPallet,
+	penpal_emulated_chain::PenpalBParaPallet as PenpalBPallet,
 	westend_emulated_chain::{genesis::ED as WESTEND_ED, WestendRelayPallet as WestendPallet},
 	AssetHubWestendPara as AssetHubWestend, AssetHubWestendParaReceiver as AssetHubWestendReceiver,
-	AssetHubWestendParaSender as AssetHubWestendSender, PenpalAPara as PenpalA,
-	PenpalAParaReceiver as PenpalAReceiver, PenpalAParaSender as PenpalASender,
+	AssetHubWestendParaSender as AssetHubWestendSender, BridgeHubWestendPara as BridgeHubWestend,
+	BridgeHubWestendParaReceiver as BridgeHubWestendReceiver, PenpalBPara as PenpalB,
+	PenpalBParaReceiver as PenpalBReceiver, PenpalBParaSender as PenpalBSender,
 	WestendRelay as Westend, WestendRelayReceiver as WestendReceiver,
 	WestendRelaySender as WestendSender,
 };
@@ -62,18 +63,20 @@ pub const ASSET_MIN_BALANCE: u128 = 1000;
 pub const ASSETS_PALLET_ID: u8 = 50;
 
 pub type RelayToSystemParaTest = Test<Westend, AssetHubWestend>;
+pub type RelayToParaTest = Test<Westend, PenpalB>;
 pub type SystemParaToRelayTest = Test<AssetHubWestend, Westend>;
-pub type SystemParaToParaTest = Test<AssetHubWestend, PenpalA>;
+pub type SystemParaToParaTest = Test<AssetHubWestend, PenpalB>;
+pub type ParaToSystemParaTest = Test<PenpalB, AssetHubWestend>;
 
 /// Returns a `TestArgs` instance to be used for the Relay Chain across integration tests
-pub fn relay_test_args(amount: Balance) -> TestArgs {
+pub fn relay_test_args(
+	dest: MultiLocation,
+	beneficiary_id: AccountId32,
+	amount: Balance,
+) -> TestArgs {
 	TestArgs {
-		dest: Westend::child_location_of(AssetHubWestend::para_id()),
-		beneficiary: AccountId32Junction {
-			network: None,
-			id: AssetHubWestendReceiver::get().into(),
-		}
-		.into(),
+		dest,
+		beneficiary: AccountId32Junction { network: None, id: beneficiary_id.into() }.into(),
 		amount,
 		assets: (Here, amount).into(),
 		asset_id: None,
@@ -82,13 +85,14 @@ pub fn relay_test_args(amount: Balance) -> TestArgs {
 	}
 }
 
-/// Returns a `TestArgs` instance to be used for the System Parachain across integration tests
-pub fn system_para_test_args(
+/// Returns a `TestArgs` instance to be used by parachains across integration tests
+pub fn para_test_args(
 	dest: MultiLocation,
 	beneficiary_id: AccountId32,
 	amount: Balance,
 	assets: MultiAssets,
 	asset_id: Option<u32>,
+	fee_asset_item: u32,
 ) -> TestArgs {
 	TestArgs {
 		dest,
@@ -96,7 +100,7 @@ pub fn system_para_test_args(
 		amount,
 		assets,
 		asset_id,
-		fee_asset_item: 0,
+		fee_asset_item,
 		weight_limit: WeightLimit::Unlimited,
 	}
 }

cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/reserve_transfer.rs

@@ -14,7 +14,31 @@
 // limitations under the License.
 
 use crate::*;
-use asset_hub_westend_runtime::xcm_config::XcmConfig;
+use asset_hub_westend_runtime::xcm_config::XcmConfig as AssetHubWestendXcmConfig;
+use penpal_runtime::xcm_config::XcmConfig as PenpalWestendXcmConfig;
+use westend_runtime::xcm_config::XcmConfig as WestendXcmConfig;
+
+fn relay_to_para_sender_assertions(t: RelayToParaTest) {
+	type RuntimeEvent = <Westend as Chain>::RuntimeEvent;
+
+	Westend::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(864_610_000, 8_799)));
+
+	assert_expected_events!(
+		Westend,
+		vec![
+			// Amount to reserve transfer is transferred to Parachain's Sovereign account
+			RuntimeEvent::Balances(
+				pallet_balances::Event::Transfer { from, to, amount }
+			) => {
+				from: *from == t.sender.account_id,
+				to: *to == Westend::sovereign_account_id_of(
+					t.args.dest
+				),
+				amount: *amount == t.args.amount,
+			},
+		]
+	);
+}
 
 fn system_para_to_para_sender_assertions(t: SystemParaToParaTest) {
 	type RuntimeEvent = <AssetHubWestend as Chain>::RuntimeEvent;
@@ -42,9 +66,9 @@ fn system_para_to_para_sender_assertions(t: SystemParaToParaTest) {
 }
 
 fn para_receiver_assertions<Test>(_: Test) {
-	type RuntimeEvent = <PenpalA as Chain>::RuntimeEvent;
+	type RuntimeEvent = <PenpalB as Chain>::RuntimeEvent;
 	assert_expected_events!(
-		PenpalA,
+		PenpalB,
 		vec![
 			RuntimeEvent::Balances(pallet_balances::Event::Deposit { .. }) => {},
 			RuntimeEvent::MessageQueue(
@@ -54,7 +78,51 @@ fn para_receiver_assertions<Test>(_: Test) {
 	);
 }
 
-fn system_para_to_para_assets_assertions(t: SystemParaToParaTest) {
+fn para_to_system_para_sender_assertions(t: ParaToSystemParaTest) {
+	type RuntimeEvent = <PenpalB as Chain>::RuntimeEvent;
+
+	PenpalB::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(864_610_000, 8_799)));
+
+	assert_expected_events!(
+		PenpalB,
+		vec![
+			// Amount to reserve transfer is transferred to Parachain's Sovereign account
+			RuntimeEvent::Balances(
+				pallet_balances::Event::Withdraw { who, amount }
+			) => {
+				who: *who == t.sender.account_id,
+				amount: *amount == t.args.amount,
+			},
+		]
+	);
+}
+
+fn para_to_system_para_receiver_assertions(t: ParaToSystemParaTest) {
+	type RuntimeEvent = <AssetHubWestend as Chain>::RuntimeEvent;
+
+	let sov_penpal_on_ahw = AssetHubWestend::sovereign_account_id_of(
+		AssetHubWestend::sibling_location_of(PenpalB::para_id()),
+	);
+
+	assert_expected_events!(
+		AssetHubWestend,
+		vec![
+			// Amount to reserve transfer is transferred to Parachain's Sovereign account
+			RuntimeEvent::Balances(
+				pallet_balances::Event::Withdraw { who, amount }
+			) => {
+				who: *who == sov_penpal_on_ahw.clone().into(),
+				amount: *amount == t.args.amount,
+			},
+			RuntimeEvent::Balances(pallet_balances::Event::Deposit { .. }) => {},
+			RuntimeEvent::MessageQueue(
+				pallet_message_queue::Event::Processed { success: true, .. }
+			) => {},
+		]
+	);
+}
+
+fn system_para_to_para_assets_sender_assertions(t: SystemParaToParaTest) {
 	type RuntimeEvent = <AssetHubWestend as Chain>::RuntimeEvent;
 
 	AssetHubWestend::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(
@@ -80,6 +148,31 @@ fn system_para_to_para_assets_assertions(t: SystemParaToParaTest) {
 	);
 }
 
+fn system_para_to_para_assets_receiver_assertions<Test>(_: Test) {
+	type RuntimeEvent = <PenpalB as Chain>::RuntimeEvent;
+	assert_expected_events!(
+		PenpalB,
+		vec![
+			RuntimeEvent::Balances(pallet_balances::Event::Deposit { .. }) => {},
+			RuntimeEvent::Assets(pallet_assets::Event::Issued { .. }) => {},
+			RuntimeEvent::MessageQueue(
+				pallet_message_queue::Event::Processed { success: true, .. }
+			) => {},
+		]
+	);
+}
+
+fn relay_to_para_limited_reserve_transfer_assets(t: RelayToParaTest) -> DispatchResult {
+	<Westend as WestendPallet>::XcmPallet::limited_reserve_transfer_assets(
+		t.signed_origin,
+		bx!(t.args.dest.into()),
+		bx!(t.args.beneficiary.into()),
+		bx!(t.args.assets.into()),
+		t.args.fee_asset_item,
+		t.args.weight_limit,
+	)
+}
+
 fn system_para_to_para_limited_reserve_transfer_assets(t: SystemParaToParaTest) -> DispatchResult {
 	<AssetHubWestend as AssetHubWestendPallet>::PolkadotXcm::limited_reserve_transfer_assets(
 		t.signed_origin,
@@ -91,6 +184,17 @@ fn system_para_to_para_limited_reserve_transfer_assets(t: SystemParaToParaTest)
 	)
 }
 
+fn para_to_system_para_limited_reserve_transfer_assets(t: ParaToSystemParaTest) -> DispatchResult {
+	<PenpalB as PenpalBPallet>::PolkadotXcm::limited_reserve_transfer_assets(
+		t.signed_origin,
+		bx!(t.args.dest.into()),
+		bx!(t.args.beneficiary.into()),
+		bx!(t.args.assets.into()),
+		t.args.fee_asset_item,
+		t.args.weight_limit,
+	)
+}
+
 /// Reserve Transfers of native asset from Relay Chain to the System Parachain shouldn't work
 #[test]
 fn reserve_transfer_native_asset_from_relay_to_system_para_fails() {
@@ -159,19 +263,62 @@ fn reserve_transfer_native_asset_from_system_para_to_relay_fails() {
 	});
 }
 
+/// Reserve Transfers of native asset from Relay to Parachain should work
+#[test]
+fn reserve_transfer_native_asset_from_relay_to_para() {
+	// Init values for Relay
+	let destination = Westend::child_location_of(PenpalB::para_id());
+	let beneficiary_id = PenpalBReceiver::get();
+	let amount_to_send: Balance = WESTEND_ED * 1000;
+
+	let test_args = TestContext {
+		sender: WestendSender::get(),
+		receiver: PenpalBReceiver::get(),
+		args: relay_test_args(destination, beneficiary_id, amount_to_send),
+	};
+
+	let mut test = RelayToParaTest::new(test_args);
+
+	let sender_balance_before = test.sender.balance;
+	let receiver_balance_before = test.receiver.balance;
+
+	test.set_assertion::<Westend>(relay_to_para_sender_assertions);
+	test.set_assertion::<PenpalB>(para_receiver_assertions);
+	test.set_dispatchable::<Westend>(relay_to_para_limited_reserve_transfer_assets);
+	test.assert();
+
+	let delivery_fees = Westend::execute_with(|| {
+		xcm_helpers::transfer_assets_delivery_fees::<
+			<WestendXcmConfig as xcm_executor::Config>::XcmSender,
+		>(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest)
+	});
+
+	let sender_balance_after = test.sender.balance;
+	let receiver_balance_after = test.receiver.balance;
+
+	// Sender's balance is reduced
+	assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after);
+	// Receiver's balance is increased
+	assert!(receiver_balance_after > receiver_balance_before);
+	// Receiver's balance increased by `amount_to_send - delivery_fees - bought_execution`;
+	// `delivery_fees` might be paid from transfer or JIT, also `bought_execution` is unknown but
+	// should be non-zero
+	assert!(receiver_balance_after < receiver_balance_before + amount_to_send);
+}
+
 /// Reserve Transfers of native asset from System Parachain to Parachain should work
 #[test]
 fn reserve_transfer_native_asset_from_system_para_to_para() {
 	// Init values for System Parachain
-	let destination = AssetHubWestend::sibling_location_of(PenpalA::para_id());
-	let beneficiary_id = PenpalAReceiver::get();
+	let destination = AssetHubWestend::sibling_location_of(PenpalB::para_id());
+	let beneficiary_id = PenpalBReceiver::get();
 	let amount_to_send: Balance = ASSET_HUB_WESTEND_ED * 1000;
 	let assets = (Parent, amount_to_send).into();
 
 	let test_args = TestContext {
 		sender: AssetHubWestendSender::get(),
-		receiver: PenpalAReceiver::get(),
-		args: system_para_test_args(destination, beneficiary_id, amount_to_send, assets, None),
+		receiver: PenpalBReceiver::get(),
+		args: para_test_args(destination, beneficiary_id, amount_to_send, assets, None, 0),
 	};
 
 	let mut test = SystemParaToParaTest::new(test_args);
@@ -180,7 +327,7 @@ fn reserve_transfer_native_asset_from_system_para_to_para() {
 	let receiver_balance_before = test.receiver.balance;
 
 	test.set_assertion::<AssetHubWestend>(system_para_to_para_sender_assertions);
-	test.set_assertion::<PenpalA>(para_receiver_assertions);
+	test.set_assertion::<PenpalB>(para_receiver_assertions);
 	test.set_dispatchable::<AssetHubWestend>(system_para_to_para_limited_reserve_transfer_assets);
 	test.assert();
 
@@ -188,53 +335,171 @@ fn reserve_transfer_native_asset_from_system_para_to_para() {
 	let receiver_balance_after = test.receiver.balance;
 
 	let delivery_fees = AssetHubWestend::execute_with(|| {
-		xcm_helpers::transfer_assets_delivery_fees::<<XcmConfig as xcm_executor::Config>::XcmSender>(
-			test.args.assets.clone(),
-			0,
-			test.args.weight_limit,
-			test.args.beneficiary,
-			test.args.dest,
-		)
+		xcm_helpers::transfer_assets_delivery_fees::<
+			<AssetHubWestendXcmConfig as xcm_executor::Config>::XcmSender,
+		>(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest)
 	});
 
 	// Sender's balance is reduced
 	assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after);
 	// Receiver's balance is increased
 	assert!(receiver_balance_after > receiver_balance_before);
+	// Receiver's balance increased by `amount_to_send - delivery_fees - bought_execution`;
+	// `delivery_fees` might be paid from transfer or JIT, also `bought_execution` is unknown but
+	// should be non-zero
+	assert!(receiver_balance_after < receiver_balance_before + amount_to_send);
 }
 
-/// Reserve Transfers of a local asset from System Parachain to Parachain should work
+/// Reserve Transfers of native asset from Parachain to System Parachain should work
 #[test]
-fn reserve_transfer_asset_from_system_para_to_para() {
-	// Force create asset from Relay Chain and mint assets for System Parachain's sender account
+fn reserve_transfer_native_asset_from_para_to_system_para() {
+	// Init values for Penpal Parachain
+	let destination = PenpalB::sibling_location_of(AssetHubWestend::para_id());
+	let beneficiary_id = AssetHubWestendReceiver::get();
+	let amount_to_send: Balance = ASSET_HUB_WESTEND_ED * 1000;
+	let assets = (Parent, amount_to_send).into();
+
+	let test_args = TestContext {
+		sender: PenpalBSender::get(),
+		receiver: AssetHubWestendReceiver::get(),
+		args: para_test_args(destination, beneficiary_id, amount_to_send, assets, None, 0),
+	};
+
+	let mut test = ParaToSystemParaTest::new(test_args);
+
+	let sender_balance_before = test.sender.balance;
+	let receiver_balance_before = test.receiver.balance;
+
+	let penpal_location_as_seen_by_ahw = AssetHubWestend::sibling_location_of(PenpalB::para_id());
+	let sov_penpal_on_ahw =
+		AssetHubWestend::sovereign_account_id_of(penpal_location_as_seen_by_ahw);
+
+	// fund the Penpal's SA on AHW with the native tokens held in reserve
+	AssetHubWestend::fund_accounts(vec![(sov_penpal_on_ahw.into(), amount_to_send * 2)]);
+
+	test.set_assertion::<PenpalB>(para_to_system_para_sender_assertions);
+	test.set_assertion::<AssetHubWestend>(para_to_system_para_receiver_assertions);
+	test.set_dispatchable::<PenpalB>(para_to_system_para_limited_reserve_transfer_assets);
+	test.assert();
+
+	let sender_balance_after = test.sender.balance;
+	let receiver_balance_after = test.receiver.balance;
+
+	let delivery_fees = PenpalB::execute_with(|| {
+		xcm_helpers::transfer_assets_delivery_fees::<
+			<PenpalWestendXcmConfig as xcm_executor::Config>::XcmSender,
+		>(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest)
+	});
+
+	// Sender's balance is reduced
+	assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after);
+	// Receiver's balance is increased
+	assert!(receiver_balance_after > receiver_balance_before);
+	// Receiver's balance increased by `amount_to_send - delivery_fees - bought_execution`;
+	// `delivery_fees` might be paid from transfer or JIT, also `bought_execution` is unknown but
+	// should be non-zero
+	assert!(receiver_balance_after < receiver_balance_before + amount_to_send);
+}
+
+/// Reserve Transfers of a local asset and native asset from System Parachain to Parachain should
+/// work
+#[test]
+fn reserve_transfer_assets_from_system_para_to_para() {
+	// Force create asset on AssetHubWestend and PenpalB from Relay Chain
 	AssetHubWestend::force_create_and_mint_asset(
 		ASSET_ID,
 		ASSET_MIN_BALANCE,
 		true,
 		AssetHubWestendSender::get(),
 		Some(Weight::from_parts(1_019_445_000, 200_000)),
-		ASSET_MIN_BALANCE * 1000000,
+		ASSET_MIN_BALANCE * 1_000_000,
+	);
+	PenpalB::force_create_and_mint_asset(
+		ASSET_ID,
+		ASSET_MIN_BALANCE,
+		false,
+		PenpalBSender::get(),
+		None,
+		0,
 	);
 
 	// Init values for System Parachain
-	let destination = AssetHubWestend::sibling_location_of(PenpalA::para_id());
-	let beneficiary_id = PenpalAReceiver::get();
-	let amount_to_send = ASSET_MIN_BALANCE * 1000;
-	let assets =
-		(X2(PalletInstance(ASSETS_PALLET_ID), GeneralIndex(ASSET_ID.into())), amount_to_send)
-			.into();
+	let destination = AssetHubWestend::sibling_location_of(PenpalB::para_id());
+	let beneficiary_id = PenpalBReceiver::get();
+	let fee_amount_to_send = ASSET_HUB_WESTEND_ED * 1000;
+	let asset_amount_to_send = ASSET_MIN_BALANCE * 1000;
+	let assets: MultiAssets = vec![
+		(Parent, fee_amount_to_send).into(),
+		(X2(PalletInstance(ASSETS_PALLET_ID), GeneralIndex(ASSET_ID.into())), asset_amount_to_send)
+			.into(),
+	]
+	.into();
+	let fee_asset_index = assets
+		.inner()
+		.iter()
+		.position(|r| r == &(Parent, fee_amount_to_send).into())
+		.unwrap() as u32;
 
-	let system_para_test_args = TestContext {
+	let para_test_args = TestContext {
 		sender: AssetHubWestendSender::get(),
-		receiver: PenpalAReceiver::get(),
-		args: system_para_test_args(destination, beneficiary_id, amount_to_send, assets, None),
+		receiver: PenpalBReceiver::get(),
+		args: para_test_args(
+			destination,
+			beneficiary_id,
+			asset_amount_to_send,
+			assets,
+			None,
+			fee_asset_index,
+		),
 	};
 
-	let mut system_para_test = SystemParaToParaTest::new(system_para_test_args);
+	let mut test = SystemParaToParaTest::new(para_test_args);
 
-	system_para_test.set_assertion::<AssetHubWestend>(system_para_to_para_assets_assertions);
-	// TODO: Add assertions when Penpal is able to manage assets
-	system_para_test
-		.set_dispatchable::<AssetHubWestend>(system_para_to_para_limited_reserve_transfer_assets);
-	system_para_test.assert();
+	// Create SA-of-Penpal-on-AHW with ED.
+	let penpal_location = AssetHubWestend::sibling_location_of(PenpalB::para_id());
+	let sov_penpal_on_ahw = AssetHubWestend::sovereign_account_id_of(penpal_location);
+	AssetHubWestend::fund_accounts(vec![(sov_penpal_on_ahw.into(), WESTEND_ED)]);
+
+	let sender_balance_before = test.sender.balance;
+	let receiver_balance_before = test.receiver.balance;
+
+	let sender_assets_before = AssetHubWestend::execute_with(|| {
+		type Assets = <AssetHubWestend as AssetHubWestendPallet>::Assets;
+		<Assets as Inspect<_>>::balance(ASSET_ID, &AssetHubWestendSender::get())
+	});
+	let receiver_assets_before = PenpalB::execute_with(|| {
+		type Assets = <PenpalB as PenpalBPallet>::Assets;
+		<Assets as Inspect<_>>::balance(ASSET_ID, &PenpalBReceiver::get())
+	});
+
+	test.set_assertion::<AssetHubWestend>(system_para_to_para_assets_sender_assertions);
+	test.set_assertion::<PenpalB>(system_para_to_para_assets_receiver_assertions);
+	test.set_dispatchable::<AssetHubWestend>(system_para_to_para_limited_reserve_transfer_assets);
+	test.assert();
+
+	let sender_balance_after = test.sender.balance;
+	let receiver_balance_after = test.receiver.balance;
+
+	// Sender's balance is reduced
+	assert!(sender_balance_after < sender_balance_before);
+	// Receiver's balance is increased
+	assert!(receiver_balance_after > receiver_balance_before);
+	// Receiver's balance increased by `amount_to_send - delivery_fees - bought_execution`;
+	// `delivery_fees` might be paid from transfer or JIT, also `bought_execution` is unknown but
+	// should be non-zero
+	assert!(receiver_balance_after < receiver_balance_before + fee_amount_to_send);
+
+	let sender_assets_after = AssetHubWestend::execute_with(|| {
+		type Assets = <AssetHubWestend as AssetHubWestendPallet>::Assets;
+		<Assets as Inspect<_>>::balance(ASSET_ID, &AssetHubWestendSender::get())
+	});
+	let receiver_assets_after = PenpalB::execute_with(|| {
+		type Assets = <PenpalB as PenpalBPallet>::Assets;
+		<Assets as Inspect<_>>::balance(ASSET_ID, &PenpalBReceiver::get())
+	});
+
+	// Sender's balance is reduced by exact amount
+	assert_eq!(sender_assets_before - asset_amount_to_send, sender_assets_after);
+	// Receiver's balance is increased by exact amount
+	assert_eq!(receiver_assets_after, receiver_assets_before + asset_amount_to_send);
 }

cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/send.rs

@@ -33,7 +33,7 @@ fn send_transact_as_superuser_from_relay_to_system_para_works() {
 #[test]
 fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() {
 	let para_sovereign_account = AssetHubWestend::sovereign_account_id_of(
-		AssetHubWestend::sibling_location_of(PenpalA::para_id()),
+		AssetHubWestend::sibling_location_of(PenpalB::para_id()),
 	);
 
 	// Force create and mint assets for Parachain's sovereign account
@@ -60,8 +60,8 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() {
 	let native_asset =
 		(X2(PalletInstance(ASSETS_PALLET_ID), GeneralIndex(ASSET_ID.into())), fee_amount).into();
 
-	let root_origin = <PenpalA as Chain>::RuntimeOrigin::root();
-	let system_para_destination = PenpalA::sibling_location_of(AssetHubWestend::para_id()).into();
+	let root_origin = <PenpalB as Chain>::RuntimeOrigin::root();
+	let system_para_destination = PenpalB::sibling_location_of(AssetHubWestend::para_id()).into();
 	let xcm = xcm_transact_paid_execution(
 		call,
 		origin_kind,
@@ -69,14 +69,14 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() {
 		para_sovereign_account.clone(),
 	);
 
-	PenpalA::execute_with(|| {
-		assert_ok!(<PenpalA as PenpalAPallet>::PolkadotXcm::send(
+	PenpalB::execute_with(|| {
+		assert_ok!(<PenpalB as PenpalBPallet>::PolkadotXcm::send(
 			root_origin,
 			bx!(system_para_destination),
 			bx!(xcm),
 		));
 
-		PenpalA::assert_xcm_pallet_sent();
+		PenpalB::assert_xcm_pallet_sent();
 	});
 
 	AssetHubWestend::execute_with(|| {

cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/swap.rs

@@ -114,7 +114,7 @@ fn swap_locally_on_chain_using_foreign_assets() {
 	let foreign_asset1_at_asset_hub_westend = Box::new(MultiLocation {
 		parents: 1,
 		interior: X3(
-			Parachain(PenpalA::para_id().into()),
+			Parachain(PenpalB::para_id().into()),
 			PalletInstance(ASSETS_PALLET_ID),
 			GeneralIndex(ASSET_ID.into()),
 		),
@@ -125,18 +125,18 @@ fn swap_locally_on_chain_using_foreign_assets() {
 			.into();
 
 	let penpal_location =
-		MultiLocation { parents: 1, interior: X1(Parachain(PenpalA::para_id().into())) };
+		MultiLocation { parents: 1, interior: X1(Parachain(PenpalB::para_id().into())) };
 
 	// 1. Create asset on penpal:
-	PenpalA::execute_with(|| {
-		assert_ok!(<PenpalA as PenpalAPallet>::Assets::create(
-			<PenpalA as Chain>::RuntimeOrigin::signed(PenpalASender::get()),
+	PenpalB::execute_with(|| {
+		assert_ok!(<PenpalB as PenpalBPallet>::Assets::create(
+			<PenpalB as Chain>::RuntimeOrigin::signed(PenpalBSender::get()),
 			ASSET_ID.into(),
-			PenpalASender::get().into(),
+			PenpalBSender::get().into(),
 			1000,
 		));
 
-		assert!(<PenpalA as PenpalAPallet>::Assets::asset_exists(ASSET_ID));
+		assert!(<PenpalB as PenpalBPallet>::Assets::asset_exists(ASSET_ID));
 	});
 
 	// 2. Create foreign asset on asset_hub_westend:
@@ -190,18 +190,18 @@ fn swap_locally_on_chain_using_foreign_assets() {
 	]));
 
 	// Send XCM message from penpal => asset_hub_westend
-	let sudo_penpal_origin = <PenpalA as Chain>::RuntimeOrigin::root();
-	PenpalA::execute_with(|| {
-		assert_ok!(<PenpalA as PenpalAPallet>::PolkadotXcm::send(
+	let sudo_penpal_origin = <PenpalB as Chain>::RuntimeOrigin::root();
+	PenpalB::execute_with(|| {
+		assert_ok!(<PenpalB as PenpalBPallet>::PolkadotXcm::send(
 			sudo_penpal_origin.clone(),
 			bx!(assets_para_destination.clone()),
 			bx!(xcm),
 		));
 
-		type RuntimeEvent = <PenpalA as Chain>::RuntimeEvent;
+		type RuntimeEvent = <PenpalB as Chain>::RuntimeEvent;
 
 		assert_expected_events!(
-			PenpalA,
+			PenpalB,
 			vec![
 				RuntimeEvent::PolkadotXcm(pallet_xcm::Event::Sent { .. }) => {},
 			]

cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/teleport.rs

@@ -157,10 +157,12 @@ fn system_para_teleport_assets(t: SystemParaToRelayTest) -> DispatchResult {
 fn limited_teleport_native_assets_from_relay_to_system_para_works() {
 	// Init values for Relay Chain
 	let amount_to_send: Balance = WESTEND_ED * 1000;
+	let dest = Westend::child_location_of(AssetHubWestend::para_id());
+	let beneficiary = AssetHubWestendReceiver::get();
 	let test_args = TestContext {
 		sender: WestendSender::get(),
-		receiver: AssetHubWestendReceiver::get(),
-		args: relay_test_args(amount_to_send),
+		receiver: beneficiary.clone(),
+		args: relay_test_args(dest, beneficiary, amount_to_send),
 	};
 
 	let mut test = RelayToSystemParaTest::new(test_args);
@@ -204,7 +206,7 @@ fn limited_teleport_native_assets_back_from_system_para_to_relay_works() {
 	let test_args = TestContext {
 		sender: AssetHubWestendSender::get(),
 		receiver: WestendReceiver::get(),
-		args: system_para_test_args(destination, beneficiary_id, amount_to_send, assets, None),
+		args: para_test_args(destination, beneficiary_id, amount_to_send, assets, None, 0),
 	};
 
 	let mut test = SystemParaToRelayTest::new(test_args);
@@ -245,7 +247,7 @@ fn limited_teleport_native_assets_from_system_para_to_relay_fails() {
 	let test_args = TestContext {
 		sender: AssetHubWestendSender::get(),
 		receiver: WestendReceiver::get(),
-		args: system_para_test_args(destination, beneficiary_id, amount_to_send, assets, None),
+		args: para_test_args(destination, beneficiary_id, amount_to_send, assets, None, 0),
 	};
 
 	let mut test = SystemParaToRelayTest::new(test_args);
@@ -278,10 +280,12 @@ fn limited_teleport_native_assets_from_system_para_to_relay_fails() {
 fn teleport_native_assets_from_relay_to_system_para_works() {
 	// Init values for Relay Chain
 	let amount_to_send: Balance = WESTEND_ED * 1000;
+	let dest = Westend::child_location_of(AssetHubWestend::para_id());
+	let beneficiary = AssetHubWestendReceiver::get();
 	let test_args = TestContext {
 		sender: WestendSender::get(),
-		receiver: AssetHubWestendReceiver::get(),
-		args: relay_test_args(amount_to_send),
+		receiver: beneficiary.clone(),
+		args: relay_test_args(dest, beneficiary, amount_to_send),
 	};
 
 	let mut test = RelayToSystemParaTest::new(test_args);
@@ -325,7 +329,7 @@ fn teleport_native_assets_back_from_system_para_to_relay_works() {
 	let test_args = TestContext {
 		sender: AssetHubWestendSender::get(),
 		receiver: WestendReceiver::get(),
-		args: system_para_test_args(destination, beneficiary_id, amount_to_send, assets, None),
+		args: para_test_args(destination, beneficiary_id, amount_to_send, assets, None, 0),
 	};
 
 	let mut test = SystemParaToRelayTest::new(test_args);
@@ -366,7 +370,7 @@ fn teleport_native_assets_from_system_para_to_relay_fails() {
 	let test_args = TestContext {
 		sender: AssetHubWestendSender::get(),
 		receiver: WestendReceiver::get(),
-		args: system_para_test_args(destination, beneficiary_id, amount_to_send, assets, None),
+		args: para_test_args(destination, beneficiary_id, amount_to_send, assets, None, 0),
 	};
 
 	let mut test = SystemParaToRelayTest::new(test_args);
@@ -394,16 +398,15 @@ fn teleport_native_assets_from_system_para_to_relay_fails() {
 	assert_eq!(receiver_balance_after, receiver_balance_before);
 }
 
-// TODO: uncomment when CollectivesWestend and BridgeHubWestend are implemented
-// https://github.com/paritytech/polkadot-sdk/pull/1737 (CollectivesWestend)
-// #[test]
-// fn teleport_to_other_system_parachains_works() {
-// 	let amount = ASSET_HUB_WESTEND_ED * 100;
-// 	let native_asset: VersionedMultiAssets = (Parent, amount).into();
+#[test]
+fn teleport_to_other_system_parachains_works() {
+	let amount = ASSET_HUB_WESTEND_ED * 100;
+	let native_asset: MultiAssets = (Parent, amount).into();
 
-// 	test_parachain_is_trusted_teleporter!(
-// 		AssetHubWestend,                            // Origin
-// 		vec![CollectivesWestend, BridgeHubWestend], // Destinations
-// 		(native_asset, amount)
-// 	);
-// }
+	test_parachain_is_trusted_teleporter!(
+		AssetHubWestend,          // Origin
+		AssetHubWestendXcmConfig, // XCM Configuration
+		vec![BridgeHubWestend],   // Destinations
+		(native_asset, amount)
+	);
+}