use relaychain asset as fee

xtokens/src/lib.rs

@@ -394,6 +394,53 @@ pub mod module {
 
 			Self::do_transfer_multiassets(who, assets.clone(), fee.clone(), dest, dest_weight, true)
 		}
+
+		/// Transfer currency and use relay-chain asset as fee
+		#[pallet::weight(Pallet::<T>::weight_of_transfer(currency_id.clone(), *amount, dest))]
+		#[transactional]
+		pub fn transfer_using_relaychain_as_fee(
+			origin: OriginFor<T>,
+			currency_id: T::CurrencyId,
+			amount: T::Balance,
+			dest: Box<VersionedMultiLocation>,
+			dest_weight: Weight,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let dest: MultiLocation = (*dest).try_into().map_err(|()| Error::<T>::BadVersion)?;
+
+			let location: MultiLocation = T::CurrencyIdConvert::convert(currency_id.clone())
+				.ok_or(Error::<T>::NotCrossChainTransferableCurrency)?;
+			let asset: MultiAsset = (location, amount.into()).into();
+
+			let fee = MultiAsset {
+				id: AssetId::Concrete(MultiLocation::new(1, Junctions::Here)),
+				fun: Fungibility::Fungible(dest_weight.into()),
+			};
+
+			let mut assets = MultiAssets::new();
+			assets.push(asset.clone());
+			assets.push(fee.clone());
+
+			let (_, dest, reserve, recipient) = Self::transfer_kind(&asset, &dest)?;
+			ensure!(dest == reserve, "Asset should match to destination!");
+			let mut msg = Self::transfer_to_reserve(assets, fee, dest.clone(), recipient, dest_weight)?;
+
+			let origin_location = T::AccountIdToMultiLocation::convert(who.clone());
+			let weight = T::Weigher::weight(&mut msg).map_err(|()| Error::<T>::UnweighableMessage)?;
+			T::XcmExecutor::execute_xcm_in_credit(origin_location, msg, weight, weight)
+				.ensure_complete()
+				.map_err(|error| {
+					log::error!("Failed execute transfer message with {:?}", error);
+					Error::<T>::XcmExecutionFailed
+				})?;
+			Self::deposit_event(Event::<T>::Transferred {
+				sender: who,
+				currency_id,
+				amount,
+				dest,
+			});
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {

xtokens/src/mock/para.rs

@@ -266,7 +266,7 @@ impl Convert<AccountId, MultiLocation> for AccountIdToMultiLocation {
 
 parameter_types! {
 	pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
-	pub const BaseXcmWeight: Weight = 100_000_000;
+	pub const BaseXcmWeight: Weight = 10;
 	pub const MaxAssetsForTransfer: usize = 2;
 }
 

xtokens/src/tests.rs

@@ -1013,6 +1013,49 @@ fn sending_assets_with_different_reserve_should_fail() {
 	});
 }
 
+#[test]
+fn sending_assets_with_relaychain_as_fee() {
+	TestNet::reset();
+
+	ParaA::execute_with(|| {
+		assert_ok!(ParaTokens::deposit(CurrencyId::B, &ALICE, 1_000));
+	});
+
+	ParaB::execute_with(|| {
+		assert_ok!(ParaTokens::deposit(CurrencyId::B, &sibling_a_account(), 1_000));
+		assert_ok!(ParaTokens::deposit(CurrencyId::R, &sibling_a_account(), 1_000));
+	});
+
+	ParaA::execute_with(|| {
+		assert_ok!(ParaXTokens::transfer_using_relaychain_as_fee(
+			Some(ALICE).into(),
+			CurrencyId::B,
+			500,
+			Box::new(
+				(
+					Parent,
+					Parachain(2),
+					Junction::AccountId32 {
+						network: NetworkId::Any,
+						id: BOB.into(),
+					},
+				)
+					.into()
+			),
+			40,
+		));
+
+		assert_eq!(500, ParaTokens::free_balance(CurrencyId::B, &ALICE));
+		assert_eq!(960, ParaTokens::free_balance(CurrencyId::R, &ALICE));
+	});
+
+	ParaB::execute_with(|| {
+		assert_eq!(500, ParaTokens::free_balance(CurrencyId::B, &BOB));
+		assert_eq!(500, ParaTokens::free_balance(CurrencyId::B, &sibling_a_account()));
+		assert_eq!(960, ParaTokens::free_balance(CurrencyId::R, &sibling_a_account()));
+	});
+}
+
 #[test]
 fn specifying_a_non_existent_asset_index_should_fail() {
 	TestNet::reset();