impl DelayTaskHooks for Task to process

Author: wangjj9219

asset-registry/src/mock/para.rs

@@ -11,22 +11,17 @@ use frame_support::{
 };
 use frame_system::{EnsureRoot, EnsureSignedBy};
 use orml_traits::{
-	define_combined_task,
 	location::{AbsoluteReserveProvider, RelativeReserveProvider},
-	parameter_type_with_key,
-	task::{DispatchableTask, TaskResult},
-	FixedConversionRateProvider, MultiCurrency,
+	parameter_type_with_key, FixedConversionRateProvider, MultiCurrency,
 };
 use orml_xcm_support::{IsNativeConcrete, MultiCurrencyAdapter, MultiNativeAsset};
-use orml_xtokens::XtokensTask;
 use pallet_xcm::XcmPassthrough;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use polkadot_parachain_primitives::primitives::Sibling;
-use scale_info::TypeInfo;
 use sp_core::Get;
 use sp_runtime::{
 	traits::{AccountIdConversion, Convert, IdentityLookup},
-	AccountId32, DispatchResult, RuntimeDebug,
+	AccountId32,
 };
 use xcm::v4::{prelude::*, Weight};
 use xcm_builder::{
@@ -315,13 +310,6 @@ parameter_type_with_key! {
 	};
 }
 
-define_combined_task! {
-	#[derive(Clone, Encode, Decode, PartialEq, RuntimeDebug, TypeInfo)]
-	pub enum DelayedTasks {
-		Xtokens(XtokensTask<Runtime>),
-	}
-}
-
 impl orml_xtokens::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Balance = Balance;

delay-tasks/Cargo.toml

