pallet-xcm: add new flexible transfer_assets() call/extrinsic (#2388)

# Motivation (+testing)

### Enable easy `ForeignAssets` transfers using `pallet-xcm` 

We had just previously added capabilities to teleport fees during
reserve-based transfers, but what about reserve-transferring fees when
needing to teleport some non-fee asset?

This PR aligns everything under either explicit reserve-transfer,
explicit teleport, or this new flexible `transfer_assets()` which can
mix and match as needed with fewer artificial constraints imposed to the
user.

This will enable, for example, a (non-system) parachain to teleport
their `ForeignAssets` assets to AssetHub while using DOT to pay fees.
(the assets are teleported - as foreign assets should from their owner
chain - while DOT used for fees can only be reserve-based transferred
between said parachain and AssetHub).

Added `xcm-emulator` tests for this scenario ^.

# Description

Reverts `(limited_)reserve_transfer_assets` to only allow reserve-based
transfers for all `assets` including fees.

Similarly `(limited_)teleport_assets` only allows teleports for all
`assets` including fees.
    
For complex combinations of asset transfers where assets and fees may
have different reserves or different reserve/teleport trust
configurations, users can use the newly added `transfer_assets()`
extrinsic which is more flexible in allowing more complex scenarios.

`assets` (excluding `fees`) must have same reserve location or otherwise
be teleportable to `dest`.
No limitations imposed on `fees`.

- for local reserve: transfer assets to sovereign account of destination
chain and forward a notification XCM to `dest` to mint and deposit
reserve-based assets to `beneficiary`.
- for destination reserve: burn local assets and forward a notification
to `dest` chain to withdraw the reserve assets from this chain's
sovereign account and deposit them to `beneficiary`.
- for remote reserve: burn local assets, forward XCM to reserve chain to
move reserves from this chain's SA to `dest` chain's SA, and forward
another XCM to `dest` to mint and deposit reserve-based assets to
`beneficiary`.
- for teleports: burn local assets and forward XCM to `dest` chain to
mint/teleport assets and deposit them to `beneficiary`.

## Review notes

Only around 500 lines are prod code (see `pallet_xcm/src/lib.rs`), the
rest of the PR is new tests and improving existing tests.

---------

Co-authored-by: command-bot <>

Author: acatangiu

pallet-xcm/src/benchmarking.rs

@@ -44,7 +44,7 @@ pub trait Config: crate::Config {
 	///
 	/// Implementation should also make sure `dest` is reachable/connected.
 	///
-	/// If `None`, the benchmarks that depend on this will be skipped.
+	/// If `None`, the benchmarks that depend on this will default to `Weight::MAX`.
 	fn teleportable_asset_and_dest() -> Option<(MultiAsset, MultiLocation)> {
 		None
 	}
@@ -54,10 +54,27 @@ pub trait Config: crate::Config {
 	///
 	/// Implementation should also make sure `dest` is reachable/connected.
 	///
-	/// If `None`, the benchmarks that depend on this will be skipped.
+	/// If `None`, the benchmarks that depend on this will default to `Weight::MAX`.
 	fn reserve_transferable_asset_and_dest() -> Option<(MultiAsset, MultiLocation)> {
 		None
 	}
+
+	/// Sets up a complex transfer (usually consisting of a teleport and reserve-based transfer), so
+	/// that runtime can properly benchmark `transfer_assets()` extrinsic. Should return a tuple
+	/// `(MultiAsset, u32, MultiLocation, dyn FnOnce())` representing the assets to transfer, the
+	/// `u32` index of the asset to be used for fees, the destination chain for the transfer, and a
+	/// `verify()` closure to verify the intended transfer side-effects.
+	///
+	/// Implementation should make sure the provided assets can be transacted by the runtime, there
+	/// are enough balances in the involved accounts, and that `dest` is reachable/connected.
+	///
+	/// Used only in benchmarks.
+	///
+	/// If `None`, the benchmarks that depend on this will default to `Weight::MAX`.
+	fn set_up_complex_asset_transfer(
+	) -> Option<(MultiAssets, u32, MultiLocation, Box<dyn FnOnce()>)> {
+		None
+	}
 }
 
 benchmarks! {
@@ -158,6 +175,23 @@ benchmarks! {
 		assert!(pallet_balances::Pallet::<T>::free_balance(&caller) <= balance - transferred_amount);
 	}
 
+	transfer_assets {
+		let (assets, fee_index, destination, verify) = T::set_up_complex_asset_transfer().ok_or(
+			BenchmarkError::Override(BenchmarkResult::from_weight(Weight::MAX)),
+		)?;
+		let caller: T::AccountId = whitelisted_caller();
+		let send_origin = RawOrigin::Signed(caller.clone());
+		let recipient = [0u8; 32];
+		let versioned_dest: VersionedMultiLocation = destination.into();
+		let versioned_beneficiary: VersionedMultiLocation =
+			AccountId32 { network: None, id: recipient.into() }.into();
+		let versioned_assets: VersionedMultiAssets = assets.into();
+	}: _<RuntimeOrigin<T>>(send_origin.into(), Box::new(versioned_dest), Box::new(versioned_beneficiary), Box::new(versioned_assets), 0, WeightLimit::Unlimited)
+	verify {
+		// run provided verification function
+		verify();
+	}
+
 	execute {
 		let execute_origin =
 			T::ExecuteXcmOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
@@ -302,3 +336,36 @@ benchmarks! {
 		crate::mock::Test
 	);
 }
+
+pub mod helpers {
+	use super::*;
+	pub fn native_teleport_as_asset_transfer<T>(
+		native_asset_location: MultiLocation,
+		destination: MultiLocation,
+	) -> Option<(MultiAssets, u32, MultiLocation, Box<dyn FnOnce()>)>
+	where
+		T: Config + pallet_balances::Config,
+		u128: From<<T as pallet_balances::Config>::Balance>,
+	{
+		// Relay/native token can be teleported to/from AH.
+		let amount = T::ExistentialDeposit::get() * 100u32.into();
+		let assets: MultiAssets =
+			MultiAsset { fun: Fungible(amount.into()), id: Concrete(native_asset_location) }.into();
+		let fee_index = 0u32;
+
+		// Give some multiple of transferred amount
+		let balance = amount * 10u32.into();
+		let who = whitelisted_caller();
+		let _ =
+			<pallet_balances::Pallet::<T> as frame_support::traits::Currency<_>>::make_free_balance_be(&who, balance);
+		// verify initial balance
+		assert_eq!(pallet_balances::Pallet::<T>::free_balance(&who), balance);
+
+		// verify transferred successfully
+		let verify = Box::new(move || {
+			// verify balance after transfer, decreased by transferred amount (and delivery fees)
+			assert!(pallet_balances::Pallet::<T>::free_balance(&who) <= balance - amount);
+		});
+		Some((assets, fee_index, destination, verify))
+	}
+}