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

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)]5354mod benchmarking;55pub mod weights;5657use sp_std::{prelude::*, marker::PhantomData, borrow::Borrow};58use codec::{Encode, Decode, Codec};59use sp_runtime::{RuntimeDebug, traits::{Zero, One, BadOrigin, Saturating}};60use frame_support::{61	decl_module, decl_storage, decl_event, decl_error, IterableStorageMap,62	dispatch::{Dispatchable, DispatchError, DispatchResult, Parameter},63	traits::{Get, schedule::{self, DispatchTime}, OriginTrait, EnsureOrigin, IsType},64	weights::{GetDispatchInfo, Weight},65};66use frame_system::{self as system, ensure_signed};67pub use weights::WeightInfo;68use up_sponsorship::SponsorshipHandler;6970/// Our pallet's configuration trait. All our types and constants go in here. If the71/// pallet is dependent on specific other pallets, then their configuration traits72/// should be added to our implied traits list.73///74/// `system::Config` should always be included in our implied traits.75/// // 76pub trait Config: system::Config77{ 7879	/// The overarching event type.80	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;8182	/// The aggregated origin which the dispatch will take.83	type Origin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>84		+ From<Self::PalletsOrigin> + IsType<<Self as system::Config>::Origin>;8586	/// The caller origin, overarching type of all pallets origins.87	type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + Clone + Eq;8889	/// The aggregated call type.90	type Call: Parameter + Dispatchable<Origin=<Self as Config>::Origin> + GetDispatchInfo + From<system::Call<Self>>;9192	/// The maximum weight that may be scheduled per block for any dispatchables of less priority93	/// than `schedule::HARD_DEADLINE`.94	type MaximumWeight: Get<Weight>;9596	/// Required origin to schedule or cancel calls.97	type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::Origin>;9899	/// The maximum number of scheduled calls in the queue for a single block.100	/// Not strictly enforced, but used for weight estimation.101	type MaxScheduledPerBlock: Get<u32>;102103	/// Sponsoring function104	type SponsorshipHandler: SponsorshipHandler<Self::AccountId, <Self as Config>::Call>;105106	/// Weight information for extrinsics in this pallet.107	type WeightInfo: WeightInfo;108}109110// pub type SelfWeightInfo<T> = <T as system::Config>::WeightInfo;111112/// Just a simple index for naming period tasks.113pub type PeriodicIndex = u32;114/// The location of a scheduled task that can be used to remove it.115pub type TaskAddress<BlockNumber> = (BlockNumber, u32);116117#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]118#[derive(Clone, RuntimeDebug, Encode, Decode)]119struct ScheduledV1<Call, BlockNumber> {120	maybe_id: Option<Vec<u8>>,121	priority: schedule::Priority,122	call: Call,123	maybe_periodic: Option<schedule::Period<BlockNumber>>,124}125126/// Information regarding an item to be executed in the future.127#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]128#[derive(Clone, RuntimeDebug, Encode, Decode)]129pub struct ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId> {130	/// The unique identity for this task, if there is one.131	maybe_id: Option<Vec<u8>>,132	/// This task's priority.133	priority: schedule::Priority,134	/// The call to be dispatched.135	call: Call,136	/// If the call is periodic, then this points to the information concerning that.137	maybe_periodic: Option<schedule::Period<BlockNumber>>,138	/// The origin to dispatch the call.139	origin: PalletsOrigin,140	_phantom: PhantomData<AccountId>,141}142143/// The current version of Scheduled struct.144pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> = ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId>;145146// A value placed in storage that represents the current version of the Scheduler storage.147// This value is used by the `on_runtime_upgrade` logic to determine whether we run148// storage migration logic.149#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug)]150enum Releases {151	V1,152	V2,153}154155impl Default for Releases {156	fn default() -> Self {157		Releases::V1158	}159}160161#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug)]162pub struct CallSpec {163164	module: u32,165	method: u32,166}167168decl_storage! {169	trait Store for Module<T: Config> as Scheduler {170		/// Items to be executed, indexed by the block number that they should be executed on.171		pub Agenda: map hasher(twox_64_concat) T::BlockNumber172			=> Vec<Option<Scheduled<<T as Config>::Call, T::BlockNumber, T::PalletsOrigin, T::AccountId>>>;173174		pub SpecAgenda: map hasher(twox_64_concat) T::BlockNumber175			=> Vec<Option<CallSpec>>;			176177		/// Lookup from identity to the block number and index of the task.178		Lookup: map hasher(twox_64_concat) Vec<u8> => Option<TaskAddress<T::BlockNumber>>;179180		/// Storage version of the pallet.181		///182		/// New networks start with last version.183		StorageVersion build(|_| Releases::V2): Releases;184	}185}186187decl_event!(188	pub enum Event<T> where <T as system::Config>::BlockNumber {189		/// Scheduled some task. \[when, index\]190		Scheduled(BlockNumber, u32),191		/// Canceled some task. \[when, index\]192		Canceled(BlockNumber, u32),193		/// Dispatched some task. \[task, id, result\]194		Dispatched(TaskAddress<BlockNumber>, Option<Vec<u8>>, DispatchResult),195	}196);197198decl_error! {199	pub enum Error for Module<T: Config> {200		/// Failed to schedule a call201		FailedToSchedule,202		/// Cannot find the scheduled call.203		NotFound,204		/// Given target block number is in the past.205		TargetBlockNumberInPast,206		/// Reschedule failed because it does not change scheduled time.207		RescheduleNoChange,208	}209}210211decl_module! {212	/// Scheduler module declaration.213	pub struct Module<T: Config> for enum Call 214	where 215		origin: <T as system::Config>::Origin216	{217		type Error = Error<T>;218		fn deposit_event() = default;219220221		/// Anonymously schedule a task.222		///223		/// # <weight>224		/// - S = Number of already scheduled calls225		/// - Base Weight: 22.29 + .126 * S µs226		/// - DB Weight:227		///     - Read: Agenda228		///     - Write: Agenda229		/// - Will use base weight of 25 which should be good for up to 30 scheduled calls230		/// # </weight>231		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]232		fn schedule(origin,233			when: T::BlockNumber,234			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,235			priority: schedule::Priority,236			call: Box<<T as Config>::Call>,237		) 238		{239			let origin = <T as Config>::Origin::from(origin);240			Self::do_schedule(DispatchTime::At(when), maybe_periodic, priority, origin.caller().clone(), *call)?;241		}242243		/// Cancel an anonymously scheduled task.244		///245		/// # <weight>246		/// - S = Number of already scheduled calls247		/// - Base Weight: 22.15 + 2.869 * S µs248		/// - DB Weight:249		///     - Read: Agenda250		///     - Write: Agenda, Lookup251		/// - Will use base weight of 100 which should be good for up to 30 scheduled calls252		/// # </weight>253		#[weight = <T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get())]254		fn cancel(origin, when: T::BlockNumber, index: u32) {255			T::ScheduleOrigin::ensure_origin(origin.clone())?;256			let origin = <T as Config>::Origin::from(origin);257			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;258		}259260		/// Schedule a named task.261		///262		/// # <weight>263		/// - S = Number of already scheduled calls264		/// - Base Weight: 29.6 + .159 * S µs265		/// - DB Weight:266		///     - Read: Agenda, Lookup267		///     - Write: Agenda, Lookup268		/// - Will use base weight of 35 which should be good for more than 30 scheduled calls269		/// # </weight>270		#[weight = <T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get())]271		fn schedule_named(origin,272			id: Vec<u8>,273			when: T::BlockNumber,274			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,275			priority: schedule::Priority,276			call: Box<<T as Config>::Call>,277		) {278			T::ScheduleOrigin::ensure_origin(origin.clone())?;279			let origin = <T as Config>::Origin::from(origin);280			Self::do_schedule_named(281				id, DispatchTime::At(when), maybe_periodic, priority, origin.caller().clone(), *call282			)?;283		}284285		/// Cancel a named scheduled task.286		///287		/// # <weight>288		/// - S = Number of already scheduled calls289		/// - Base Weight: 24.91 + 2.907 * S µs290		/// - DB Weight:291		///     - Read: Agenda, Lookup292		///     - Write: Agenda, Lookup293		/// - Will use base weight of 100 which should be good for up to 30 scheduled calls294		/// # </weight>295		#[weight = <T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get())]296		fn cancel_named(origin, id: Vec<u8>) {297			T::ScheduleOrigin::ensure_origin(origin.clone())?;298			let origin = <T as Config>::Origin::from(origin);299			Self::do_cancel_named(Some(origin.caller().clone()), id)?;300		}301302		/// Anonymously schedule a task after a delay.303		///304		/// # <weight>305		/// Same as [`schedule`].306		/// # </weight>307		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]308		fn schedule_after(origin,309			after: T::BlockNumber,310			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,311			priority: schedule::Priority,312			call: Box<<T as Config>::Call>,313		) {314			T::ScheduleOrigin::ensure_origin(origin.clone())?;315			let origin = <T as Config>::Origin::from(origin);316			Self::do_schedule(317				DispatchTime::After(after), maybe_periodic, priority, origin.caller().clone(), *call318			)?;319		}320321		/// Schedule a named task after a delay.322		///323		/// # <weight>324		/// Same as [`schedule_named`].325		/// # </weight>326		#[weight = <T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get())]327		fn schedule_named_after(origin,328			id: Vec<u8>,329			after: T::BlockNumber,330			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,331			priority: schedule::Priority,332			call: Box<<T as Config>::Call>,333		) {334			T::ScheduleOrigin::ensure_origin(origin.clone())?;335			let origin = <T as Config>::Origin::from(origin);336			Self::do_schedule_named(337				id, DispatchTime::After(after), maybe_periodic, priority, origin.caller().clone(), *call338			)?;339		}340341		/// Execute the scheduled calls342		///343		/// # <weight>344		/// - S = Number of already scheduled calls345		/// - N = Named scheduled calls346		/// - P = Periodic Calls347		/// - Base Weight: 9.243 + 23.45 * S µs348		/// - DB Weight:349		///     - Read: Agenda + Lookup * N + Agenda(Future) * P350		///     - Write: Agenda + Lookup * N  + Agenda(future) * P351		/// # </weight>352		fn on_initialize(now: T::BlockNumber) -> Weight {353			let limit = T::MaximumWeight::get();354			let mut queued = Agenda::<T>::take(now).into_iter()355				.enumerate()356				.filter_map(|(index, s)| s.map(|inner| (index as u32, inner)))357				.collect::<Vec<_>>();358			if queued.len() as u32 > T::MaxScheduledPerBlock::get() {359				log::warn!(360					target: "runtime::scheduler",361					"Warning: This block has more items queued in Scheduler than \362					expected from the runtime configuration. An update might be needed."363				);364			}365			queued.sort_by_key(|(_, s)| s.priority);366			let base_weight: Weight = T::DbWeight::get().reads_writes(1, 2); // Agenda + Agenda(next)367			let mut total_weight: Weight = 0;368			queued.into_iter()369				.enumerate()370				.scan(base_weight, |cumulative_weight, (order, (index, s))| {371					*cumulative_weight = cumulative_weight372						.saturating_add(s.call.get_dispatch_info().weight);373374					let origin = <<T as Config>::Origin as From<T::PalletsOrigin>>::from(375						s.origin.clone()376					).into();377378					if ensure_signed(origin).is_ok() {379						 // AccountData for inner call origin accountdata.380						*cumulative_weight = cumulative_weight381							.saturating_add(T::DbWeight::get().reads_writes(1, 1));382					}383384					if s.maybe_id.is_some() {385						// Remove/Modify Lookup386						*cumulative_weight = cumulative_weight.saturating_add(T::DbWeight::get().writes(1));387					}388					if s.maybe_periodic.is_some() {389						// Read/Write Agenda for future block390						*cumulative_weight = cumulative_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));391					}392393					Some((order, index, *cumulative_weight, s))394				})395				.filter_map(|(order, index, cumulative_weight, mut s)| {396					// We allow a scheduled call if any is true:397					// - It's priority is `HARD_DEADLINE`398					// - It does not push the weight past the limit.399					// - It is the first item in the schedule400					if s.priority <= schedule::HARD_DEADLINE || cumulative_weight <= limit || order == 0 {401402						let origin = <<T as Config>::Origin as From<T::PalletsOrigin>>::from(403							s.origin.clone()404						).into();405						let sender = ensure_signed(origin).unwrap_or(T::AccountId::default());406						let who_will_pay = T::SponsorshipHandler::get_sponsor(&sender, &s.call).unwrap_or(sender);407						let sponsor = T::PalletsOrigin::from(system::RawOrigin::Signed(who_will_pay));408						let r = s.call.clone().dispatch(sponsor.into());409						let maybe_id = s.maybe_id.clone();410						if let &Some((period, count)) = &s.maybe_periodic {411							if count > 1 {412								s.maybe_periodic = Some((period, count - 1));413							} else {414								s.maybe_periodic = None;415							}416							let next = now + period;417							// If scheduled is named, place it's information in `Lookup`418							if let Some(ref id) = s.maybe_id {419								let next_index = Agenda::<T>::decode_len(now + period).unwrap_or(0);420								Lookup::<T>::insert(id, (next, next_index as u32));421							}422							Agenda::<T>::append(next, Some(s));423						} else {424							if let Some(ref id) = s.maybe_id {425								Lookup::<T>::remove(id);426							}427						}428						Self::deposit_event(RawEvent::Dispatched(429							(now, index),430							maybe_id,431							r.map(|_| ()).map_err(|e| e.error)432						));433						total_weight = cumulative_weight;434						None435					} else {436						Some(Some(s))437					}438				})439				.for_each(|unused| {440					let next = now + One::one();441					Agenda::<T>::append(next, unused);442				});443444			total_weight445		}446	}447}448449impl<T: Config> Module<T> {450	/// Migrate storage format from V1 to V2.451	/// Return true if migration is performed.452	pub fn migrate_v1_to_t2() -> bool {453		if StorageVersion::get() == Releases::V1 {454			StorageVersion::put(Releases::V2);455456			Agenda::<T>::translate::<457				Vec<Option<ScheduledV1<<T as Config>::Call, T::BlockNumber>>>, _458			>(|_, agenda| Some(459				agenda460					.into_iter()461					.map(|schedule| schedule.map(|schedule| ScheduledV2 {462						maybe_id: schedule.maybe_id,463						priority: schedule.priority,464						call: schedule.call,465						maybe_periodic: schedule.maybe_periodic,466						origin: system::RawOrigin::Root.into(),467						_phantom: Default::default(),468					}))469					.collect::<Vec<_>>()470			));471472			true473		} else {474			false475		}476	}477478	/// Helper to migrate scheduler when the pallet origin type has changed.479	pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {480		Agenda::<T>::translate::<481			Vec<Option<Scheduled<<T as Config>::Call, T::BlockNumber, OldOrigin, T::AccountId>>>, _482		>(|_, agenda| Some(483			agenda484				.into_iter()485				.map(|schedule| schedule.map(|schedule| Scheduled {486					maybe_id: schedule.maybe_id,487					priority: schedule.priority,488					call: schedule.call,489					maybe_periodic: schedule.maybe_periodic,490					origin: schedule.origin.into(),491					_phantom: Default::default(),492				}))493				.collect::<Vec<_>>()494		));495	}496497	fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {498		let now = frame_system::Pallet::<T>::block_number();499500		let when = match when {501			DispatchTime::At(x) => x,502			// The current block has already completed it's scheduled tasks, so503			// Schedule the task at lest one block after this current block.504			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one())505		};506507		if when <= now {508			return Err(Error::<T>::TargetBlockNumberInPast.into())509		}510511		Ok(when)512	}513514	fn do_schedule(515		when: DispatchTime<T::BlockNumber>,516		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,517		priority: schedule::Priority,518		origin: T::PalletsOrigin,519		call: <T as Config>::Call520	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {521		let when = Self::resolve_time(when)?;522523		// sanitize maybe_periodic524		let maybe_periodic = maybe_periodic525			.filter(|p| p.1 > 1 && !p.0.is_zero())526			// Remove one from the number of repetitions since we will schedule one now.527			.map(|(p, c)| (p, c - 1));528		let s = Some(Scheduled {529			maybe_id: None, priority, call, maybe_periodic, origin, _phantom: PhantomData::<T::AccountId>::default(),530		});531		Agenda::<T>::append(when, s);532		let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;533		if index > T::MaxScheduledPerBlock::get() {534			log::warn!(535				target: "runtime::scheduler",536				"Warning: There are more items queued in the Scheduler than \537				expected from the runtime configuration. An update might be needed.",538			);539		}540		Self::deposit_event(RawEvent::Scheduled(when, index));541542		Ok((when, index))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(550			when,551			|agenda| {552				agenda.get_mut(index as usize)553					.map_or(Ok(None), |s| -> Result<Option<Scheduled<_, _, _, _>>, DispatchError> {554						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {555							if *o != s.origin {556								return Err(BadOrigin.into());557							}558						};559						Ok(s.take())560					})561			},562		)?;563		if let Some(s) = scheduled {564			if let Some(id) = s.maybe_id {565				Lookup::<T>::remove(id);566			}567			Self::deposit_event(RawEvent::Canceled(when, index));568			Ok(())569		} else {570			Err(Error::<T>::NotFound)?571		}572	}573574	fn do_reschedule(575		(when, index): TaskAddress<T::BlockNumber>,576		new_time: DispatchTime<T::BlockNumber>,577	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {578		let new_time = Self::resolve_time(new_time)?;579580		if new_time == when {581			return Err(Error::<T>::RescheduleNoChange.into());582		}583584		Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {585			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;586			let task = task.take().ok_or(Error::<T>::NotFound)?;587			Agenda::<T>::append(new_time, Some(task));588			Ok(())589		})?;590591		let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;592		Self::deposit_event(RawEvent::Canceled(when, index));593		Self::deposit_event(RawEvent::Scheduled(new_time, new_index));594595		Ok((new_time, new_index))596	}597598	fn do_schedule_named(599		id: Vec<u8>,600		when: DispatchTime<T::BlockNumber>,601		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,602		priority: schedule::Priority,603		origin: T::PalletsOrigin,604		call: <T as Config>::Call,605	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {606		// ensure id it is unique607		if Lookup::<T>::contains_key(&id) {608			return Err(Error::<T>::FailedToSchedule)?609		}610611		let when = Self::resolve_time(when)?;612613		// sanitize maybe_periodic614		let maybe_periodic = maybe_periodic615			.filter(|p| p.1 > 1 && !p.0.is_zero())616			// Remove one from the number of repetitions since we will schedule one now.617			.map(|(p, c)| (p, c - 1));618619		let s = Scheduled {620			maybe_id: Some(id.clone()), priority, call, maybe_periodic, origin, _phantom: Default::default()621		};622		Agenda::<T>::append(when, Some(s));623		let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;624		if index > T::MaxScheduledPerBlock::get() {625			log::warn!(626				target: "runtime::scheduler",627				"Warning: There are more items queued in the Scheduler than \628				expected from the runtime configuration. An update might be needed.",629			);630		}631		let address = (when, index);632		Lookup::<T>::insert(&id, &address);633		Self::deposit_event(RawEvent::Scheduled(when, index));634635		Ok(address)636	}637638	fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: Vec<u8>) -> DispatchResult {639		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {640			if let Some((when, index)) = lookup.take() {641				let i = index as usize;642				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {643					if let Some(s) = agenda.get_mut(i) {644						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {645							if *o != s.origin {646								return Err(BadOrigin.into());647							}648						}649						*s = None;650					}651					Ok(())652				})?;653				Self::deposit_event(RawEvent::Canceled(when, index));654				Ok(())655			} else {656				Err(Error::<T>::NotFound)?657			}658		})659	}660661	fn do_reschedule_named(662		id: Vec<u8>,663		new_time: DispatchTime<T::BlockNumber>,664	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {665		let new_time = Self::resolve_time(new_time)?;666667		Lookup::<T>::try_mutate_exists(id, |lookup| -> Result<TaskAddress<T::BlockNumber>, DispatchError> {668			let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;669670			if new_time == when {671				return Err(Error::<T>::RescheduleNoChange.into());672			}673674			Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {675				let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;676				let task = task.take().ok_or(Error::<T>::NotFound)?;677				Agenda::<T>::append(new_time, Some(task));678679				Ok(())680			})?;681682			let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;683			Self::deposit_event(RawEvent::Canceled(when, index));684			Self::deposit_event(RawEvent::Scheduled(new_time, new_index));685686			*lookup = Some((new_time, new_index));687688			Ok((new_time, new_index))689		})690	}691}692693impl<T: Config> schedule::Anon<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin> for Module<T> {694	type Address = TaskAddress<T::BlockNumber>;695696	fn schedule(697		when: DispatchTime<T::BlockNumber>,698		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,699		priority: schedule::Priority,700		origin: T::PalletsOrigin,701		call: <T as Config>::Call702	) -> Result<Self::Address, DispatchError> {703		Self::do_schedule(when, maybe_periodic, priority, origin, call)704	}705706	fn cancel((when, index): Self::Address) -> Result<(), ()> {707		Self::do_cancel(None, (when, index)).map_err(|_| ())708	}709710	fn reschedule(711		address: Self::Address,712		when: DispatchTime<T::BlockNumber>,713	) -> Result<Self::Address, DispatchError> {714		Self::do_reschedule(address, when)715	}716717	fn next_dispatch_time((when, index): Self::Address) -> Result<T::BlockNumber, ()> {718		Agenda::<T>::get(when).get(index as usize).ok_or(()).map(|_| when)719	}720}721722impl<T: Config> schedule::Named<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin> for Module<T> {723	type Address = TaskAddress<T::BlockNumber>;724725	fn schedule_named(726		id: Vec<u8>,727		when: DispatchTime<T::BlockNumber>,728		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,729		priority: schedule::Priority,730		origin: T::PalletsOrigin,731		call: <T as Config>::Call,732	) -> Result<Self::Address, ()> {733		Self::do_schedule_named(id, when, maybe_periodic, priority, origin, call).map_err(|_| ())734	}735736	fn cancel_named(id: Vec<u8>) -> Result<(), ()> {737		Self::do_cancel_named(None, id).map_err(|_| ())738	}739740	fn reschedule_named(741		id: Vec<u8>,742		when: DispatchTime<T::BlockNumber>,743	) -> Result<Self::Address, DispatchError> {744		Self::do_reschedule_named(id, when)745	}746747	fn next_dispatch_time(id: Vec<u8>) -> Result<T::BlockNumber, ()> {748		Lookup::<T>::get(id).and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when)).ok_or(())749	}750}751752#[cfg(test)]753mod tests {754	use super::*;755756	use frame_support::{757		parameter_types, assert_ok, ord_parameter_types,758		assert_noop, assert_err, Hashable,759		traits::{OnInitialize, OnFinalize, Filter},760		weights::constants::RocksDbWeight,761	};762	use sp_core::H256;763	use sp_runtime::{764		Perbill,765		testing::Header,766		traits::{BlakeTwo256, IdentityLookup},767	};768	use frame_system::{EnsureOneOf, EnsureRoot, EnsureSignedBy};769	use substrate_test_utils::assert_eq_uvec;770	use crate as scheduler;771772	mod logger {773		use super::*;774		use std::cell::RefCell;775776		thread_local! {777			static LOG: RefCell<Vec<(OriginCaller, u32)>> = RefCell::new(Vec::new());778		}779		pub fn log() -> Vec<(OriginCaller, u32)> {780			LOG.with(|log| log.borrow().clone())781		}782		pub trait Config: system::Config {783			type Event: From<Event> + Into<<Self as system::Config>::Event>;784		}785		decl_event! {786			pub enum Event {787				Logged(u32, Weight),788			}789		}790		decl_module! {791			pub struct Module<T: Config> for enum Call792			where793				origin: <T as system::Config>::Origin,794				<T as system::Config>::Origin: OriginTrait<PalletsOrigin = OriginCaller>795			{796				fn deposit_event() = default;797798				#[weight = *weight]799				fn log(origin, i: u32, weight: Weight) {800					Self::deposit_event(Event::Logged(i, weight));801					LOG.with(|log| {802						log.borrow_mut().push((origin.caller().clone(), i));803					})804				}805806				#[weight = *weight]807				fn log_without_filter(origin, i: u32, weight: Weight) {808					Self::deposit_event(Event::Logged(i, weight));809					LOG.with(|log| {810						log.borrow_mut().push((origin.caller().clone(), i));811					})812				}813			}814		}815	}816817	type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;818	type Block = frame_system::mocking::MockBlock<Test>;819820	frame_support::construct_runtime!(821		pub enum Test where822			Block = Block,823			NodeBlock = Block,824			UncheckedExtrinsic = UncheckedExtrinsic,825		{826			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},827			Logger: logger::{Pallet, Call, Event},828			Scheduler: scheduler::{Pallet, Call, Storage, Event<T>},829		}830	);831832	// Scheduler must dispatch with root and no filter, this tests base filter is indeed not used.833	pub struct BaseFilter;834	impl Filter<Call> for BaseFilter {835		fn filter(call: &Call) -> bool {836			!matches!(call, Call::Logger(logger::Call::log(_, _)))837		}838	}839840	parameter_types! {841		pub const BlockHashCount: u64 = 250;842		pub BlockWeights: frame_system::limits::BlockWeights =843			frame_system::limits::BlockWeights::simple_max(2_000_000_000_000);844	}845	impl system::Config for Test {846		type BaseCallFilter = BaseFilter;847		type BlockWeights = ();848		type BlockLength = ();849		type DbWeight = RocksDbWeight;850		type Origin = Origin;851		type Call = Call;852		type Index = u64;853		type BlockNumber = u64;854		type Hash = H256;855		type Hashing = BlakeTwo256;856		type AccountId = u64;857		type Lookup = IdentityLookup<Self::AccountId>;858		type Header = Header;859		type Event = Event;860		type BlockHashCount = BlockHashCount;861		type Version = ();862		type PalletInfo = PalletInfo;863		type AccountData = ();864		type OnNewAccount = ();865		type OnKilledAccount = ();866		type SystemWeightInfo = ();867		type SS58Prefix = ();868		type OnSetCode = ();869	}870	impl logger::Config for Test {871		type Event = Event;872	}873	parameter_types! {874		pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * BlockWeights::get().max_block;875		pub const MaxScheduledPerBlock: u32 = 10;876	}877	ord_parameter_types! {878		pub const One: u64 = 1;879	}880881	impl Config for Test {882		type Event = Event;883		type Origin = Origin;884		type PalletsOrigin = OriginCaller;885		type Call = Call;886		type MaximumWeight = MaximumSchedulerWeight;887		type ScheduleOrigin = EnsureOneOf<u64, EnsureRoot<u64>, EnsureSignedBy<One, u64>>;888		type MaxScheduledPerBlock = MaxScheduledPerBlock;889		type WeightInfo = ();890        type SponsorshipHandler = ();891	}892893	pub fn new_test_ext() -> sp_io::TestExternalities {894		let t = system::GenesisConfig::default().build_storage::<Test>().unwrap();895		t.into()896	}897898	fn run_to_block(n: u64) {899		while System::block_number() < n {900			Scheduler::on_finalize(System::block_number());901			System::set_block_number(System::block_number() + 1);902			Scheduler::on_initialize(System::block_number());903		}904	}905906	fn root() -> OriginCaller {907		system::RawOrigin::Root.into()908	}909910	#[test]911	fn basic_scheduling_works() {912		new_test_ext().execute_with(|| {913			let call = Call::Logger(logger::Call::log(42, 1000));914			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));915			assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call));916			run_to_block(3);917			assert!(logger::log().is_empty());918			run_to_block(4);919			assert_eq!(logger::log(), vec![(root(), 42u32)]);920			run_to_block(100);921			assert_eq!(logger::log(), vec![(root(), 42u32)]);922		});923	}924925	#[test]926	fn schedule_after_works() {927		new_test_ext().execute_with(|| {928			run_to_block(2);929			let call = Call::Logger(logger::Call::log(42, 1000));930			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));931			// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6932			assert_ok!(Scheduler::do_schedule(DispatchTime::After(3), None, 127, root(), call));933			run_to_block(5);934			assert!(logger::log().is_empty());935			run_to_block(6);936			assert_eq!(logger::log(), vec![(root(), 42u32)]);937			run_to_block(100);938			assert_eq!(logger::log(), vec![(root(), 42u32)]);939		});940	}941942	#[test]943	fn schedule_after_zero_works() {944		new_test_ext().execute_with(|| {945			run_to_block(2);946			let call = Call::Logger(logger::Call::log(42, 1000));947			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));948			assert_ok!(Scheduler::do_schedule(DispatchTime::After(0), None, 127, root(), call));949			// Will trigger on the next block.950			run_to_block(3);951			assert_eq!(logger::log(), vec![(root(), 42u32)]);952			run_to_block(100);953			assert_eq!(logger::log(), vec![(root(), 42u32)]);954		});955	}956957	#[test]958	fn periodic_scheduling_works() {959		new_test_ext().execute_with(|| {960			// at #4, every 3 blocks, 3 times.961			assert_ok!(Scheduler::do_schedule(962				DispatchTime::At(4), Some((3, 3)), 127, root(), Call::Logger(logger::Call::log(42, 1000))963			));964			run_to_block(3);965			assert!(logger::log().is_empty());966			run_to_block(4);967			assert_eq!(logger::log(), vec![(root(), 42u32)]);968			run_to_block(6);969			assert_eq!(logger::log(), vec![(root(), 42u32)]);970			run_to_block(7);971			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);972			run_to_block(9);973			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);974			run_to_block(10);975			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);976			run_to_block(100);977			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);978		});979	}980981	#[test]982	fn reschedule_works() {983		new_test_ext().execute_with(|| {984			let call = Call::Logger(logger::Call::log(42, 1000));985			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));986			assert_eq!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call).unwrap(), (4, 0));987988			run_to_block(3);989			assert!(logger::log().is_empty());990991			assert_eq!(Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(), (6, 0));992993			assert_noop!(Scheduler::do_reschedule((6, 0), DispatchTime::At(6)), Error::<Test>::RescheduleNoChange);994995			run_to_block(4);996			assert!(logger::log().is_empty());997998			run_to_block(6);999			assert_eq!(logger::log(), vec![(root(), 42u32)]);10001001			run_to_block(100);1002			assert_eq!(logger::log(), vec![(root(), 42u32)]);1003		});1004	}10051006	#[test]1007	fn reschedule_named_works() {1008		new_test_ext().execute_with(|| {1009			let call = Call::Logger(logger::Call::log(42, 1000));1010			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));1011			assert_eq!(Scheduler::do_schedule_named(1012				1u32.encode(), DispatchTime::At(4), None, 127, root(), call1013			).unwrap(), (4, 0));10141015			run_to_block(3);1016			assert!(logger::log().is_empty());10171018			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(), (6, 0));10191020			assert_noop!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)), Error::<Test>::RescheduleNoChange);10211022			run_to_block(4);1023			assert!(logger::log().is_empty());10241025			run_to_block(6);1026			assert_eq!(logger::log(), vec![(root(), 42u32)]);10271028			run_to_block(100);1029			assert_eq!(logger::log(), vec![(root(), 42u32)]);1030		});1031	}10321033	#[test]1034	fn reschedule_named_perodic_works() {1035		new_test_ext().execute_with(|| {1036			let call = Call::Logger(logger::Call::log(42, 1000));1037			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));1038			assert_eq!(Scheduler::do_schedule_named(1039				1u32.encode(), DispatchTime::At(4), Some((3, 3)), 127, root(), call1040			).unwrap(), (4, 0));10411042			run_to_block(3);1043			assert!(logger::log().is_empty());10441045			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(5)).unwrap(), (5, 0));1046			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(), (6, 0));10471048			run_to_block(5);1049			assert!(logger::log().is_empty());10501051			run_to_block(6);1052			assert_eq!(logger::log(), vec![(root(), 42u32)]);10531054			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(10)).unwrap(), (10, 0));10551056			run_to_block(9);1057			assert_eq!(logger::log(), vec![(root(), 42u32)]);10581059			run_to_block(10);1060			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);10611062			run_to_block(13);1063			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);10641065			run_to_block(100);1066			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);1067		});1068	}10691070	#[test]1071	fn cancel_named_scheduling_works_with_normal_cancel() {1072		new_test_ext().execute_with(|| {1073			// at #4.1074			Scheduler::do_schedule_named(1075				1u32.encode(), DispatchTime::At(4), None, 127, root(), Call::Logger(logger::Call::log(69, 1000))1076			).unwrap();1077			let i = Scheduler::do_schedule(1078				DispatchTime::At(4), None, 127, root(), Call::Logger(logger::Call::log(42, 1000))1079			).unwrap();1080			run_to_block(3);1081			assert!(logger::log().is_empty());1082			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1083			assert_ok!(Scheduler::do_cancel(None, i));1084			run_to_block(100);1085			assert!(logger::log().is_empty());1086		});1087	}10881089	#[test]1090	fn cancel_named_periodic_scheduling_works() {1091		new_test_ext().execute_with(|| {1092			// at #4, every 3 blocks, 3 times.1093			Scheduler::do_schedule_named(1094				1u32.encode(),1095				DispatchTime::At(4),1096				Some((3, 3)),1097				127,1098				root(),1099				Call::Logger(logger::Call::log(42, 1000))1100			).unwrap();1101			// same id results in error.1102			assert!(Scheduler::do_schedule_named(1103				1u32.encode(),1104				DispatchTime::At(4),1105				None,1106				127,1107				root(),1108				Call::Logger(logger::Call::log(69, 1000))1109			).is_err());1110			// different id is ok.1111			Scheduler::do_schedule_named(1112				2u32.encode(), DispatchTime::At(8), None, 127, root(), Call::Logger(logger::Call::log(69, 1000))1113			).unwrap();1114			run_to_block(3);1115			assert!(logger::log().is_empty());1116			run_to_block(4);1117			assert_eq!(logger::log(), vec![(root(), 42u32)]);1118			run_to_block(6);1119			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1120			run_to_block(100);1121			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1122		});1123	}11241125	#[test]1126	fn scheduler_respects_weight_limits() {1127		new_test_ext().execute_with(|| {1128			assert_ok!(Scheduler::do_schedule(1129				DispatchTime::At(4),1130				None,1131				127,1132				root(),1133				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1134			));1135			assert_ok!(Scheduler::do_schedule(1136				DispatchTime::At(4),1137				None,1138				127,1139				root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1140			));1141			// 69 and 42 do not fit together1142			run_to_block(4);1143			assert_eq!(logger::log(), vec![(root(), 42u32)]);1144			run_to_block(5);1145			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1146		});1147	}11481149	#[test]1150	fn scheduler_respects_hard_deadlines_more() {1151		new_test_ext().execute_with(|| {1152			assert_ok!(Scheduler::do_schedule(1153				DispatchTime::At(4),1154				None,1155				0,1156				root(),1157				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1158			));1159			assert_ok!(Scheduler::do_schedule(1160				DispatchTime::At(4),1161				None,1162				0,1163				root(),1164				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1165			));1166			// With base weights, 69 and 42 should not fit together, but do because of hard deadlines1167			run_to_block(4);1168			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1169		});1170	}11711172	#[test]1173	fn scheduler_respects_priority_ordering() {1174		new_test_ext().execute_with(|| {1175			assert_ok!(Scheduler::do_schedule(1176				DispatchTime::At(4),1177				None,1178				1,1179				root(),1180				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1181			));1182			assert_ok!(Scheduler::do_schedule(1183				DispatchTime::At(4),1184				None,1185				0,1186				root(),1187				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1188			));1189			run_to_block(4);1190			assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);1191		});1192	}11931194	#[test]1195	fn scheduler_respects_priority_ordering_with_soft_deadlines() {1196		new_test_ext().execute_with(|| {1197			assert_ok!(Scheduler::do_schedule(1198				DispatchTime::At(4),1199				None,1200				255,1201				root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1202			));1203			assert_ok!(Scheduler::do_schedule(1204				DispatchTime::At(4),1205				None,1206				127,1207				root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1208			));1209			assert_ok!(Scheduler::do_schedule(1210				DispatchTime::At(4),1211				None,1212				126,1213				root(), Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))1214			));12151216			// 2600 does not fit with 69 or 42, but has higher priority, so will go through1217			run_to_block(4);1218			assert_eq!(logger::log(), vec![(root(), 2600u32)]);1219			// 69 and 42 fit together1220			run_to_block(5);1221			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);1222		});1223	}12241225	#[test]1226	fn on_initialize_weight_is_correct() {1227		new_test_ext().execute_with(|| {1228			let base_weight: Weight = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);1229			let base_multiplier = 0;1230			let named_multiplier = <Test as frame_system::Config>::DbWeight::get().writes(1);1231			let periodic_multiplier = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 1);12321233			// Named1234			assert_ok!(1235				Scheduler::do_schedule_named(1236					1u32.encode(), DispatchTime::At(1), None, 255, root(),1237					Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))1238				)1239			);1240			// Anon Periodic1241			assert_ok!(Scheduler::do_schedule(1242				DispatchTime::At(1),1243				Some((1000, 3)),1244				128,1245				root(),1246				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1247			));1248			// Anon1249			assert_ok!(Scheduler::do_schedule(1250				DispatchTime::At(1),1251				None,1252				127,1253				root(),1254				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1255			));1256			// Named Periodic1257			assert_ok!(Scheduler::do_schedule_named(1258				2u32.encode(), DispatchTime::At(1), Some((1000, 3)), 126, root(),1259				Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2)))1260			);12611262			// Will include the named periodic only1263			let actual_weight = Scheduler::on_initialize(1);1264			let call_weight = MaximumSchedulerWeight::get() / 2;1265			assert_eq!(1266				actual_weight, call_weight + base_weight + base_multiplier + named_multiplier + periodic_multiplier1267			);1268			assert_eq!(logger::log(), vec![(root(), 2600u32)]);12691270			// Will include anon and anon periodic1271			let actual_weight = Scheduler::on_initialize(2);1272			let call_weight = MaximumSchedulerWeight::get() / 2 + MaximumSchedulerWeight::get() / 3;1273			assert_eq!(actual_weight, call_weight + base_weight + base_multiplier * 2 + periodic_multiplier);1274			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);12751276			// Will include named only1277			let actual_weight = Scheduler::on_initialize(3);1278			let call_weight = MaximumSchedulerWeight::get() / 3;1279			assert_eq!(actual_weight, call_weight + base_weight + base_multiplier + named_multiplier);1280			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32), (root(), 3u32)]);12811282			// Will contain none1283			let actual_weight = Scheduler::on_initialize(4);1284			assert_eq!(actual_weight, 0);1285		});1286	}12871288	#[test]1289	fn root_calls_works() {1290		new_test_ext().execute_with(|| {1291			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1292			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1293			assert_ok!(Scheduler::schedule_named(Origin::root(), 1u32.encode(), 4, None, 127, call));1294			assert_ok!(Scheduler::schedule(Origin::root(), 4, None, 127, call2));1295			run_to_block(3);1296			// Scheduled calls are in the agenda.1297			assert_eq!(Agenda::<Test>::get(4).len(), 2);1298			assert!(logger::log().is_empty());1299			assert_ok!(Scheduler::cancel_named(Origin::root(), 1u32.encode()));1300			assert_ok!(Scheduler::cancel(Origin::root(), 4, 1));1301			// Scheduled calls are made NONE, so should not effect state1302			run_to_block(100);1303			assert!(logger::log().is_empty());1304		});1305	}13061307	#[test]1308	fn fails_to_schedule_task_in_the_past() {1309		new_test_ext().execute_with(|| {1310			run_to_block(3);13111312			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1313			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));13141315			assert_err!(1316				Scheduler::schedule_named(Origin::root(), 1u32.encode(), 2, None, 127, call),1317				Error::<Test>::TargetBlockNumberInPast,1318			);13191320			assert_err!(1321				Scheduler::schedule(Origin::root(), 2, None, 127, call2.clone()),1322				Error::<Test>::TargetBlockNumberInPast,1323			);13241325			assert_err!(1326				Scheduler::schedule(Origin::root(), 3, None, 127, call2),1327				Error::<Test>::TargetBlockNumberInPast,1328			);1329		});1330	}13311332	#[test]1333	fn should_use_orign() {1334		new_test_ext().execute_with(|| {1335			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1336			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1337			assert_ok!(1338				Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)1339			);1340			assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));1341			run_to_block(3);1342			// Scheduled calls are in the agenda.1343			assert_eq!(Agenda::<Test>::get(4).len(), 2);1344			assert!(logger::log().is_empty());1345			assert_ok!(Scheduler::cancel_named(system::RawOrigin::Signed(1).into(), 1u32.encode()));1346			assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));1347			// Scheduled calls are made NONE, so should not effect state1348			run_to_block(100);1349			assert!(logger::log().is_empty());1350		});1351	}13521353	#[test]1354	fn should_check_orign() {1355		new_test_ext().execute_with(|| {1356			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1357			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1358			assert_noop!(1359				Scheduler::schedule_named(system::RawOrigin::Signed(2).into(), 1u32.encode(), 4, None, 127, call),1360				BadOrigin1361			);1362			assert_noop!(Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2), BadOrigin);1363		});1364	}13651366	#[test]1367	fn should_check_orign_for_cancel() {1368		new_test_ext().execute_with(|| {1369			let call = Box::new(Call::Logger(logger::Call::log_without_filter(69, 1000)));1370			let call2 = Box::new(Call::Logger(logger::Call::log_without_filter(42, 1000)));1371			assert_ok!(1372				Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)1373			);1374			assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));1375			run_to_block(3);1376			// Scheduled calls are in the agenda.1377			assert_eq!(Agenda::<Test>::get(4).len(), 2);1378			assert!(logger::log().is_empty());1379			assert_noop!(Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()), BadOrigin);1380			assert_noop!(Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1), BadOrigin);1381			assert_noop!(Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()), BadOrigin);1382			assert_noop!(Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1), BadOrigin);1383			run_to_block(5);1384			assert_eq!(1385				logger::log(),1386				vec![(system::RawOrigin::Signed(1).into(), 69u32), (system::RawOrigin::Signed(1).into(), 42u32)]1387			);1388		});1389	}13901391	#[test]1392	fn migration_to_v2_works() {1393		new_test_ext().execute_with(|| {1394			for i in 0..3u64 {1395				let k = i.twox_64_concat();1396				let old = vec![1397					Some(ScheduledV1 {1398						maybe_id: None,1399						priority: i as u8 + 10,1400						call: Call::Logger(logger::Call::log(96, 100)),1401						maybe_periodic: None,1402					}),1403					None,1404					Some(ScheduledV1 {1405						maybe_id: Some(b"test".to_vec()),1406						priority: 123,1407						call: Call::Logger(logger::Call::log(69, 1000)),1408						maybe_periodic: Some((456u64, 10)),1409					}),1410				];1411				frame_support::migration::put_storage_value(1412					b"Scheduler",1413					b"Agenda",1414					&k,1415					old,1416				);1417			}14181419			assert_eq!(StorageVersion::get(), Releases::V1);14201421			assert!(Scheduler::migrate_v1_to_t2());14221423			assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![1424				(1425					0,1426					vec![1427					Some(ScheduledV2 {1428						maybe_id: None,1429						priority: 10,1430						call: Call::Logger(logger::Call::log(96, 100)),1431						maybe_periodic: None,1432						origin: root(),1433						_phantom: PhantomData::<u64>::default(),1434					}),1435					None,1436					Some(ScheduledV2 {1437						maybe_id: Some(b"test".to_vec()),1438						priority: 123,1439						call: Call::Logger(logger::Call::log(69, 1000)),1440						maybe_periodic: Some((456u64, 10)),1441						origin: root(),1442						_phantom: PhantomData::<u64>::default(),1443					}),1444				]),1445				(1446					1,1447					vec![1448						Some(ScheduledV2 {1449							maybe_id: None,1450							priority: 11,1451							call: Call::Logger(logger::Call::log(96, 100)),1452							maybe_periodic: None,1453							origin: root(),1454							_phantom: PhantomData::<u64>::default(),1455						}),1456						None,1457						Some(ScheduledV2 {1458							maybe_id: Some(b"test".to_vec()),1459							priority: 123,1460							call: Call::Logger(logger::Call::log(69, 1000)),1461							maybe_periodic: Some((456u64, 10)),1462							origin: root(),1463							_phantom: PhantomData::<u64>::default(),1464						}),1465					]1466				),1467				(1468					2,1469					vec![1470						Some(ScheduledV2 {1471							maybe_id: None,1472							priority: 12,1473							call: Call::Logger(logger::Call::log(96, 100)),1474							maybe_periodic: None,1475							origin: root(),1476							_phantom: PhantomData::<u64>::default(),1477						}),1478						None,1479						Some(ScheduledV2 {1480							maybe_id: Some(b"test".to_vec()),1481							priority: 123,1482							call: Call::Logger(logger::Call::log(69, 1000)),1483							maybe_periodic: Some((456u64, 10)),1484							origin: root(),1485							_phantom: PhantomData::<u64>::default(),1486						}),1487					]1488				)1489			]);14901491			assert_eq!(StorageVersion::get(), Releases::V2);1492		});1493	}14941495	#[test]1496	fn test_migrate_origin() {1497		new_test_ext().execute_with(|| {1498			for i in 0..3u64 {1499				let k = i.twox_64_concat();1500				let old: Vec<Option<Scheduled<_, _, u32, u64>>> = vec![1501					Some(Scheduled {1502						maybe_id: None,1503						priority: i as u8 + 10,1504						call: Call::Logger(logger::Call::log(96, 100)),1505						origin: 3u32,1506						maybe_periodic: None,1507						_phantom: Default::default(),1508					}),1509					None,1510					Some(Scheduled {1511						maybe_id: Some(b"test".to_vec()),1512						priority: 123,1513						origin: 2u32,1514						call: Call::Logger(logger::Call::log(69, 1000)),1515						maybe_periodic: Some((456u64, 10)),1516						_phantom: Default::default(),1517					}),1518				];1519				frame_support::migration::put_storage_value(1520					b"Scheduler",1521					b"Agenda",1522					&k,1523					old,1524				);1525			}15261527			impl Into<OriginCaller> for u32 {1528				fn into(self) -> OriginCaller {1529					match self {1530						3u32 => system::RawOrigin::Root.into(),1531						2u32 => system::RawOrigin::None.into(),1532						_ => unreachable!("test make no use of it"),1533					}1534				}1535			}15361537			Scheduler::migrate_origin::<u32>();15381539			assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![1540				(1541					0,1542					vec![1543					Some(ScheduledV2::<_, _, OriginCaller, u64> {1544						maybe_id: None,1545						priority: 10,1546						call: Call::Logger(logger::Call::log(96, 100)),1547						maybe_periodic: None,1548						origin: system::RawOrigin::Root.into(),1549						_phantom: PhantomData::<u64>::default(),1550					}),1551					None,1552					Some(ScheduledV2 {1553						maybe_id: Some(b"test".to_vec()),1554						priority: 123,1555						call: Call::Logger(logger::Call::log(69, 1000)),1556						maybe_periodic: Some((456u64, 10)),1557						origin: system::RawOrigin::None.into(),1558						_phantom: PhantomData::<u64>::default(),1559					}),1560				]),1561				(1562					1,1563					vec![1564						Some(ScheduledV2 {1565							maybe_id: None,1566							priority: 11,1567							call: Call::Logger(logger::Call::log(96, 100)),1568							maybe_periodic: None,1569							origin: system::RawOrigin::Root.into(),1570							_phantom: PhantomData::<u64>::default(),1571						}),1572						None,1573						Some(ScheduledV2 {1574							maybe_id: Some(b"test".to_vec()),1575							priority: 123,1576							call: Call::Logger(logger::Call::log(69, 1000)),1577							maybe_periodic: Some((456u64, 10)),1578							origin: system::RawOrigin::None.into(),1579							_phantom: PhantomData::<u64>::default(),1580						}),1581					]1582				),1583				(1584					2,1585					vec![1586						Some(ScheduledV2 {1587							maybe_id: None,1588							priority: 12,1589							call: Call::Logger(logger::Call::log(96, 100)),1590							maybe_periodic: None,1591							origin: system::RawOrigin::Root.into(),1592							_phantom: PhantomData::<u64>::default(),1593						}),1594						None,1595						Some(ScheduledV2 {1596							maybe_id: Some(b"test".to_vec()),1597							priority: 123,1598							call: Call::Logger(logger::Call::log(69, 1000)),1599							maybe_periodic: Some((456u64, 10)),1600							origin: system::RawOrigin::None.into(),1601							_phantom: PhantomData::<u64>::default(),1602						}),1603					]1604				)1605			]);1606		});1607	}1608}