Support different assets for delivery fees

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

@@ -275,6 +275,155 @@ fn transfer_foreign_assets_from_asset_hub_to_para() {
 	assert_eq!(receiver_rocs_after, receiver_rocs_before + foreign_amount_to_send);
 }
 
+// =================================================================================
+// ======= Reserve Transfers - Sufficient Foreign Asset - AssetHub<>Parachain ======
+// =================================================================================
+/// Reserve Transfers of a sufficient foreign asset from System Parachain to Parachain should
+/// work without using any other token.
+#[test]
+fn reserve_transfer_sufficient_foreign_assets_from_system_para_to_para() {
+	use penpal_runtime::xcm_config::ASSET_HUB_ID;
+
+	let destination = AssetHubWestend::sibling_location_of(PenpalA::para_id());
+	let sov_penpal_on_ahr = AssetHubWestend::sovereign_account_id_of(destination.clone());
+	let sender = AssetHubWestendSender::get();
+	let fee_amount_to_send = ASSET_HUB_WESTEND_ED * 100;
+	let asset_amount_to_send = ASSET_HUB_WESTEND_ED * 100;
+	let asset_owner = AssetHubWestendAssetOwner::get();
+	let asset_owner_signer = <AssetHubWestend as Chain>::RuntimeOrigin::signed(asset_owner.clone());
+	let receiver = PenpalAReceiver::get();
+
+	let roc_at_westend_parachains = Location::new(2, GlobalConsensus(NetworkId::Rococo));
+	// Configure destination chain to trust AH as reserve of ROC
+	PenpalA::execute_with(|| {
+		assert_ok!(<PenpalA as Chain>::System::set_storage(
+			<PenpalA as Chain>::RuntimeOrigin::root(),
+			vec![(
+				penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(),
+				roc_at_westend_parachains.encode(),
+			)],
+		));
+	});
+	// Create sufficient asset.
+	PenpalA::force_create_foreign_asset(
+		roc_at_westend_parachains.clone(),
+		PenpalAssetOwner::get(),
+		true, // Mark it as sufficient.
+		10_000_000_000,
+		vec![],
+	);
+	AssetHubWestend::force_create_foreign_asset(
+		roc_at_westend_parachains.clone().try_into().unwrap(),
+		asset_owner,
+		true, // Mark it as sufficient.
+		10_000_000_000,
+		vec![(sender.clone(), ASSET_HUB_WESTEND_ED * 10000)],
+	);
+
+	let assets: Assets = vec![
+		(
+			(Parent, Parent, GlobalConsensus(NetworkId::Rococo)),
+			asset_amount_to_send + fee_amount_to_send,
+		).into(),
+	].into();
+	// Just to be very clear we don't need to send any native asset.
+	assert_eq!(assets.len(), 1);
+	let fee_asset_index = 0;
+
+	// Create SA-of-Penpal-on-AHR with ED.
+	// This ED isn't reflected in any derivative in a PenpalA account.
+	AssetHubWestend::fund_accounts(vec![(sov_penpal_on_ahr.into(), ASSET_HUB_WESTEND_ED)]);
+
+	// We want to make sure the sender doesn't have ANY native asset other than ED, so we can make
+	// sure we are paying delivery fees with the sufficient asset.
+	AssetHubWestend::execute_with(|| {
+		assert_ok!(<AssetHubWestend as AssetHubWestendPallet>::Balances::force_set_balance(
+			<AssetHubWestend as Chain>::RuntimeOrigin::root(),
+			sender.clone().into(),
+			ASSET_HUB_WESTEND_ED,
+		));
+	});
+
+	let para_test_args = TestContext {
+		sender: sender.clone(),
+		receiver: receiver.clone(),
+		args: TestArgs::new_para(
+			destination,
+			receiver.clone(),
+			asset_amount_to_send,
+			assets,
+			None,
+			fee_asset_index,
+		),
+	};
+	let mut test = SystemParaToParaTest::new(para_test_args);
+
+	// Query initial balances.
+	let sender_balance_before = test.sender.balance;
+	let sender_foreign_assets_before = AssetHubWestend::execute_with(|| {
+		type Assets = <AssetHubWestend as AssetHubWestendPallet>::ForeignAssets;
+		<Assets as Inspect<_>>::balance(roc_at_westend_parachains.clone().try_into().unwrap(), &sender)
+	});
+	let receiver_foreign_assets_before = PenpalA::execute_with(|| {
+		type ForeignAssets = <PenpalA as PenpalAPallet>::ForeignAssets;
+		<ForeignAssets as Inspect<_>>::balance(
+			roc_at_westend_parachains.clone(),
+			&receiver,
+		)
+	});
+
+	// Set assertions and dispatchables
+	test.set_assertion::<AssetHubWestend>(system_para_to_para_sender_sufficient_foreign_asset_assertions);
+	test.set_assertion::<PenpalA>(system_para_to_para_receiver_assertions);
+	test.set_dispatchable::<AssetHubWestend>(ah_to_para_transfer_assets);
+	test.assert();
+
+	// Query initial balances.
+	let sender_balance_after = test.sender.balance;
+	let sender_foreign_assets_after = AssetHubWestend::execute_with(|| {
+		type Assets = <AssetHubWestend as AssetHubWestendPallet>::ForeignAssets;
+		<Assets as Inspect<_>>::balance(roc_at_westend_parachains.clone().try_into().unwrap(), &sender)
+	});
+	let receiver_foreign_assets_after = PenpalA::execute_with(|| {
+		type ForeignAssets = <PenpalA as PenpalAPallet>::ForeignAssets;
+		<ForeignAssets as Inspect<_>>::balance(
+			roc_at_westend_parachains.clone(),
+			&receiver,
+		)
+	});
+
+	// The native asset balance is the same. They weren't send or used for fees.
+	assert_eq!(sender_balance_before, sender_balance_after);
+	// The assets have been sent and used for fees.
+	assert!(sender_foreign_assets_after < sender_foreign_assets_before - asset_amount_to_send);
+	assert!(receiver_foreign_assets_after > receiver_foreign_assets_before);
+}
+
+pub fn system_para_to_para_sender_sufficient_foreign_asset_assertions(t: SystemParaToParaTest) {
+	type RuntimeEvent = <AssetHubWestend as Chain>::RuntimeEvent;
+	AssetHubWestend::assert_xcm_pallet_attempted_complete(None);
+
+	let sov_account_of_dest = AssetHubWestend::sovereign_account_id_of(t.args.dest.clone());
+	for (index, asset) in t.args.assets.into_inner().into_iter().enumerate() {
+		let expected_id = asset.id.0.clone().try_into().unwrap();
+		let asset_amount = if let Fungible(a) = asset.fun { Some(a) } else { None }.unwrap();
+		assert_expected_events!(
+			AssetHubWestend,
+			vec![
+				// Amount of foreign asset is transferred to Parachain's sovereign account.
+				RuntimeEvent::ForeignAssets(
+					pallet_assets::Event::Transferred { asset_id, from, to, amount },
+				) => {
+					asset_id: *asset_id == expected_id,
+					from: *from == t.sender.account_id, // Sender is test sender.
+					to: *to == sov_account_of_dest, // Receiver is parachain's sovereign account.
+					amount: *amount == asset_amount, // Asset amount is the one specified in the test.
+				},
+			]
+		);
+	}
+}
+
 /// Reserve Transfers of native asset from Parachain to System Parachain should work
 // ===========================================================================
 // ======= Transfer - Native + Bridged Assets - Parachain->AssetHub ==========
