git.delta.rocks / unique-network / refs/commits / 6f1d8428d6e1

1// This file is part of Substrate.23// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.4// SPDX-License-Identifier: Apache-2.056// Licensed under the Apache License, Version 2.0 (the "License");7// you may not use this file except in compliance with the License.8// You may obtain a copy of the License at9//10// 	http://www.apache.org/licenses/LICENSE-2.011//12// Unless required by applicable law or agreed to in writing, software13// distributed under the License is distributed on an "AS IS" BASIS,14// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.15// See the License for the specific language governing permissions and16// limitations under the License.1718//! # Scheduler19//! A module for scheduling dispatches.20//!21//! - [`Config`]22//! - [`Call`]23//! - [`Module`]24//!25//! ## Overview26//!27//! This module exposes capabilities for scheduling dispatches to occur at a28//! specified block number or at a specified period. These scheduled dispatches29//! may be named or anonymous and may be canceled.30//!31//! **NOTE:** The scheduled calls will be dispatched with the default filter32//! for the origin: namely `frame_system::Config::BaseCallFilter` for all origin33//! except root which will get no filter. And not the filter contained in origin34//! use to call `fn schedule`.35//!36//! If a call is scheduled using proxy or whatever mecanism which adds filter,37//! then those filter will not be used when dispatching the schedule call.38//!39//! ## Interface40//!41//! ### Dispatchable Functions42//!43//! * `schedule` - schedule a dispatch, which may be periodic, to occur at a44//!   specified block and with a specified priority.45//! * `cancel` - cancel a scheduled dispatch, specified by block number and46//!   index.47//! * `schedule_named` - augments the `schedule` interface with an additional48//!   `Vec<u8>` parameter that can be used for identification.49//! * `cancel_named` - the named complement to the cancel function.5051// Ensure we're `no_std` when compiling for Wasm.52#![cfg_attr(not(feature = "std"), no_std)]53#![allow(clippy::type_complexity, clippy::boxed_local, clippy::unused_unit)]5455mod benchmarking;56pub mod weights;5758use sp_std::{prelude::*, marker::PhantomData, borrow::Borrow};59use codec::{Encode, Decode, Codec};60use sp_runtime::{61	RuntimeDebug,62	traits::{Zero, One, BadOrigin, Saturating, SignedExtension},63};64use frame_support::{65	decl_module, decl_storage, decl_event, decl_error,66	dispatch::{Dispatchable, DispatchError, DispatchResult, Parameter},67	traits::{68		Get,69		schedule::{self, DispatchTime},70		OriginTrait, EnsureOrigin, IsType,71	},72	weights::{GetDispatchInfo, Weight},73};74use frame_system::{self as system, ensure_signed};75pub use weights::WeightInfo;76use up_sponsorship::SponsorshipHandler;77use scale_info::TypeInfo;7879/// Our pallet's configuration trait. All our types and constants go in here. If the80/// pallet is dependent on specific other pallets, then their configuration traits81/// should be added to our implied traits list.82///83/// `system::Config` should always be included in our implied traits.84/// //85pub trait Config: system::Config {86	/// The overarching event type.87	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;8889	/// The aggregated origin which the dispatch will take.90	type Origin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>91		+ From<Self::PalletsOrigin>92		+ IsType<<Self as system::Config>::Origin>;9394	/// The caller origin, overarching type of all pallets origins.95	type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + TypeInfo + Clone + Eq;9697	/// The aggregated call type.98	type Call: Parameter99		+ Dispatchable<Origin = <Self as Config>::Origin>100		+ GetDispatchInfo101		+ From<system::Call<Self>>;102103	/// The maximum weight that may be scheduled per block for any dispatchables of less priority104	/// than `schedule::HARD_DEADLINE`.105	type MaximumWeight: Get<Weight>;106107	/// Required origin to schedule or cancel calls.108	type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::Origin>;109110	/// The maximum number of scheduled calls in the queue for a single block.111	/// Not strictly enforced, but used for weight estimation.112	type MaxScheduledPerBlock: Get<u32>;113114	/// Sponsoring function115	type SponsorshipHandler: SponsorshipHandler<Self::AccountId, <Self as Config>::Call>;116117	/// Weight information for extrinsics in this pallet.118	type WeightInfo: WeightInfo;119120	/// Unchecked extrinsic type as expected by the runtime that uses this pallet.121	type PaymentHandler: SignedExtension;122}123124pub const MAX_TASK_ID_LENGTH_IN_BYTES: u8 = 16;125126pub const PERIODIC_CALLS_LIMIT: u32 = 100;127128// pub type SelfWeightInfo<T> = <T as system::Config>::WeightInfo;129130/// Just a simple index for naming period tasks.131pub type PeriodicIndex = u32;132/// The location of a scheduled task that can be used to remove it.133pub type TaskAddress<BlockNumber> = (BlockNumber, u32);134135#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]136#[derive(Clone, RuntimeDebug, Encode, Decode)]137struct ScheduledV1<Call, BlockNumber> {138	maybe_id: Option<Vec<u8>>,139	priority: schedule::Priority,140	call: Call,141	maybe_periodic: Option<schedule::Period<BlockNumber>>,142}143144/// Information regarding an item to be executed in the future.145#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]146#[derive(Clone, RuntimeDebug, Encode, Decode, TypeInfo)]147pub struct ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId> {148	/// The unique identity for this task, if there is one.149	maybe_id: Option<Vec<u8>>,150	/// This task's priority.151	priority: schedule::Priority,152	/// The call to be dispatched.153	call: Call,154	/// If the call is periodic, then this points to the information concerning that.155	maybe_periodic: Option<schedule::Period<BlockNumber>>,156	/// The origin to dispatch the call.157	origin: PalletsOrigin,158	_phantom: PhantomData<AccountId>,159}160161/// The current version of Scheduled struct.162pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> =163	ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId>;164165// A value placed in storage that represents the current version of the Scheduler storage.166// This value is used by the `on_runtime_upgrade` logic to determine whether we run167// storage migration logic.168#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo)]169enum Releases {170	V1,171	V2,172}173174impl Default for Releases {175	fn default() -> Self {176		Releases::V1177	}178}179180#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]181pub struct CallSpec {182	module: u32,183	method: u32,184}185186decl_storage! {187	trait Store for Module<T: Config> as Scheduler {188		/// Items to be executed, indexed by the block number that they should be executed on.189		pub Agenda: map hasher(twox_64_concat) T::BlockNumber190			=> Vec<Option<Scheduled<<T as Config>::Call, T::BlockNumber, T::PalletsOrigin, T::AccountId>>>;191192		pub SpecAgenda: map hasher(twox_64_concat) T::BlockNumber193			=> Vec<Option<CallSpec>>;194195		/// Lookup from identity to the block number and index of the task.196		Lookup: map hasher(twox_64_concat) Vec<u8> => Option<TaskAddress<T::BlockNumber>>;197198		/// Storage version of the pallet.199		///200		/// New networks start with last version.201		StorageVersion build(|_| Releases::V2): Releases;202	}203}204205decl_event!(206	pub enum Event<T> where <T as system::Config>::BlockNumber {207		/// Scheduled some task. \[when, index\]208		Scheduled(BlockNumber, u32),209		/// Canceled some task. \[when, index\]210		Canceled(BlockNumber, u32),211		/// Dispatched some task. \[task, id, result\]212		Dispatched(TaskAddress<BlockNumber>, Option<Vec<u8>>, DispatchResult),213	}214);215216decl_error! {217	pub enum Error for Module<T: Config> {218		/// Failed to schedule a call219		FailedToSchedule,220		/// Cannot find the scheduled call.221		NotFound,222		/// Given target block number is in the past.223		TargetBlockNumberInPast,224		/// Reschedule failed because it does not change scheduled time.225		RescheduleNoChange,226	}227}228229decl_module! {230	/// Scheduler module declaration.231	pub struct Module<T: Config> for enum Call232	where233		origin: <T as system::Config>::Origin234	{235		type Error = Error<T>;236		fn deposit_event() = default;237238239		/// Anonymously schedule a task.240		///241		/// # <weight>242		/// - S = Number of already scheduled calls243		/// - Base Weight: 22.29 + .126 * S µs244		/// - DB Weight:245		///     - Read: Agenda246		///     - Write: Agenda247		/// - Will use base weight of 25 which should be good for up to 30 scheduled calls248		/// # </weight>249		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]250		fn schedule(origin,251			when: T::BlockNumber,252			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,253			priority: schedule::Priority,254			call: Box<<T as Config>::Call>,255		)256		{257			let origin = <T as Config>::Origin::from(origin);258			Self::do_schedule_nameless(DispatchTime::At(when), maybe_periodic, priority, origin.caller().clone(), *call)?;259		}260261		/// Cancel an anonymously scheduled task.262		///263		/// # <weight>264		/// - S = Number of already scheduled calls265		/// - Base Weight: 22.15 + 2.869 * S µs266		/// - DB Weight:267		///     - Read: Agenda268		///     - Write: Agenda, Lookup269		/// - Will use base weight of 100 which should be good for up to 30 scheduled calls270		/// # </weight>271		#[weight = <T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get())]272		fn cancel(origin, when: T::BlockNumber, index: u32) {273			T::ScheduleOrigin::ensure_origin(origin.clone())?;274			let origin = <T as Config>::Origin::from(origin);275			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;276		}277278		/// Schedule a named task.279		///280		/// # <weight>281		/// - S = Number of already scheduled calls282		/// - Base Weight: 29.6 + .159 * S µs283		/// - DB Weight:284		///     - Read: Agenda, Lookup285		///     - Write: Agenda, Lookup286		/// - Will use base weight of 35 which should be good for more than 30 scheduled calls287		/// # </weight>288		#[weight = <T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get())]289		fn schedule_named(origin,290			id: Vec<u8>,291			when: T::BlockNumber,292			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,293			priority: schedule::Priority,294			call: Box<<T as Config>::Call>,295		) {296			T::ScheduleOrigin::ensure_origin(origin.clone())?;297			let origin = <T as Config>::Origin::from(origin);298			Self::do_schedule_named(299				id, DispatchTime::At(when), maybe_periodic, priority, origin.caller().clone(), *call300			)?;301		}302303		/// Cancel a named scheduled task.304		///305		/// # <weight>306		/// - S = Number of already scheduled calls307		/// - Base Weight: 24.91 + 2.907 * S µs308		/// - DB Weight:309		///     - Read: Agenda, Lookup310		///     - Write: Agenda, Lookup311		/// - Will use base weight of 100 which should be good for up to 30 scheduled calls312		/// # </weight>313		#[weight = <T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get())]314		fn cancel_named(origin, id: Vec<u8>) {315			T::ScheduleOrigin::ensure_origin(origin.clone())?;316			let origin = <T as Config>::Origin::from(origin);317			Self::do_cancel_named(Some(origin.caller().clone()), id)?;318		}319320		/// Anonymously schedule a task after a delay.321		///322		/// # <weight>323		/// Same as [`schedule`].324		/// # </weight>325		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]326		fn schedule_after(origin,327			after: T::BlockNumber,328			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,329			priority: schedule::Priority,330			call: Box<<T as Config>::Call>,331		) {332			T::ScheduleOrigin::ensure_origin(origin.clone())?;333			let origin = <T as Config>::Origin::from(origin);334			Self::do_schedule_nameless(335				DispatchTime::After(after), maybe_periodic, priority, origin.caller().clone(), *call336			)?;337		}338339		/// Schedule a named task after a delay.340		///341		/// # <weight>342		/// Same as [`schedule_named`].343		/// # </weight>344		#[weight = <T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get())]345		fn schedule_named_after(origin,346			id: Vec<u8>,347			after: T::BlockNumber,348			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,349			priority: schedule::Priority,350			call: Box<<T as Config>::Call>,351		) {352			T::ScheduleOrigin::ensure_origin(origin.clone())?;353			let origin = <T as Config>::Origin::from(origin);354			Self::do_schedule_named(355				id, DispatchTime::After(after), maybe_periodic, priority, origin.caller().clone(), *call356			)?;357		}358359		/// Execute the scheduled calls360		///361		/// # <weight>362		/// - S = Number of already scheduled calls363		/// - N = Named scheduled calls364		/// - P = Periodic Calls365		/// - Base Weight: 9.243 + 23.45 * S µs366		/// - DB Weight:367		///     - Read: Agenda + Lookup * N + Agenda(Future) * P368		///     - Write: Agenda + Lookup * N  + Agenda(future) * P369		/// # </weight>370		fn on_initialize(now: T::BlockNumber) -> Weight {371			let limit = T::MaximumWeight::get();372			let mut queued = Agenda::<T>::take(now)373				.into_iter()374				.enumerate()375				.filter_map(|(index, s)| s.map(|inner| (index as u32, inner)))376				.collect::<Vec<_>>();377			if queued.len() as u32 > T::MaxScheduledPerBlock::get() {378				log::warn!(379					target: "runtime::scheduler",380					"Warning: This block has more items queued in Scheduler than \381					expected from the runtime configuration. An update might be needed."382				);383			}384			queued.sort_by_key(|(_, s)| s.priority);385			let base_weight: Weight = T::DbWeight::get().reads_writes(1, 2); // Agenda + Agenda(next)386			let mut total_weight: Weight = 0; // T::WeightInfo::on_initialize(0)387			queued.into_iter()388				.enumerate()389				.scan(base_weight, |cumulative_weight, (order, (index, s))| {390					*cumulative_weight = cumulative_weight391						.saturating_add(s.call.get_dispatch_info().weight);392393					let origin = <<T as Config>::Origin as From<T::PalletsOrigin>>::from(394						s.origin.clone()395					).into();396397					if ensure_signed(origin).is_ok() {398						 // AccountData for inner call origin accountdata.399						*cumulative_weight = cumulative_weight400							.saturating_add(T::DbWeight::get().reads_writes(1, 1));401					}402403					if s.maybe_id.is_some() {404						// Remove/Modify Lookup405						*cumulative_weight = cumulative_weight.saturating_add(T::DbWeight::get().writes(1));406					}407					if s.maybe_periodic.is_some() {408						// Read/Write Agenda for future block409						*cumulative_weight = cumulative_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));410					}411412					Some((order, index, *cumulative_weight, s))413				})414				.filter_map(|(order, index, cumulative_weight, mut s)| {415					// We allow a scheduled call if any is true:416					// - It's priority is `HARD_DEADLINE`417					// - It does not push the weight past the limit.418					// - It is the first item in the schedule419					if s.priority <= schedule::HARD_DEADLINE || cumulative_weight <= limit || order == 0 {420421						// let origin = <<T as Config>::Origin as From<T::PalletsOrigin>>::from(422						// 	s.origin.clone()423						// ).into();424						// let sender = ensure_signed(origin).unwrap_or_default();425						// let who_will_pay = T::SponsorshipHandler::get_sponsor(&sender, &s.call).unwrap_or(sender);426						// let sponsor = T::PalletsOrigin::from(system::RawOrigin::Signed(who_will_pay));427						// let r = s.call.clone().dispatch(sponsor.into());428						let maybe_id = s.maybe_id.clone();429						if let Some((period, count)) = s.maybe_periodic {430							if count > 1 {431								s.maybe_periodic = Some((period, count - 1));432							} else {433								s.maybe_periodic = None;434							}435							let next = now + period;436							// If scheduled is named, place it's information in `Lookup`437							if let Some(ref id) = s.maybe_id {438								let next_index = Agenda::<T>::decode_len(now + period).unwrap_or(0);439								Lookup::<T>::insert(id, (next, next_index as u32));440							}441							Agenda::<T>::append(next, Some(s));442						} else if let Some(ref id) = s.maybe_id {443									  Lookup::<T>::remove(id);444								  }445						Self::deposit_event(RawEvent::Dispatched(446							(now, index),447							maybe_id,448							Ok(())// r.map(|_| ()).map_err(|e| e.error)449						));450						total_weight = cumulative_weight;451						None452					} else {453						Some(Some(s))454					}455				})456				.for_each(|unused| {457					let next = now + One::one();458					Agenda::<T>::append(next, unused);459				});460461			total_weight462		}463	}464}465466impl<T: Config> Module<T> {467	fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {468		let now = frame_system::Pallet::<T>::block_number();469470		let when = match when {471			DispatchTime::At(x) => x,472			// The current block has already completed it's scheduled tasks, so473			// Schedule the task at lest one block after this current block.474			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),475		};476477		if when <= now {478			return Err(Error::<T>::TargetBlockNumberInPast.into());479		}480481		Ok(when)482	}483484	fn do_schedule(485		maybe_id: Option<Vec<u8>>,486		when: DispatchTime<T::BlockNumber>,487		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,488		priority: schedule::Priority,489		origin: T::PalletsOrigin,490		call: <T as Config>::Call,491	) -> Result<(T::BlockNumber, u32), DispatchError> {492		let when = Self::resolve_time(when)?;493494		let sender = ensure_signed(495			<<T as Config>::Origin as From<T::PalletsOrigin>>::from(origin.clone()).into()496		).unwrap_or_default();497		let who_will_pay = T::SponsorshipHandler::get_sponsor(&sender, &call).unwrap_or(sender);498		let sponsor = T::PalletsOrigin::from(system::RawOrigin::Signed(who_will_pay));499		let r = call.clone().dispatch(sponsor.into());500501		//T::PaymentHandler::validate(sponsor.into(), call.clone(), ); todo dispatch call502503		// sanitize maybe_periodic504		let maybe_periodic = maybe_periodic505			.filter(|p| p.1 > 1 && !p.0.is_zero())506			// Limit the repetitions to 100 calls and remove one from the number of repetitions since we will schedule one now.507			.map(|(p, c)| (p, std::cmp::min(c, PERIODIC_CALLS_LIMIT) - 1));508			509		let s = Some(Scheduled {510			maybe_id,511			priority,512			call,513			maybe_periodic,514			origin,515			_phantom: PhantomData::<T::AccountId>::default(),516		});517		Agenda::<T>::append(when, s);518		let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;519		if index > T::MaxScheduledPerBlock::get() {520			log::warn!(521				target: "runtime::scheduler",522				"Warning: There are more items queued in the Scheduler than \523				expected from the runtime configuration. An update might be needed.",524			);525		}526527		Ok((when, index))528	}529530	fn do_schedule_nameless(531		when: DispatchTime<T::BlockNumber>,532		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,533		priority: schedule::Priority,534		origin: T::PalletsOrigin,535		call: <T as Config>::Call,536	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {537		let address = Self::do_schedule(None, when, maybe_periodic, priority, origin, call)?;538		let (when, index) = address;539540		Self::deposit_event(RawEvent::Scheduled(when, index));541542		Ok(address)543	}544545	fn do_cancel(546		origin: Option<T::PalletsOrigin>,547		(when, index): TaskAddress<T::BlockNumber>,548	) -> Result<(), DispatchError> {549		let scheduled = Agenda::<T>::try_mutate(when, |agenda| {550			agenda.get_mut(index as usize).map_or(551				Ok(None),552				|s| -> Result<Option<Scheduled<_, _, _, _>>, DispatchError> {553					if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {554						if *o != s.origin {555							return Err(BadOrigin.into());556						}557					};558					Ok(s.take())559				},560			)561		})?;562		if let Some(s) = scheduled {563			if let Some(id) = s.maybe_id {564				Lookup::<T>::remove(id);565			}566			Self::deposit_event(RawEvent::Canceled(when, index));567			Ok(())568		} else {569			Err(Error::<T>::NotFound.into())570		}571	}572573	fn do_reschedule(574		(when, index): TaskAddress<T::BlockNumber>,575		new_time: DispatchTime<T::BlockNumber>,576	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {577		let new_time = Self::resolve_time(new_time)?;578579		if new_time == when {580			return Err(Error::<T>::RescheduleNoChange.into());581		}582583		Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {584			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;585			let task = task.take().ok_or(Error::<T>::NotFound)?;586			Agenda::<T>::append(new_time, Some(task));587			Ok(())588		})?;589590		let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;591		Self::deposit_event(RawEvent::Canceled(when, index));592		Self::deposit_event(RawEvent::Scheduled(new_time, new_index));593594		Ok((new_time, new_index))595	}596597	fn do_schedule_named(598		id: Vec<u8>,599		when: DispatchTime<T::BlockNumber>,600		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,601		priority: schedule::Priority,602		origin: T::PalletsOrigin,603		call: <T as Config>::Call,604	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {605		// ensure id length does not exceed expectations & is unique606		if id.len() > MAX_TASK_ID_LENGTH_IN_BYTES.try_into().unwrap()607			|| Lookup::<T>::contains_key(&id)608		{609			return Err(Error::<T>::FailedToSchedule.into());610		}611612		let address = Self::do_schedule(Some(id.clone()), when, maybe_periodic, priority, origin, call)?;613		let (when, index) = address;614615		Lookup::<T>::insert(&id, &address);616		Self::deposit_event(RawEvent::Scheduled(when, index));617		Ok(address)618	}619620	fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: Vec<u8>) -> DispatchResult {621		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {622			if let Some((when, index)) = lookup.take() {623				let i = index as usize;624				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {625					if let Some(s) = agenda.get_mut(i) {626						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {627							if *o != s.origin {628								return Err(BadOrigin.into());629							}630						}631						*s = None;632					}633					Ok(())634				})?;635				Self::deposit_event(RawEvent::Canceled(when, index));636				Ok(())637			} else {638				Err(Error::<T>::NotFound.into())639			}640		})641	}642643	fn do_reschedule_named(644		id: Vec<u8>,645		new_time: DispatchTime<T::BlockNumber>,646	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {647		let new_time = Self::resolve_time(new_time)?;648649		Lookup::<T>::try_mutate_exists(650			id,651			|lookup| -> Result<TaskAddress<T::BlockNumber>, DispatchError> {652				let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;653654				if new_time == when {655					return Err(Error::<T>::RescheduleNoChange.into());656				}657658				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {659					let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;660					let task = task.take().ok_or(Error::<T>::NotFound)?;661					Agenda::<T>::append(new_time, Some(task));662663					Ok(())664				})?;665666				let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;667				Self::deposit_event(RawEvent::Canceled(when, index));668				Self::deposit_event(RawEvent::Scheduled(new_time, new_index));669670				*lookup = Some((new_time, new_index));671672				Ok((new_time, new_index))673			},674		)675	}676}677678impl<T: Config> schedule::Anon<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin>679	for Module<T>680{681	type Address = TaskAddress<T::BlockNumber>;682683	fn schedule(684		when: DispatchTime<T::BlockNumber>,685		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,686		priority: schedule::Priority,687		origin: T::PalletsOrigin,688		call: <T as Config>::Call,689	) -> Result<Self::Address, DispatchError> {690		Self::do_schedule_nameless(when, maybe_periodic, priority, origin, call)691	}692693	fn cancel((when, index): Self::Address) -> Result<(), ()> {694		Self::do_cancel(None, (when, index)).map_err(|_| ())695	}696697	fn reschedule(698		address: Self::Address,699		when: DispatchTime<T::BlockNumber>,700	) -> Result<Self::Address, DispatchError> {701		Self::do_reschedule(address, when)702	}703704	fn next_dispatch_time((when, index): Self::Address) -> Result<T::BlockNumber, ()> {705		Agenda::<T>::get(when)706			.get(index as usize)707			.ok_or(())708			.map(|_| when)709	}710}711712impl<T: Config> schedule::Named<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin>713	for Module<T>714{715	type Address = TaskAddress<T::BlockNumber>;716717	fn schedule_named(718		id: Vec<u8>,719		when: DispatchTime<T::BlockNumber>,720		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,721		priority: schedule::Priority,722		origin: T::PalletsOrigin,723		call: <T as Config>::Call,724	) -> Result<Self::Address, ()> {725		Self::do_schedule_named(id, when, maybe_periodic, priority, origin, call).map_err(|_| ())726	}727728	fn cancel_named(id: Vec<u8>) -> Result<(), ()> {729		Self::do_cancel_named(None, id).map_err(|_| ())730	}731732	fn reschedule_named(733		id: Vec<u8>,734		when: DispatchTime<T::BlockNumber>,735	) -> Result<Self::Address, DispatchError> {736		Self::do_reschedule_named(id, when)737	}738739	fn next_dispatch_time(id: Vec<u8>) -> Result<T::BlockNumber, ()> {740		Lookup::<T>::get(id)741			.and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when))742			.ok_or(())743	}744}745746#[cfg(test)]747#[allow(clippy::from_over_into)]748mod tests {749	use super::*;750751	use frame_support::{752		ord_parameter_types, parameter_types, traits::Contains, weights::constants::RocksDbWeight,753	};754	use sp_core::H256;755	use sp_runtime::{756		Perbill,757		testing::Header,758		traits::{BlakeTwo256, IdentityLookup},759	};760	use frame_system::{EnsureOneOf, EnsureRoot, EnsureSignedBy};761	use crate as scheduler;762763	mod logger {764		use super::*;765		use std::cell::RefCell;766767		thread_local! {768			static LOG: RefCell<Vec<(OriginCaller, u32)>> = RefCell::new(Vec::new());769		}770		pub trait Config: system::Config {771			type Event: From<Event> + Into<<Self as system::Config>::Event>;772		}773		decl_event! {774			pub enum Event {775				Logged(u32, Weight),776			}777		}778		decl_module! {779			pub struct Module<T: Config> for enum Call780			where781				origin: <T as system::Config>::Origin,782				<T as system::Config>::Origin: OriginTrait<PalletsOrigin = OriginCaller>783			{784				fn deposit_event() = default;785786				#[weight = *weight]787				fn log(origin, i: u32, weight: Weight) {788					Self::deposit_event(Event::Logged(i, weight));789					LOG.with(|log| {790						log.borrow_mut().push((origin.caller().clone(), i));791					})792				}793794				#[weight = *weight]795				fn log_without_filter(origin, i: u32, weight: Weight) {796					Self::deposit_event(Event::Logged(i, weight));797					LOG.with(|log| {798						log.borrow_mut().push((origin.caller().clone(), i));799					})800				}801			}802		}803	}804805	type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;806	type Block = frame_system::mocking::MockBlock<Test>;807808	frame_support::construct_runtime!(809		pub enum Test where810			Block = Block,811			NodeBlock = Block,812			UncheckedExtrinsic = UncheckedExtrinsic,813		{814			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},815			Logger: logger::{Pallet, Call, Event},816			Scheduler: scheduler::{Pallet, Call, Storage, Event<T>},817		}818	);819820	// Scheduler must dispatch with root and no filter, this tests base filter is indeed not used.821	pub struct BaseFilter;822	impl Contains<Call> for BaseFilter {823		fn contains(call: &Call) -> bool {824			!matches!(call, Call::Logger(logger::Call::log { .. }))825		}826	}827828	parameter_types! {829		pub const BlockHashCount: u64 = 250;830		pub BlockWeights: frame_system::limits::BlockWeights =831			frame_system::limits::BlockWeights::simple_max(2_000_000_000_000);832	}833	impl system::Config for Test {834		type BaseCallFilter = BaseFilter;835		type BlockWeights = ();836		type BlockLength = ();837		type DbWeight = RocksDbWeight;838		type Origin = Origin;839		type Call = Call;840		type Index = u64;841		type BlockNumber = u64;842		type Hash = H256;843		type Hashing = BlakeTwo256;844		type AccountId = u64;845		type Lookup = IdentityLookup<Self::AccountId>;846		type Header = Header;847		type Event = Event;848		type BlockHashCount = BlockHashCount;849		type Version = ();850		type PalletInfo = PalletInfo;851		type AccountData = ();852		type OnNewAccount = ();853		type OnKilledAccount = ();854		type SystemWeightInfo = ();855		type SS58Prefix = ();856		type OnSetCode = ();857	}858	impl logger::Config for Test {859		type Event = Event;860	}861	parameter_types! {862		pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * BlockWeights::get().max_block;863		pub const MaxScheduledPerBlock: u32 = 10;864	}865	ord_parameter_types! {866		pub const One: u64 = 1;867	}868869	impl Config for Test {870		type Event = Event;871		type Origin = Origin;872		type PalletsOrigin = OriginCaller;873		type Call = Call;874		type MaximumWeight = MaximumSchedulerWeight;875		type ScheduleOrigin = EnsureOneOf<u64, EnsureRoot<u64>, EnsureSignedBy<One, u64>>;876		type MaxScheduledPerBlock = MaxScheduledPerBlock;877		type WeightInfo = ();878		type SponsorshipHandler = ();879		type PaymentHandler = ();880	}881}