git.delta.rocks / unique-network / refs/commits / e7f57de8c599

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Original license:18// This file is part of Substrate.1920// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.21// SPDX-License-Identifier: Apache-2.02223// Licensed under the Apache License, Version 2.0 (the "License");24// you may not use this file except in compliance with the License.25// You may obtain a copy of the License at26//27// 	http://www.apache.org/licenses/LICENSE-2.028//29// Unless required by applicable law or agreed to in writing, software30// distributed under the License is distributed on an "AS IS" BASIS,31// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.32// See the License for the specific language governing permissions and33// limitations under the License.3435//! # Scheduler36//! A Pallet for scheduling dispatches.37//!38//! - [`Config`]39//! - [`Call`]40//! - [`Pallet`]41//!42//! ## Overview43//!44//! This Pallet exposes capabilities for scheduling dispatches to occur at a45//! specified block number or at a specified period. These scheduled dispatches46//! may be named or anonymous and may be canceled.47//!48//! **NOTE:** The scheduled calls will be dispatched with the default filter49//! for the origin: namely `frame_system::Config::BaseCallFilter` for all origin50//! except root which will get no filter. And not the filter contained in origin51//! use to call `fn schedule`.52//!53//! If a call is scheduled using proxy or whatever mecanism which adds filter,54//! then those filter will not be used when dispatching the schedule call.55//!56//! ## Interface57//!58//! ### Dispatchable Functions59//!60//! * `schedule` - schedule a dispatch, which may be periodic, to occur at a specified block and61//!   with a specified priority.62//! * `cancel` - cancel a scheduled dispatch, specified by block number and index.63//! * `schedule_named` - augments the `schedule` interface with an additional `Vec<u8>` parameter64//!   that can be used for identification.65//! * `cancel_named` - the named complement to the cancel function.6667// Ensure we're `no_std` when compiling for Wasm.68#![cfg_attr(not(feature = "std"), no_std)]6970#[cfg(feature = "runtime-benchmarks")]71mod benchmarking;72#[cfg(test)]73mod mock;74#[cfg(test)]75mod tests;76pub mod weights;7778use codec::{Codec, Decode, Encode, MaxEncodedLen};79use frame_support::{80	dispatch::{81		DispatchError, DispatchResult, Dispatchable, GetDispatchInfo, Parameter, PostDispatchInfo,82	},83	traits::{84		schedule::{self, DispatchTime, LOWEST_PRIORITY},85		EnsureOrigin, Get, IsType, OriginTrait, PrivilegeCmp, StorageVersion, PreimageRecipient,86		ConstU32, UnfilteredDispatchable,87	},88	weights::Weight,89	unsigned::TransactionValidityError,90};9192use frame_system::{self as system};93use scale_info::TypeInfo;94use sp_runtime::{95	traits::{BadOrigin, One, Saturating, Zero, Hash},96	BoundedVec, RuntimeDebug, DispatchErrorWithPostInfo,97};98use sp_core::H160;99use sp_std::{cmp::Ordering, marker::PhantomData, prelude::*};100pub use weights::WeightInfo;101102pub use pallet::*;103104/// Just a simple index for naming period tasks.105pub type PeriodicIndex = u32;106/// The location of a scheduled task that can be used to remove it.107pub type TaskAddress<BlockNumber> = (BlockNumber, u32);108109pub type EncodedCall = BoundedVec<u8, ConstU32<128>>;110111#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]112#[scale_info(skip_type_params(T))]113pub enum ScheduledCall<T: Config> {114	Inline(EncodedCall),115	PreimageLookup { hash: T::Hash, unbounded_len: u32 },116}117118impl<T: Config> ScheduledCall<T> {119	pub fn new(call: <T as Config>::RuntimeCall) -> Result<Self, DispatchError> {120		let encoded = call.encode();121		let len = encoded.len();122123		match EncodedCall::try_from(encoded.clone()) {124			Ok(bounded) => Ok(Self::Inline(bounded)),125			Err(_) => {126				let hash = <T as system::Config>::Hashing::hash_of(&encoded);127				<T as Config>::Preimages::note_preimage(128					encoded129						.try_into()130						.map_err(|_| <Error<T>>::TooBigScheduledCall)?,131				);132133				Ok(Self::PreimageLookup {134					hash,135					unbounded_len: len as u32,136				})137			}138		}139	}140141	/// The maximum length of the lookup that is needed to peek `Self`.142	pub fn lookup_len(&self) -> Option<u32> {143		match self {144			Self::Inline(..) => None,145			Self::PreimageLookup { unbounded_len, .. } => Some(*unbounded_len),146		}147	}148149	/// Returns whether the image will require a lookup to be peeked.150	pub fn lookup_needed(&self) -> bool {151		match self {152			Self::Inline(_) => false,153			Self::PreimageLookup { .. } => true,154		}155	}156157	fn decode(mut data: &[u8]) -> Result<<T as Config>::RuntimeCall, DispatchError> {158		<T as Config>::RuntimeCall::decode(&mut data)159			.map_err(|_| <Error<T>>::ScheduledCallCorrupted.into())160	}161}162163pub trait SchedulerPreimages<T: Config>: PreimageRecipient<T::Hash> {164	fn drop(call: &ScheduledCall<T>);165166	fn peek(167		call: &ScheduledCall<T>,168	) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError>;169170	/// Convert the given scheduled `call` value back into its original instance. If successful,171	/// `drop` any data backing it. This will not break the realisability of independently172	/// created instances of `ScheduledCall` which happen to have identical data.173	fn realize(174		call: &ScheduledCall<T>,175	) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError>;176}177178impl<T: Config, PP: PreimageRecipient<T::Hash>> SchedulerPreimages<T> for PP {179	fn drop(call: &ScheduledCall<T>) {180		match call {181			ScheduledCall::Inline(_) => {}182			ScheduledCall::PreimageLookup { hash, .. } => Self::unrequest_preimage(hash),183		}184	}185186	fn peek(187		call: &ScheduledCall<T>,188	) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError> {189		match call {190			ScheduledCall::Inline(data) => Ok((ScheduledCall::<T>::decode(data)?, None)),191			ScheduledCall::PreimageLookup {192				hash,193				unbounded_len,194			} => {195				let (preimage, len) = Self::get_preimage(hash)196					.ok_or(<Error<T>>::PreimageNotFound)197					.map(|preimage| (preimage, *unbounded_len))?;198199				Ok((ScheduledCall::<T>::decode(preimage.as_slice())?, Some(len)))200			}201		}202	}203204	fn realize(205		call: &ScheduledCall<T>,206	) -> Result<(<T as pallet::Config>::RuntimeCall, Option<u32>), DispatchError> {207		let r = Self::peek(call)?;208		Self::drop(call);209		Ok(r)210	}211}212213pub enum ScheduledEnsureOriginSuccess<AccountId> {214	Root,215	Signed(AccountId),216}217218pub type TaskName = [u8; 32];219220/// Information regarding an item to be executed in the future.221#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]222#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]223pub struct Scheduled<Name, Call, BlockNumber, PalletsOrigin, AccountId> {224	/// The unique identity for this task, if there is one.225	maybe_id: Option<Name>,226227	/// This task's priority.228	priority: schedule::Priority,229230	/// The call to be dispatched.231	call: Call,232233	/// If the call is periodic, then this points to the information concerning that.234	maybe_periodic: Option<schedule::Period<BlockNumber>>,235236	/// The origin with which to dispatch the call.237	origin: PalletsOrigin,238	_phantom: PhantomData<AccountId>,239}240241pub type ScheduledOf<T> = Scheduled<242	TaskName,243	ScheduledCall<T>,244	<T as frame_system::Config>::BlockNumber,245	<T as Config>::PalletsOrigin,246	<T as frame_system::Config>::AccountId,247>;248249#[derive(Encode, Decode, MaxEncodedLen, TypeInfo)]250#[scale_info(skip_type_params(T))]251pub struct BlockAgenda<T: Config> {252	agenda: BoundedVec<Option<ScheduledOf<T>>, T::MaxScheduledPerBlock>,253	free_places: u32,254}255256impl<T: Config> BlockAgenda<T> {257	fn try_push(&mut self, scheduled: ScheduledOf<T>) -> Result<u32, ScheduledOf<T>> {258		if self.free_places == 0 {259			return Err(scheduled);260		}261262		self.free_places = self.free_places.saturating_sub(1);263264		if (self.agenda.len() as u32) < T::MaxScheduledPerBlock::get() {265			// will always succeed due to the above check.266			let _ = self.agenda.try_push(Some(scheduled));267			Ok((self.agenda.len() - 1) as u32)268		} else {269			match self.agenda.iter().position(|i| i.is_none()) {270				Some(hole_index) => {271					self.agenda[hole_index] = Some(scheduled);272					Ok(hole_index as u32)273				}274				None => unreachable!("free_places was greater than 0; qed"),275			}276		}277	}278279	fn set_slot(&mut self, index: u32, slot: Option<ScheduledOf<T>>) {280		self.agenda[index as usize] = slot;281	}282283	fn iter(&self) -> impl Iterator<Item = &'_ Option<ScheduledOf<T>>> + '_ {284		self.agenda.iter()285	}286287	fn get(&self, index: u32) -> Option<&ScheduledOf<T>> {288		match self.agenda.get(index as usize) {289			Some(Some(scheduled)) => Some(scheduled),290			_ => None,291		}292	}293294	fn get_mut(&mut self, index: u32) -> Option<&mut ScheduledOf<T>> {295		match self.agenda.get_mut(index as usize) {296			Some(Some(scheduled)) => Some(scheduled),297			_ => None,298		}299	}300301	fn take(&mut self, index: u32) -> Option<ScheduledOf<T>> {302		let removed = self.agenda.get_mut(index as usize)?.take();303304		if removed.is_some() {305			self.free_places = self.free_places.saturating_add(1);306		}307308		removed309	}310}311312impl<T: Config> Default for BlockAgenda<T> {313	fn default() -> Self {314		let agenda = Default::default();315		let free_places = T::MaxScheduledPerBlock::get();316317		Self {318			agenda,319			free_places,320		}321	}322}323324struct WeightCounter {325	used: Weight,326	limit: Weight,327}328329impl WeightCounter {330	fn check_accrue(&mut self, w: Weight) -> bool {331		let test = self.used.saturating_add(w);332		if test.any_gt(self.limit) {333			false334		} else {335			self.used = test;336			true337		}338	}339340	fn can_accrue(&mut self, w: Weight) -> bool {341		self.used.saturating_add(w).all_lte(self.limit)342	}343}344345pub(crate) trait MarginalWeightInfo: WeightInfo {346	fn service_task(maybe_lookup_len: Option<usize>, named: bool, periodic: bool) -> Weight {347		let base = Self::service_task_base();348		let mut total = match maybe_lookup_len {349			None => base,350			Some(l) => Self::service_task_fetched(l as u32),351		};352		if named {353			total.saturating_accrue(Self::service_task_named().saturating_sub(base));354		}355		if periodic {356			total.saturating_accrue(Self::service_task_periodic().saturating_sub(base));357		}358		total359	}360}361362impl<T: WeightInfo> MarginalWeightInfo for T {}363364#[frame_support::pallet]365pub mod pallet {366	use super::*;367	use frame_support::{dispatch::PostDispatchInfo, pallet_prelude::*};368	use system::pallet_prelude::*;369370	/// The current storage version.371	const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);372373	#[pallet::pallet]374	#[pallet::generate_store(pub(super) trait Store)]375	#[pallet::storage_version(STORAGE_VERSION)]376	pub struct Pallet<T>(_);377378	#[pallet::config]379	pub trait Config: frame_system::Config {380		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;381382		/// The aggregated origin which the dispatch will take.383		type RuntimeOrigin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>384			+ From<Self::PalletsOrigin>385			+ IsType<<Self as system::Config>::RuntimeOrigin>386			+ Clone;387388		/// The caller origin, overarching type of all pallets origins.389		type PalletsOrigin: From<system::RawOrigin<Self::AccountId>>390			+ Codec391			+ Clone392			+ Eq393			+ TypeInfo394			+ MaxEncodedLen;395396		/// The aggregated call type.397		type RuntimeCall: Parameter398			+ Dispatchable<399				RuntimeOrigin = <Self as Config>::RuntimeOrigin,400				PostInfo = PostDispatchInfo,401			> + UnfilteredDispatchable<RuntimeOrigin = <Self as system::Config>::RuntimeOrigin>402			+ GetDispatchInfo403			+ From<system::Call<Self>>;404405		/// The maximum weight that may be scheduled per block for any dispatchables.406		#[pallet::constant]407		type MaximumWeight: Get<Weight>;408409		/// Required origin to schedule or cancel calls.410		type ScheduleOrigin: EnsureOrigin<411			<Self as system::Config>::RuntimeOrigin,412			Success = ScheduledEnsureOriginSuccess<Self::AccountId>,413		>;414415		/// Compare the privileges of origins.416		///417		/// This will be used when canceling a task, to ensure that the origin that tries418		/// to cancel has greater or equal privileges as the origin that created the scheduled task.419		///420		/// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can421		/// be used. This will only check if two given origins are equal.422		type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;423424		/// The maximum number of scheduled calls in the queue for a single block.425		#[pallet::constant]426		type MaxScheduledPerBlock: Get<u32>;427428		/// Weight information for extrinsics in this pallet.429		type WeightInfo: WeightInfo;430431		/// The preimage provider with which we look up call hashes to get the call.432		type Preimages: SchedulerPreimages<Self>;433434		/// The helper type used for custom transaction fee logic.435		type CallExecutor: DispatchCall<Self, H160>;436437		/// Required origin to set/change calls' priority.438		type PrioritySetOrigin: EnsureOrigin<<Self as system::Config>::RuntimeOrigin>;439	}440441	#[pallet::storage]442	pub type IncompleteSince<T: Config> = StorageValue<_, T::BlockNumber>;443444	/// Items to be executed, indexed by the block number that they should be executed on.445	#[pallet::storage]446	pub type Agenda<T: Config> =447		StorageMap<_, Twox64Concat, T::BlockNumber, BlockAgenda<T>, ValueQuery>;448449	/// Lookup from a name to the block number and index of the task.450	#[pallet::storage]451	pub(crate) type Lookup<T: Config> =452		StorageMap<_, Twox64Concat, TaskName, TaskAddress<T::BlockNumber>>;453454	/// Events type.455	#[pallet::event]456	#[pallet::generate_deposit(pub(super) fn deposit_event)]457	pub enum Event<T: Config> {458		/// Scheduled some task.459		Scheduled { when: T::BlockNumber, index: u32 },460		/// Canceled some task.461		Canceled { when: T::BlockNumber, index: u32 },462		/// Dispatched some task.463		Dispatched {464			task: TaskAddress<T::BlockNumber>,465			id: Option<[u8; 32]>,466			result: DispatchResult,467		},468		/// Scheduled task's priority has changed469		PriorityChanged {470			when: T::BlockNumber,471			index: u32,472			priority: schedule::Priority,473		},474		/// The call for the provided hash was not found so the task has been aborted.475		CallUnavailable {476			task: TaskAddress<T::BlockNumber>,477			id: Option<[u8; 32]>,478		},479		/// The given task can never be executed since it is overweight.480		PermanentlyOverweight {481			task: TaskAddress<T::BlockNumber>,482			id: Option<[u8; 32]>,483		},484	}485486	#[pallet::error]487	pub enum Error<T> {488		/// Failed to schedule a call489		FailedToSchedule,490		/// There is no place for a new task in the agenda491		AgendaIsExhausted,492		/// Scheduled call is corrupted493		ScheduledCallCorrupted,494		/// Scheduled call preimage is not found495		PreimageNotFound,496		/// Scheduled call is too big497		TooBigScheduledCall,498		/// Cannot find the scheduled call.499		NotFound,500		/// Given target block number is in the past.501		TargetBlockNumberInPast,502		/// Attempt to use a non-named function on a named task.503		Named,504	}505506	#[pallet::hooks]507	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {508		/// Execute the scheduled calls509		fn on_initialize(now: T::BlockNumber) -> Weight {510			let mut weight_counter = WeightCounter {511				used: Weight::zero(),512				limit: T::MaximumWeight::get(),513			};514			Self::service_agendas(&mut weight_counter, now, u32::max_value());515			weight_counter.used516		}517	}518519	#[pallet::call]520	impl<T: Config> Pallet<T> {521		/// Anonymously schedule a task.522		#[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]523		pub fn schedule(524			origin: OriginFor<T>,525			when: T::BlockNumber,526			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,527			priority: Option<schedule::Priority>,528			call: Box<<T as Config>::RuntimeCall>,529		) -> DispatchResult {530			T::ScheduleOrigin::ensure_origin(origin.clone())?;531532			if priority.is_some() {533				T::PrioritySetOrigin::ensure_origin(origin.clone())?;534			}535536			let origin = <T as Config>::RuntimeOrigin::from(origin);537			Self::do_schedule(538				DispatchTime::At(when),539				maybe_periodic,540				priority.unwrap_or(LOWEST_PRIORITY),541				origin.caller().clone(),542				<ScheduledCall<T>>::new(*call)?,543			)?;544			Ok(())545		}546547		/// Cancel an anonymously scheduled task.548		#[pallet::weight(<T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get()))]549		pub fn cancel(origin: OriginFor<T>, when: T::BlockNumber, index: u32) -> DispatchResult {550			T::ScheduleOrigin::ensure_origin(origin.clone())?;551			let origin = <T as Config>::RuntimeOrigin::from(origin);552			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;553			Ok(())554		}555556		/// Schedule a named task.557		#[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]558		pub fn schedule_named(559			origin: OriginFor<T>,560			id: TaskName,561			when: T::BlockNumber,562			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,563			priority: Option<schedule::Priority>,564			call: Box<<T as Config>::RuntimeCall>,565		) -> DispatchResult {566			T::ScheduleOrigin::ensure_origin(origin.clone())?;567568			if priority.is_some() {569				T::PrioritySetOrigin::ensure_origin(origin.clone())?;570			}571572			let origin = <T as Config>::RuntimeOrigin::from(origin);573			Self::do_schedule_named(574				id,575				DispatchTime::At(when),576				maybe_periodic,577				priority.unwrap_or(LOWEST_PRIORITY),578				origin.caller().clone(),579				<ScheduledCall<T>>::new(*call)?,580			)?;581			Ok(())582		}583584		/// Cancel a named scheduled task.585		#[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]586		pub fn cancel_named(origin: OriginFor<T>, id: TaskName) -> DispatchResult {587			T::ScheduleOrigin::ensure_origin(origin.clone())?;588			let origin = <T as Config>::RuntimeOrigin::from(origin);589			Self::do_cancel_named(Some(origin.caller().clone()), id)?;590			Ok(())591		}592593		/// Anonymously schedule a task after a delay.594		///595		/// # <weight>596		/// Same as [`schedule`].597		/// # </weight>598		#[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]599		pub fn schedule_after(600			origin: OriginFor<T>,601			after: T::BlockNumber,602			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,603			priority: Option<schedule::Priority>,604			call: Box<<T as Config>::RuntimeCall>,605		) -> DispatchResult {606			T::ScheduleOrigin::ensure_origin(origin.clone())?;607608			if priority.is_some() {609				T::PrioritySetOrigin::ensure_origin(origin.clone())?;610			}611612			let origin = <T as Config>::RuntimeOrigin::from(origin);613			Self::do_schedule(614				DispatchTime::After(after),615				maybe_periodic,616				priority.unwrap_or(LOWEST_PRIORITY),617				origin.caller().clone(),618				<ScheduledCall<T>>::new(*call)?,619			)?;620			Ok(())621		}622623		/// Schedule a named task after a delay.624		///625		/// # <weight>626		/// Same as [`schedule_named`](Self::schedule_named).627		/// # </weight>628		#[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]629		pub fn schedule_named_after(630			origin: OriginFor<T>,631			id: TaskName,632			after: T::BlockNumber,633			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,634			priority: Option<schedule::Priority>,635			call: Box<<T as Config>::RuntimeCall>,636		) -> DispatchResult {637			T::ScheduleOrigin::ensure_origin(origin.clone())?;638639			if priority.is_some() {640				T::PrioritySetOrigin::ensure_origin(origin.clone())?;641			}642643			let origin = <T as Config>::RuntimeOrigin::from(origin);644			Self::do_schedule_named(645				id,646				DispatchTime::After(after),647				maybe_periodic,648				priority.unwrap_or(LOWEST_PRIORITY),649				origin.caller().clone(),650				<ScheduledCall<T>>::new(*call)?,651			)?;652			Ok(())653		}654655		#[pallet::weight(<T as Config>::WeightInfo::change_named_priority(T::MaxScheduledPerBlock::get()))]656		pub fn change_named_priority(657			origin: OriginFor<T>,658			id: TaskName,659			priority: schedule::Priority,660		) -> DispatchResult {661			T::PrioritySetOrigin::ensure_origin(origin.clone())?;662			let origin = <T as Config>::RuntimeOrigin::from(origin);663			Self::do_change_named_priority(origin.caller().clone(), id, priority)664		}665	}666}667668impl<T: Config> Pallet<T> {669	fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {670		let now = frame_system::Pallet::<T>::block_number();671672		let when = match when {673			DispatchTime::At(x) => x,674			// The current block has already completed it's scheduled tasks, so675			// Schedule the task at lest one block after this current block.676			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),677		};678679		if when <= now {680			return Err(Error::<T>::TargetBlockNumberInPast.into());681		}682683		Ok(when)684	}685686	fn mandatory_place_task(when: T::BlockNumber, what: ScheduledOf<T>) {687		Self::place_task(when, what, true).expect("mandatory place task always succeeds; qed");688	}689690	fn try_place_task(691		when: T::BlockNumber,692		what: ScheduledOf<T>,693	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {694		Self::place_task(when, what, false)695	}696697	fn place_task(698		mut when: T::BlockNumber,699		what: ScheduledOf<T>,700		is_mandatory: bool,701	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {702		let maybe_name = what.maybe_id;703		let index = Self::push_to_agenda(&mut when, what, is_mandatory)?;704		let address = (when, index);705		if let Some(name) = maybe_name {706			Lookup::<T>::insert(name, address)707		}708		Self::deposit_event(Event::Scheduled {709			when: address.0,710			index: address.1,711		});712		Ok(address)713	}714715	fn push_to_agenda(716		when: &mut T::BlockNumber,717		mut what: ScheduledOf<T>,718		is_mandatory: bool,719	) -> Result<u32, DispatchError> {720		let mut agenda;721722		let index = loop {723			agenda = Agenda::<T>::get(*when);724725			match agenda.try_push(what) {726				Ok(index) => break index,727				Err(returned_what) if is_mandatory => {728					what = returned_what;729					when.saturating_inc();730				}731				Err(_) => return Err(<Error<T>>::AgendaIsExhausted.into()),732			}733		};734735		Agenda::<T>::insert(when, agenda);736		Ok(index)737	}738739	fn do_schedule(740		when: DispatchTime<T::BlockNumber>,741		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,742		priority: schedule::Priority,743		origin: T::PalletsOrigin,744		call: ScheduledCall<T>,745	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {746		let when = Self::resolve_time(when)?;747748		// sanitize maybe_periodic749		let maybe_periodic = maybe_periodic750			.filter(|p| p.1 > 1 && !p.0.is_zero())751			// Remove one from the number of repetitions since we will schedule one now.752			.map(|(p, c)| (p, c - 1));753		let task = Scheduled {754			maybe_id: None,755			priority,756			call,757			maybe_periodic,758			origin,759			_phantom: PhantomData,760		};761		Self::try_place_task(when, task)762	}763764	fn do_cancel(765		origin: Option<T::PalletsOrigin>,766		(when, index): TaskAddress<T::BlockNumber>,767	) -> Result<(), DispatchError> {768		let scheduled = Agenda::<T>::try_mutate(769			when,770			|agenda| -> Result<Option<Scheduled<_, _, _, _, _>>, DispatchError> {771				let scheduled = match agenda.get(index) {772					Some(scheduled) => scheduled,773					None => return Ok(None),774				};775776				if let Some(ref o) = origin {777					if matches!(778						T::OriginPrivilegeCmp::cmp_privilege(o, &scheduled.origin),779						Some(Ordering::Less) | None780					) {781						return Err(BadOrigin.into());782					}783				}784785				Ok(agenda.take(index))786			},787		)?;788		if let Some(s) = scheduled {789			T::Preimages::drop(&s.call);790791			if let Some(id) = s.maybe_id {792				Lookup::<T>::remove(id);793			}794			Self::deposit_event(Event::Canceled { when, index });795			Ok(())796		} else {797			Err(Error::<T>::NotFound.into())798		}799	}800801	fn do_schedule_named(802		id: TaskName,803		when: DispatchTime<T::BlockNumber>,804		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,805		priority: schedule::Priority,806		origin: T::PalletsOrigin,807		call: ScheduledCall<T>,808	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {809		// ensure id it is unique810		if Lookup::<T>::contains_key(&id) {811			return Err(Error::<T>::FailedToSchedule.into());812		}813814		let when = Self::resolve_time(when)?;815816		// sanitize maybe_periodic817		let maybe_periodic = maybe_periodic818			.filter(|p| p.1 > 1 && !p.0.is_zero())819			// Remove one from the number of repetitions since we will schedule one now.820			.map(|(p, c)| (p, c - 1));821822		let task = Scheduled {823			maybe_id: Some(id),824			priority,825			call,826			maybe_periodic,827			origin,828			_phantom: Default::default(),829		};830		Self::try_place_task(when, task)831	}832833	fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: TaskName) -> DispatchResult {834		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {835			if let Some((when, index)) = lookup.take() {836				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {837					let scheduled = match agenda.get(index) {838						Some(scheduled) => scheduled,839						None => return Ok(()),840					};841842					if let Some(ref o) = origin {843						if matches!(844							T::OriginPrivilegeCmp::cmp_privilege(o, &scheduled.origin),845							Some(Ordering::Less) | None846						) {847							return Err(BadOrigin.into());848						}849						T::Preimages::drop(&scheduled.call);850					}851852					agenda.take(index);853854					Ok(())855				})?;856				Self::deposit_event(Event::Canceled { when, index });857				Ok(())858			} else {859				Err(Error::<T>::NotFound.into())860			}861		})862	}863864	fn do_change_named_priority(865		origin: T::PalletsOrigin,866		id: TaskName,867		priority: schedule::Priority,868	) -> DispatchResult {869		match Lookup::<T>::get(id) {870			Some((when, index)) => Agenda::<T>::try_mutate(when, |agenda| {871				let scheduled = match agenda.get_mut(index) {872					Some(scheduled) => scheduled,873					None => return Ok(()),874				};875876				if matches!(877					T::OriginPrivilegeCmp::cmp_privilege(&origin, &scheduled.origin),878					Some(Ordering::Less) | None879				) {880					return Err(BadOrigin.into());881				}882883				scheduled.priority = priority;884				Self::deposit_event(Event::PriorityChanged {885					when,886					index,887					priority,888				});889890				Ok(())891			}),892			None => Err(Error::<T>::NotFound.into()),893		}894	}895}896897enum ServiceTaskError {898	/// Could not be executed due to missing preimage.899	Unavailable,900	/// Could not be executed due to weight limitations.901	Overweight,902}903use ServiceTaskError::*;904905/// A Scheduler-Runtime interface for finer payment handling.906pub trait DispatchCall<T: frame_system::Config + Config, SelfContainedSignedInfo> {907	/// Resolve the call dispatch, including any post-dispatch operations.908	fn dispatch_call(909		signer: Option<T::AccountId>,910		function: <T as Config>::RuntimeCall,911	) -> Result<912		Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,913		TransactionValidityError,914	>;915}916917impl<T: Config> Pallet<T> {918	/// Service up to `max` agendas queue starting from earliest incompletely executed agenda.919	fn service_agendas(weight: &mut WeightCounter, now: T::BlockNumber, max: u32) {920		if !weight.check_accrue(T::WeightInfo::service_agendas_base()) {921			return;922		}923924		let mut incomplete_since = now + One::one();925		let mut when = IncompleteSince::<T>::take().unwrap_or(now);926		let mut executed = 0;927928		let max_items = T::MaxScheduledPerBlock::get();929		let mut count_down = max;930		let service_agenda_base_weight = T::WeightInfo::service_agenda_base(max_items);931		while count_down > 0 && when <= now && weight.can_accrue(service_agenda_base_weight) {932			if !Self::service_agenda(weight, &mut executed, now, when, u32::max_value()) {933				incomplete_since = incomplete_since.min(when);934			}935			when.saturating_inc();936			count_down.saturating_dec();937		}938		incomplete_since = incomplete_since.min(when);939		if incomplete_since <= now {940			IncompleteSince::<T>::put(incomplete_since);941		}942	}943944	/// Returns `true` if the agenda was fully completed, `false` if it should be revisited at a945	/// later block.946	fn service_agenda(947		weight: &mut WeightCounter,948		executed: &mut u32,949		now: T::BlockNumber,950		when: T::BlockNumber,951		max: u32,952	) -> bool {953		let mut agenda = Agenda::<T>::get(when);954		let mut ordered = agenda955			.iter()956			.enumerate()957			.filter_map(|(index, maybe_item)| {958				maybe_item959					.as_ref()960					.map(|item| (index as u32, item.priority))961			})962			.collect::<Vec<_>>();963		ordered.sort_by_key(|k| k.1);964		let within_limit =965			weight.check_accrue(T::WeightInfo::service_agenda_base(ordered.len() as u32));966		debug_assert!(967			within_limit,968			"weight limit should have been checked in advance"969		);970971		// Items which we know can be executed and have postponed for execution in a later block.972		let mut postponed = (ordered.len() as u32).saturating_sub(max);973		// Items which we don't know can ever be executed.974		let mut dropped = 0;975976		for (agenda_index, _) in ordered.into_iter().take(max as usize) {977			let task = match agenda.take(agenda_index).take() {978				None => continue,979				Some(t) => t,980			};981			let base_weight = T::WeightInfo::service_task(982				task.call.lookup_len().map(|x| x as usize),983				task.maybe_id.is_some(),984				task.maybe_periodic.is_some(),985			);986			if !weight.can_accrue(base_weight) {987				postponed += 1;988				break;989			}990			let result = Self::service_task(weight, now, when, agenda_index, *executed == 0, task);991			match result {992				Err((Unavailable, slot)) => {993					dropped += 1;994					agenda.set_slot(agenda_index, slot);995				}996				Err((Overweight, slot)) => {997					postponed += 1;998					agenda.set_slot(agenda_index, slot);999				}1000				Ok(()) => {1001					*executed += 1;1002				}1003			};1004		}1005		if postponed > 0 || dropped > 0 {1006			Agenda::<T>::insert(when, agenda);1007		} else {1008			Agenda::<T>::remove(when);1009		}1010		postponed == 01011	}10121013	/// Service (i.e. execute) the given task, being careful not to overflow the `weight` counter.1014	///1015	/// This involves:1016	/// - removing and potentially replacing the `Lookup` entry for the task.1017	/// - realizing the task's call which can include a preimage lookup.1018	/// - Rescheduling the task for execution in a later agenda if periodic.1019	fn service_task(1020		weight: &mut WeightCounter,1021		now: T::BlockNumber,1022		when: T::BlockNumber,1023		agenda_index: u32,1024		is_first: bool,1025		mut task: ScheduledOf<T>,1026	) -> Result<(), (ServiceTaskError, Option<ScheduledOf<T>>)> {1027		let (call, lookup_len) = match T::Preimages::peek(&task.call) {1028			Ok(c) => c,1029			Err(_) => {1030				if let Some(ref id) = task.maybe_id {1031					Lookup::<T>::remove(id);1032				}10331034				return Err((Unavailable, Some(task)));1035			}1036		};10371038		weight.check_accrue(T::WeightInfo::service_task(1039			lookup_len.map(|x| x as usize),1040			task.maybe_id.is_some(),1041			task.maybe_periodic.is_some(),1042		));10431044		match Self::execute_dispatch(weight, task.origin.clone(), call) {1045			Err(Unavailable) => {1046				debug_assert!(false, "Checked to exist with `peek`");10471048				if let Some(ref id) = task.maybe_id {1049					Lookup::<T>::remove(id);1050				}10511052				Self::deposit_event(Event::CallUnavailable {1053					task: (when, agenda_index),1054					id: task.maybe_id,1055				});1056				Err((Unavailable, Some(task)))1057			}1058			Err(Overweight) if is_first && !Self::is_runtime_upgraded() => {1059				T::Preimages::drop(&task.call);10601061				if let Some(ref id) = task.maybe_id {1062					Lookup::<T>::remove(id);1063				}10641065				Self::deposit_event(Event::PermanentlyOverweight {1066					task: (when, agenda_index),1067					id: task.maybe_id,1068				});1069				Err((Unavailable, Some(task)))1070			}1071			Err(Overweight) => {1072				// Preserve Lookup -- the task will be postponed.1073				Err((Overweight, Some(task)))1074			}1075			Ok(result) => {1076				Self::deposit_event(Event::Dispatched {1077					task: (when, agenda_index),1078					id: task.maybe_id,1079					result,1080				});10811082				let is_canceled = task1083					.maybe_id1084					.as_ref()1085					.map(|id| !Lookup::<T>::contains_key(id))1086					.unwrap_or(false);10871088				match &task.maybe_periodic {1089					&Some((period, count)) if !is_canceled => {1090						if count > 1 {1091							task.maybe_periodic = Some((period, count - 1));1092						} else {1093							task.maybe_periodic = None;1094						}1095						let wake = now.saturating_add(period);1096						Self::mandatory_place_task(wake, task);1097					}1098					_ => {1099						if let Some(ref id) = task.maybe_id {1100							Lookup::<T>::remove(id);1101						}11021103						T::Preimages::drop(&task.call)1104					}1105				}1106				Ok(())1107			}1108		}1109	}11101111	fn is_runtime_upgraded() -> bool {1112		let last = system::LastRuntimeUpgrade::<T>::get();1113		let current = T::Version::get();11141115		last.map(|v| v.was_upgraded(&current)).unwrap_or(true)1116	}11171118	/// Make a dispatch to the given `call` from the given `origin`, ensuring that the `weight`1119	/// counter does not exceed its limit and that it is counted accurately (e.g. accounted using1120	/// post info if available).1121	///1122	/// NOTE: Only the weight for this function will be counted (origin lookup, dispatch and the1123	/// call itself).1124	fn execute_dispatch(1125		weight: &mut WeightCounter,1126		origin: T::PalletsOrigin,1127		call: <T as Config>::RuntimeCall,1128	) -> Result<DispatchResult, ServiceTaskError> {1129		let dispatch_origin: <T as Config>::RuntimeOrigin = origin.into();1130		let base_weight = match dispatch_origin.clone().as_signed() {1131			Some(_) => T::WeightInfo::execute_dispatch_signed(),1132			_ => T::WeightInfo::execute_dispatch_unsigned(),1133		};1134		let call_weight = call.get_dispatch_info().weight;1135		// We only allow a scheduled call if it cannot push the weight past the limit.1136		let max_weight = base_weight.saturating_add(call_weight);11371138		if !weight.can_accrue(max_weight) {1139			return Err(Overweight);1140		}11411142		let ensured_origin = T::ScheduleOrigin::ensure_origin(dispatch_origin.into());11431144		let r = match ensured_origin {1145			Ok(ScheduledEnsureOriginSuccess::Root) => {1146				Ok(call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into()))1147			}1148			Ok(ScheduledEnsureOriginSuccess::Signed(sender)) => {1149				// Execute transaction via chain default pipeline1150				// That means dispatch will be processed like any user's extrinsic e.g. transaction fees will be taken1151				T::CallExecutor::dispatch_call(Some(sender), call)1152			}1153			Err(e) => Ok(Err(e.into())),1154		};11551156		let (maybe_actual_call_weight, result) = match r {1157			Ok(result) => match result {1158				Ok(post_info) => (post_info.actual_weight, Ok(())),1159				Err(error_and_info) => (1160					error_and_info.post_info.actual_weight,1161					Err(error_and_info.error),1162				),1163			},1164			Err(_) => {1165				log::error!(1166					target: "runtime::scheduler",1167					"Warning: Scheduler has failed to execute a post-dispatch transaction. \1168					This block might have become invalid.");1169				(None, Err(DispatchError::CannotLookup))1170			}1171		};1172		let call_weight = maybe_actual_call_weight.unwrap_or(call_weight);1173		weight.check_accrue(base_weight);1174		weight.check_accrue(call_weight);1175		Ok(result)1176	}1177}