@@ -613,13 +762,16 @@ fn transfer_foreign_assets_from_para_to_para_through_asset_hub() {
 		<ForeignAssets as Inspect<_>>::balance(roc_at_westend_parachains, &receiver)
 	});
 
-	// Sender's balance is reduced by amount sent plus delivery fees
-	assert!(sender_wnds_after < sender_wnds_before - wnd_to_send);
+	// Sender's balance is reduced by amount sent.
+	assert_eq!(sender_wnds_after, sender_wnds_before - wnd_to_send);
 	assert_eq!(sender_rocs_after, sender_rocs_before - roc_to_send);
 	// Sovereign accounts on reserve are changed accordingly
+	let delivery_fees_amount = 31_340_000_000; // TODO: Estimate this.
+	// Delivery fees stay in the sender chain, so the balance of the sender's
+	// sovereign account reflects this.
 	assert_eq!(
 		wnds_in_sender_reserve_on_ah_after,
-		wnds_in_sender_reserve_on_ah_before - wnd_to_send
+		wnds_in_sender_reserve_on_ah_before - wnd_to_send + delivery_fees_amount
 	);
 	assert_eq!(
 		rocs_in_sender_reserve_on_ah_after,
@@ -630,8 +782,9 @@ fn transfer_foreign_assets_from_para_to_para_through_asset_hub() {
 		rocs_in_receiver_reserve_on_ah_after,
 		rocs_in_receiver_reserve_on_ah_before + roc_to_send
 	);
-	// Receiver's balance is increased
+	// Receiver's balance is increased by amount sent minus delivery fees.
 	assert!(receiver_wnds_after > receiver_wnds_before);
+	assert!(receiver_wnds_after < receiver_wnds_before + wnd_to_send);
 	assert_eq!(receiver_rocs_after, receiver_rocs_before + roc_to_send);
 }