@@ -26,8 +26,22 @@ orml-xtokens = { path = "../xtokens", version = "0.7.0", default-features = fals
 [dev-dependencies]
 sp-core = { workspace = true, features = ["std"] }
 sp-io = { workspace = true, features = ["std"] }
+pallet-balances = { workspace = true, features = ["std"] }
 pallet-preimage = { workspace = true, features = ["std"] }
 pallet-scheduler = { workspace = true, features = ["std"] }
+orml-tokens = { path = "../tokens", version = "0.7.0", features = ["std"] }
+
+cumulus-pallet-xcm = { workspace = true, features = ["std"] }
+orml-xcm-mock-message-queue = { path = "../xcm-mock-message-queue" }
+orml-xcm = { path = "../xcm" }
+orml-xcm-support = { path = "../xcm-support" }
+pallet-xcm = { workspace = true, features = ["std"] }
+xcm-builder = { workspace = true, features = ["std"] }
+xcm-executor = { workspace = true, features = ["std"] }
+polkadot-parachain-primitives = { workspace = true, features = ["std"] }
+polkadot-runtime-parachains = { workspace = true, features = ["std"] }
+polkadot-runtime-common = { workspace = true, features = ["std"] }
+xcm-simulator = { workspace = true }
 
 [features]
 default = [ "std" ]
@@ -43,6 +57,11 @@ std = [
 	"sp-std/std",
 	"xcm/std",
 ]
+runtime-benchmarks = [
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
 try-runtime = [
 	"frame-support/try-runtime",
 	"frame-system/try-runtime",

delay-tasks/src/lib.rs

@@ -10,7 +10,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::*;
 use orml_traits::{
-	task::{DelayTaskHooks, DelayTasksManager, DispatchableTask, TaskResult},
+	task::{DelayTaskHooks, DelayTasksManager, DispatchableTask},
 	MultiCurrency, NamedMultiReservableCurrency,
 };
 use parity_scale_codec::FullCodec;
@@ -38,7 +38,7 @@ pub struct EnsureDelayed;
 impl<O: Into<Result<DelayedExecuteOrigin, O>> + From<DelayedExecuteOrigin>> EnsureOrigin<O> for EnsureDelayed {
 	type Success = ();
 	fn try_origin(o: O) -> Result<Self::Success, O> {
-		o.into().and_then(|_| Ok(()))
+		o.into().map(|_| ())
 	}
 
 	#[cfg(feature = "runtime-benchmarks")]
@@ -98,6 +98,8 @@ pub mod module {
 		InvalidDelayBlock,
 		InvalidId,
 		FailedToSchedule,
+		AssetIndexNonExistent,
+		AssetConvertFailed,
 	}
 
 	#[pallet::event]
@@ -119,6 +121,10 @@ pub mod module {
 		DelayedTaskCanceled {
 			id: Nonce,
 		},
+		DelayedTaskStuck {
+			id: Nonce,
+			error: DispatchError,
+		},
 	}
 
 	#[pallet::pallet]
@@ -143,12 +149,21 @@ pub mod module {
 		pub fn delayed_execute(origin: OriginFor<T>, id: Nonce) -> DispatchResult {
 			T::DelayOrigin::ensure_origin(origin)?;
 
-			let execute_result = Self::do_delayed_execute(id)?;
+			let (delayed_task, _) = DelayedTasks::<T>::get(id).ok_or(Error::<T>::InvalidId)?;
+
+			// pre delayed execute
+			if let Err(error) = T::DelayTaskHooks::pre_delayed_execute(&delayed_task) {
+				Self::deposit_event(Event::<T>::DelayedTaskStuck { id, error });
+			} else {
+				let execute_result = delayed_task.dispatch(Weight::zero());
+
+				DelayedTasks::<T>::remove(id);
+				Self::deposit_event(Event::<T>::DelayedTaskExecuted {
+					id,
+					result: execute_result.result,
+				});
+			}
 
-			Self::deposit_event(Event::<T>::DelayedTaskExecuted {
-				id,
-				result: execute_result.result,
-			});
 			Ok(())
 		}
 
@@ -171,11 +186,11 @@ pub mod module {
 				};
 				ensure!(new_execute_block > now, Error::<T>::InvalidDelayBlock);
 
-				*execute_block = new_execute_block;
-
 				T::Scheduler::reschedule_named((&DELAY_TASK_ID, id).encode(), DispatchTime::At(new_execute_block))
 					.map_err(|_| Error::<T>::FailedToSchedule)?;
 
+				*execute_block = new_execute_block;
+
 				Self::deposit_event(Event::<T>::DelayedTaskReDelayed {
 					id,
 					execute_block: new_execute_block,
@@ -188,31 +203,26 @@ pub mod module {
 
 		#[pallet::call_index(2)]
 		#[pallet::weight(Weight::zero())]
-		pub fn cancel_delayed_task(origin: OriginFor<T>, id: Nonce) -> DispatchResult {
+		pub fn cancel_delayed_task(origin: OriginFor<T>, id: Nonce, skip_pre_cancel: bool) -> DispatchResult {
 			T::GovernanceOrigin::ensure_origin(origin)?;
 
-			let (task, _) = DelayedTasks::<T>::take(id).ok_or(Error::<T>::InvalidId)?;
+			let (task, execute_block) = DelayedTasks::<T>::take(id).ok_or(Error::<T>::InvalidId)?;
 
-			// pre cancel
-			T::DelayTaskHooks::on_cancel(&task)?;
+			if !skip_pre_cancel {
+				T::DelayTaskHooks::pre_cancel(&task)?;
+			}
 
-			T::Scheduler::cancel_named((&DELAY_TASK_ID, id).encode()).map_err(|_| Error::<T>::FailedToSchedule)?;
+			if frame_system::Pallet::<T>::block_number() < execute_block {
+				// if now < execute_block, need cancel scheduler
+				T::Scheduler::cancel_named((&DELAY_TASK_ID, id).encode()).map_err(|_| Error::<T>::FailedToSchedule)?;
+			}
 
 			Self::deposit_event(Event::<T>::DelayedTaskCanceled { id });
 			Ok(())
 		}
 	}
 
 	impl<T: Config> Pallet<T> {
-		pub(crate) fn do_delayed_execute(id: Nonce) -> sp_std::result::Result<TaskResult, DispatchError> {
-			let (delayed_task, _) = DelayedTasks::<T>::take(id).ok_or(Error::<T>::InvalidId)?;
-
-			// pre delayed dispatch
-			T::DelayTaskHooks::pre_delayed_execute(&delayed_task)?;
-
-			Ok(delayed_task.dispatch(Weight::zero()))
-		}
-
 		/// Retrieves the next delayed task ID from storage, and increment it by
 		/// one.
 		fn get_next_delayed_task_id() -> Result<Nonce, DispatchError> {
@@ -261,29 +271,64 @@ pub mod module {
 	}
 
 	pub struct DelayedXtokensTaskHooks<T>(PhantomData<T>);
-	impl<T: Config + orml_xtokens::Config> DelayTaskHooks<orml_xtokens::XtokensTask<T>> for DelayedXtokensTaskHooks<T> {
+	impl<T: Config + orml_xtokens::Config> DelayTaskHooks<orml_xtokens::XtokensTask<T>> for DelayedXtokensTaskHooks<T>
+	where
+		<T as Config>::Currency: MultiCurrency<
+			T::AccountId,
+			CurrencyId = <T as orml_xtokens::Config>::CurrencyId,
+			Balance = <T as orml_xtokens::Config>::Balance,
+		>,
+	{
 		fn pre_delay(task: &orml_xtokens::XtokensTask<T>) -> DispatchResult {
 			match task {
-				orml_xtokens::XtokensTask::<T>::TransferAssets { who, assets, fee, .. } => {}
+				orml_xtokens::XtokensTask::<T>::TransferAssets { who, assets, .. } => {
+					let asset_len = assets.len();
+					for i in 0..asset_len {
+						let asset = assets.get(i).ok_or(Error::<T>::AssetIndexNonExistent)?;
+						let currency_id: <T::Currency as MultiCurrency<T::AccountId>>::CurrencyId =
+							<T as Config>::CurrencyIdConvert::convert(asset.id.0.clone())
+								.ok_or(Error::<T>::AssetConvertFailed)?;
+						let amount: T::Balance = match asset.fun {
+							Fungibility::Fungible(amount) => {
+								amount.try_into().map_err(|_| Error::<T>::AssetConvertFailed)?
+							}
+							Fungibility::NonFungible(_) => return Err(Error::<T>::AssetConvertFailed.into()),
+						};
+
+						T::Currency::reserve_named(&T::ReserveId::get(), currency_id, who, amount)?;
+					}
+				}
 			}
 
 			Ok(())
 		}
 
 		fn pre_delayed_execute(task: &orml_xtokens::XtokensTask<T>) -> DispatchResult {
 			match task {
-				orml_xtokens::XtokensTask::<T>::TransferAssets { who, assets, fee, .. } => {}
+				orml_xtokens::XtokensTask::<T>::TransferAssets { who, assets, .. } => {
+					let asset_len = assets.len();
+					for i in 0..asset_len {
+						let asset = assets.get(i).ok_or(Error::<T>::AssetIndexNonExistent)?;
+						let currency_id: <T::Currency as MultiCurrency<T::AccountId>>::CurrencyId =
+							<T as Config>::CurrencyIdConvert::convert(asset.id.0.clone())
+								.ok_or(Error::<T>::AssetConvertFailed)?;
+						let amount: T::Balance = match asset.fun {
+							Fungibility::Fungible(amount) => {
+								amount.try_into().map_err(|_| Error::<T>::AssetConvertFailed)?
+							}
+							Fungibility::NonFungible(_) => return Err(Error::<T>::AssetConvertFailed.into()),
+						};
+
+						T::Currency::unreserve_named(&T::ReserveId::get(), currency_id, who, amount);
+					}
+				}
 			}
 
 			Ok(())
 		}
 
-		fn on_cancel(task: &orml_xtokens::XtokensTask<T>) -> DispatchResult {
-			match task {
-				orml_xtokens::XtokensTask::<T>::TransferAssets { who, assets, fee, .. } => {}
-			}
-
-			Ok(())
+		fn pre_cancel(task: &orml_xtokens::XtokensTask<T>) -> DispatchResult {
+			Self::pre_delayed_execute(task)
 		}
 	}
 }