Specify the currency for the execution fee

pallets/automation-price/src/fees.rs

@@ -101,9 +101,8 @@ where
 
 		let currency_id = T::CurrencyIdConvert::convert(self.schedule_fee_location)
 			.ok_or("IncoveribleMultilocation")?;
-		let currency_id = currency_id.into();
 
-		match T::MultiCurrency::withdraw(currency_id, &self.owner, fee) {
+		match T::MultiCurrency::withdraw(currency_id.into(), &self.owner, fee) {
 			Ok(_) => {
 				TR::take_revenue(MultiAsset {
 					id: AssetId::Concrete(self.schedule_fee_location),
@@ -112,6 +111,7 @@ where
 
 				if self.execution_fee_amount > MultiBalanceOf::<T>::zero() {
 					T::XcmpTransactor::pay_xcm_fee(
+						currency_id,
 						self.owner.clone(),
 						self.execution_fee_amount.saturated_into(),
 					)?;

pallets/automation-price/src/mock.rs

@@ -322,7 +322,11 @@ where
 		Ok(())
 	}
 
-	fn pay_xcm_fee(_: T::AccountId, _: u128) -> Result<(), sp_runtime::DispatchError> {
+	fn pay_xcm_fee(
+		_: CurrencyId,
+		_: T::AccountId,
+		_: u128,
+	) -> Result<(), sp_runtime::DispatchError> {
 		Ok(())
 	}
 }

pallets/automation-time/src/fees.rs

@@ -18,6 +18,7 @@
 /// ! Traits and default implementation for paying execution fees.
 use crate::{AccountOf, Action, ActionOf, Config, Error, MultiBalanceOf, Pallet};
 
+use frame_support::traits::Get;
 use orml_traits::MultiCurrency;
 use pallet_xcmp_handler::{InstructionSequence, XcmpTransactor};
 use sp_runtime::{
@@ -39,11 +40,17 @@ pub trait HandleFees<T: Config> {
 	) -> Result<R, DispatchError>;
 }
 
+#[derive(Clone)]
+pub struct FeePayment<T: Config> {
+	pub asset_location: MultiLocation,
+	pub amount: MultiBalanceOf<T>,
+	pub is_local: bool,
+}
+
 pub struct FeeHandler<T: Config, TR> {
 	owner: T::AccountId,
-	pub schedule_fee_location: MultiLocation,
-	pub schedule_fee_amount: MultiBalanceOf<T>,
-	pub execution_fee_amount: MultiBalanceOf<T>,
+	pub schedule_fee: FeePayment<T>,
+	pub execution_fee: Option<FeePayment<T>>,
 	_phantom_data: PhantomData<TR>,
 }
 
@@ -71,59 +78,110 @@ where
 	T: Config,
 	TR: TakeRevenue,
 {
-	/// Ensure the fee can be paid.
-	fn can_pay_fee(&self) -> Result<(), DispatchError> {
-		let fee = self.schedule_fee_amount.saturating_add(self.execution_fee_amount);
-
-		if fee.is_zero() {
+	fn ensure_can_withdraw(
+		&self,
+		asset_location: MultiLocation,
+		amount: MultiBalanceOf<T>,
+	) -> Result<(), DispatchError> {
+		if amount.is_zero() {
 			return Ok(())
 		}
 
-		// Manually check for ExistenceRequirement since MultiCurrency doesn't currently support it
-		let currency_id = T::CurrencyIdConvert::convert(self.schedule_fee_location)
-			.ok_or("IncoveribleMultilocation")?;
-		let currency_id = currency_id.into();
+		let currency_id = T::CurrencyIdConvert::convert(asset_location)
+			.ok_or("IncoveribleMultilocation")?
+			.into();
 		let free_balance = T::MultiCurrency::free_balance(currency_id, &self.owner);
+		let min_balance = T::MultiCurrency::minimum_balance(currency_id);
 
 		free_balance
-			.checked_sub(&fee)
-			.ok_or(DispatchError::Token(BelowMinimum))?
-			.checked_sub(&T::MultiCurrency::minimum_balance(currency_id))
+			.checked_sub(&amount)
+			.and_then(|balance_minus_fee| balance_minus_fee.checked_sub(&min_balance))
 			.ok_or(DispatchError::Token(BelowMinimum))?;
-		T::MultiCurrency::ensure_can_withdraw(currency_id, &self.owner, fee)?;
+
+		T::MultiCurrency::ensure_can_withdraw(currency_id, &self.owner, amount)?;
+
+		Ok(())
+	}
+
+	/// Ensure the fee can be paid.
+	fn can_pay_fee(&self) -> Result<(), DispatchError> {
+		match &self.execution_fee {
+			Some(exec_fee) if exec_fee.is_local => {
+				// If the locations of schedule_fee and execution_fee are equal,
+				// we need to add the fees to check whether they are sufficient,
+				// otherwise check them separately.
+				let exec_fee_location = exec_fee
+					.asset_location
+					.reanchored(&T::SelfLocation::get(), T::UniversalLocation::get())
+					.map_err(|_| Error::<T>::CannotReanchor)?;
+
+				let schedule_fee_location = self
+					.schedule_fee
+					.asset_location
+					.reanchored(&T::SelfLocation::get(), T::UniversalLocation::get())
+					.map_err(|_| Error::<T>::CannotReanchor)?;
+
+				if exec_fee_location == schedule_fee_location {
+					let fee = self.schedule_fee.amount.saturating_add(exec_fee.amount);
+					Self::ensure_can_withdraw(self, exec_fee.asset_location, fee)?;
+				} else {
+					Self::ensure_can_withdraw(
+						self,
+						self.schedule_fee.asset_location,
+						self.schedule_fee.amount,
+					)?;
+				}
+			},
+			_ => {
+				Self::ensure_can_withdraw(
+					self,
+					self.schedule_fee.asset_location,
+					self.schedule_fee.amount,
+				)?;
+			},
+		}
+
 		Ok(())
 	}
 
 	/// Withdraw the fee.
 	fn withdraw_fee(&self) -> Result<(), DispatchError> {
-		let fee = self.schedule_fee_amount.saturating_add(self.execution_fee_amount);
+		log::debug!(target: "FeeHandler", "FeeHandler::withdraw_fee, self.schedule_fee.asset_location: {:?}, self.schedule_fee.amount: {:?}",
+			self.schedule_fee.asset_location, self.schedule_fee.amount);
+		// Withdraw schedule fee
+		if !self.schedule_fee.amount.is_zero() {
+			let currency_id = T::CurrencyIdConvert::convert(self.schedule_fee.asset_location)
+				.ok_or("InconvertibleMultilocation")?;
 
-		if fee.is_zero() {
-			return Ok(())
-		}
+			T::MultiCurrency::withdraw(currency_id.into(), &self.owner, self.schedule_fee.amount)
+				.map_err(|_| DispatchError::Token(BelowMinimum))?;
 
-		let currency_id = T::CurrencyIdConvert::convert(self.schedule_fee_location)
-			.ok_or("IncoveribleMultilocation")?;
-		let currency_id = currency_id.into();
+			TR::take_revenue(MultiAsset {
+				id: AssetId::Concrete(self.schedule_fee.asset_location),
+				fun: Fungibility::Fungible(self.schedule_fee.amount.saturated_into()),
+			});
+		}
 
-		match T::MultiCurrency::withdraw(currency_id, &self.owner, fee) {
-			Ok(_) => {
-				TR::take_revenue(MultiAsset {
-					id: AssetId::Concrete(self.schedule_fee_location),
-					fun: Fungibility::Fungible(self.schedule_fee_amount.saturated_into()),
-				});
+		// Withdraw execution fee
+		if let Some(execution_fee) = &self.execution_fee {
+			if execution_fee.is_local {
+				log::debug!(target: "FeeHandler", "FeeHandler::withdraw_fee, self.execution_fee.asset_location: {:?}, self.execution_fee.amount: {:?}",
+					execution_fee.asset_location, execution_fee.amount);
+				let currency_id = T::CurrencyIdConvert::convert(execution_fee.asset_location)
+					.ok_or("InconvertibleMultilocation")?;
 
-				if self.execution_fee_amount > MultiBalanceOf::<T>::zero() {
+				let execution_fee_amount = execution_fee.amount;
+				if !execution_fee_amount.is_zero() {
 					T::XcmpTransactor::pay_xcm_fee(
+						currency_id,
 						self.owner.clone(),
-						self.execution_fee_amount.saturated_into(),
+						execution_fee_amount.saturated_into(),
 					)?;
 				}
-
-				Ok(())
-			},
-			Err(_) => Err(DispatchError::Token(BelowMinimum)),
+			}
 		}
+
+		Ok(())
 	}
 
 	/// Builds an instance of the struct
@@ -137,18 +195,32 @@ where
 		let schedule_fee_amount: u128 =
 			Pallet::<T>::calculate_schedule_fee_amount(action, executions)?.saturated_into();
 
-		let execution_fee_amount = match action.clone() {
-			Action::XCMP { execution_fee, instruction_sequence, .. }
-				if instruction_sequence == InstructionSequence::PayThroughSovereignAccount =>
-				execution_fee.amount.saturating_mul(executions.into()).saturated_into(),
-			_ => 0u32.saturated_into(),
+		let schedule_fee = FeePayment {
+			asset_location: schedule_fee_location,
+			amount: schedule_fee_amount.saturated_into(),
+			is_local: true,
+		};
+
+		let execution_fee = match action.clone() {
+			Action::XCMP { execution_fee, instruction_sequence, .. } => {
+				let location = MultiLocation::try_from(execution_fee.asset_location)
+					.map_err(|()| Error::<T>::BadVersion)?;
+				let amount =
+					execution_fee.amount.saturating_mul(executions.into()).saturated_into();
+				Some(FeePayment {
+					asset_location: location,
+					amount,
+					is_local: instruction_sequence ==
+						InstructionSequence::PayThroughSovereignAccount,
+				})
+			},
+			_ => None,
 		};
 
 		Ok(Self {
 			owner: owner.clone(),
-			schedule_fee_location,
-			schedule_fee_amount: schedule_fee_amount.saturated_into(),
-			execution_fee_amount,
+			schedule_fee,
+			execution_fee,
 			_phantom_data: Default::default(),
 		})
 	}