git.delta.rocks / unique-network / refs/commits / 90fcef986d5a

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	}891892	pub fn new_test_ext() -> sp_io::TestExternalities {893		let t = system::GenesisConfig::default().build_storage::<Test>().unwrap();894		t.into()895	}896897	fn run_to_block(n: u64) {898		while System::block_number() < n {899			Scheduler::on_finalize(System::block_number());900			System::set_block_number(System::block_number() + 1);901			Scheduler::on_initialize(System::block_number());902		}903	}904905	fn root() -> OriginCaller {906		system::RawOrigin::Root.into()907	}908909	#[test]910	fn basic_scheduling_works() {911		new_test_ext().execute_with(|| {912			let call = Call::Logger(logger::Call::log(42, 1000));913			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));914			assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call));915			run_to_block(3);916			assert!(logger::log().is_empty());917			run_to_block(4);918			assert_eq!(logger::log(), vec![(root(), 42u32)]);919			run_to_block(100);920			assert_eq!(logger::log(), vec![(root(), 42u32)]);921		});922	}923924	#[test]925	fn schedule_after_works() {926		new_test_ext().execute_with(|| {927			run_to_block(2);928			let call = Call::Logger(logger::Call::log(42, 1000));929			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));930			// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6931			assert_ok!(Scheduler::do_schedule(DispatchTime::After(3), None, 127, root(), call));932			run_to_block(5);933			assert!(logger::log().is_empty());934			run_to_block(6);935			assert_eq!(logger::log(), vec![(root(), 42u32)]);936			run_to_block(100);937			assert_eq!(logger::log(), vec![(root(), 42u32)]);938		});939	}940941	#[test]942	fn schedule_after_zero_works() {943		new_test_ext().execute_with(|| {944			run_to_block(2);945			let call = Call::Logger(logger::Call::log(42, 1000));946			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));947			assert_ok!(Scheduler::do_schedule(DispatchTime::After(0), None, 127, root(), call));948			// Will trigger on the next block.949			run_to_block(3);950			assert_eq!(logger::log(), vec![(root(), 42u32)]);951			run_to_block(100);952			assert_eq!(logger::log(), vec![(root(), 42u32)]);953		});954	}955956	#[test]957	fn periodic_scheduling_works() {958		new_test_ext().execute_with(|| {959			// at #4, every 3 blocks, 3 times.960			assert_ok!(Scheduler::do_schedule(961				DispatchTime::At(4), Some((3, 3)), 127, root(), Call::Logger(logger::Call::log(42, 1000))962			));963			run_to_block(3);964			assert!(logger::log().is_empty());965			run_to_block(4);966			assert_eq!(logger::log(), vec![(root(), 42u32)]);967			run_to_block(6);968			assert_eq!(logger::log(), vec![(root(), 42u32)]);969			run_to_block(7);970			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);971			run_to_block(9);972			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);973			run_to_block(10);974			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);975			run_to_block(100);976			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);977		});978	}979980	#[test]981	fn reschedule_works() {982		new_test_ext().execute_with(|| {983			let call = Call::Logger(logger::Call::log(42, 1000));984			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));985			assert_eq!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call).unwrap(), (4, 0));986987			run_to_block(3);988			assert!(logger::log().is_empty());989990			assert_eq!(Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(), (6, 0));991992			assert_noop!(Scheduler::do_reschedule((6, 0), DispatchTime::At(6)), Error::<Test>::RescheduleNoChange);993994			run_to_block(4);995			assert!(logger::log().is_empty());996997			run_to_block(6);998			assert_eq!(logger::log(), vec![(root(), 42u32)]);9991000			run_to_block(100);1001			assert_eq!(logger::log(), vec![(root(), 42u32)]);1002		});1003	}10041005	#[test]1006	fn reschedule_named_works() {1007		new_test_ext().execute_with(|| {1008			let call = Call::Logger(logger::Call::log(42, 1000));1009			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));1010			assert_eq!(Scheduler::do_schedule_named(1011				1u32.encode(), DispatchTime::At(4), None, 127, root(), call1012			).unwrap(), (4, 0));10131014			run_to_block(3);1015			assert!(logger::log().is_empty());10161017			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(), (6, 0));10181019			assert_noop!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)), Error::<Test>::RescheduleNoChange);10201021			run_to_block(4);1022			assert!(logger::log().is_empty());10231024			run_to_block(6);1025			assert_eq!(logger::log(), vec![(root(), 42u32)]);10261027			run_to_block(100);1028			assert_eq!(logger::log(), vec![(root(), 42u32)]);1029		});1030	}10311032	#[test]1033	fn reschedule_named_perodic_works() {1034		new_test_ext().execute_with(|| {1035			let call = Call::Logger(logger::Call::log(42, 1000));1036			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));1037			assert_eq!(Scheduler::do_schedule_named(1038				1u32.encode(), DispatchTime::At(4), Some((3, 3)), 127, root(), call1039			).unwrap(), (4, 0));10401041			run_to_block(3);1042			assert!(logger::log().is_empty());10431044			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(5)).unwrap(), (5, 0));1045			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(), (6, 0));10461047			run_to_block(5);1048			assert!(logger::log().is_empty());10491050			run_to_block(6);1051			assert_eq!(logger::log(), vec![(root(), 42u32)]);10521053			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(10)).unwrap(), (10, 0));10541055			run_to_block(9);1056			assert_eq!(logger::log(), vec![(root(), 42u32)]);10571058			run_to_block(10);1059			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);10601061			run_to_block(13);1062			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);10631064			run_to_block(100);1065			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);1066		});1067	}10681069	#[test]1070	fn cancel_named_scheduling_works_with_normal_cancel() {1071		new_test_ext().execute_with(|| {1072			// at #4.1073			Scheduler::do_schedule_named(1074				1u32.encode(), DispatchTime::At(4), None, 127, root(), Call::Logger(logger::Call::log(69, 1000))1075			).unwrap();1076			let i = Scheduler::do_schedule(1077				DispatchTime::At(4), None, 127, root(), Call::Logger(logger::Call::log(42, 1000))1078			).unwrap();1079			run_to_block(3);1080			assert!(logger::log().is_empty());1081			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1082			assert_ok!(Scheduler::do_cancel(None, i));1083			run_to_block(100);1084			assert!(logger::log().is_empty());1085		});1086	}10871088	#[test]1089	fn cancel_named_periodic_scheduling_works() {1090		new_test_ext().execute_with(|| {1091			// at #4, every 3 blocks, 3 times.1092			Scheduler::do_schedule_named(1093				1u32.encode(),1094				DispatchTime::At(4),1095				Some((3, 3)),1096				127,1097				root(),1098				Call::Logger(logger::Call::log(42, 1000))1099			).unwrap();1100			// same id results in error.1101			assert!(Scheduler::do_schedule_named(1102				1u32.encode(),1103				DispatchTime::At(4),1104				None,1105				127,1106				root(),1107				Call::Logger(logger::Call::log(69, 1000))1108			).is_err());1109			// different id is ok.1110			Scheduler::do_schedule_named(1111				2u32.encode(), DispatchTime::At(8), None, 127, root(), Call::Logger(logger::Call::log(69, 1000))1112			).unwrap();1113			run_to_block(3);1114			assert!(logger::log().is_empty());1115			run_to_block(4);1116			assert_eq!(logger::log(), vec![(root(), 42u32)]);1117			run_to_block(6);1118			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1119			run_to_block(100);1120			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1121		});1122	}11231124	#[test]1125	fn scheduler_respects_weight_limits() {1126		new_test_ext().execute_with(|| {1127			assert_ok!(Scheduler::do_schedule(1128				DispatchTime::At(4),1129				None,1130				127,1131				root(),1132				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1133			));1134			assert_ok!(Scheduler::do_schedule(1135				DispatchTime::At(4),1136				None,1137				127,1138				root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1139			));1140			// 69 and 42 do not fit together1141			run_to_block(4);1142			assert_eq!(logger::log(), vec![(root(), 42u32)]);1143			run_to_block(5);1144			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1145		});1146	}11471148	#[test]1149	fn scheduler_respects_hard_deadlines_more() {1150		new_test_ext().execute_with(|| {1151			assert_ok!(Scheduler::do_schedule(1152				DispatchTime::At(4),1153				None,1154				0,1155				root(),1156				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1157			));1158			assert_ok!(Scheduler::do_schedule(1159				DispatchTime::At(4),1160				None,1161				0,1162				root(),1163				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1164			));1165			// With base weights, 69 and 42 should not fit together, but do because of hard deadlines1166			run_to_block(4);1167			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1168		});1169	}11701171	#[test]1172	fn scheduler_respects_priority_ordering() {1173		new_test_ext().execute_with(|| {1174			assert_ok!(Scheduler::do_schedule(1175				DispatchTime::At(4),1176				None,1177				1,1178				root(),1179				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1180			));1181			assert_ok!(Scheduler::do_schedule(1182				DispatchTime::At(4),1183				None,1184				0,1185				root(),1186				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1187			));1188			run_to_block(4);1189			assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);1190		});1191	}11921193	#[test]1194	fn scheduler_respects_priority_ordering_with_soft_deadlines() {1195		new_test_ext().execute_with(|| {1196			assert_ok!(Scheduler::do_schedule(1197				DispatchTime::At(4),1198				None,1199				255,1200				root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1201			));1202			assert_ok!(Scheduler::do_schedule(1203				DispatchTime::At(4),1204				None,1205				127,1206				root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1207			));1208			assert_ok!(Scheduler::do_schedule(1209				DispatchTime::At(4),1210				None,1211				126,1212				root(), Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))1213			));12141215			// 2600 does not fit with 69 or 42, but has higher priority, so will go through1216			run_to_block(4);1217			assert_eq!(logger::log(), vec![(root(), 2600u32)]);1218			// 69 and 42 fit together1219			run_to_block(5);1220			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);1221		});1222	}12231224	#[test]1225	fn on_initialize_weight_is_correct() {1226		new_test_ext().execute_with(|| {1227			let base_weight: Weight = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);1228			let base_multiplier = 0;1229			let named_multiplier = <Test as frame_system::Config>::DbWeight::get().writes(1);1230			let periodic_multiplier = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 1);12311232			// Named1233			assert_ok!(1234				Scheduler::do_schedule_named(1235					1u32.encode(), DispatchTime::At(1), None, 255, root(),1236					Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))1237				)1238			);1239			// Anon Periodic1240			assert_ok!(Scheduler::do_schedule(1241				DispatchTime::At(1),1242				Some((1000, 3)),1243				128,1244				root(),1245				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1246			));1247			// Anon1248			assert_ok!(Scheduler::do_schedule(1249				DispatchTime::At(1),1250				None,1251				127,1252				root(),1253				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1254			));1255			// Named Periodic1256			assert_ok!(Scheduler::do_schedule_named(1257				2u32.encode(), DispatchTime::At(1), Some((1000, 3)), 126, root(),1258				Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2)))1259			);12601261			// Will include the named periodic only1262			let actual_weight = Scheduler::on_initialize(1);1263			let call_weight = MaximumSchedulerWeight::get() / 2;1264			assert_eq!(1265				actual_weight, call_weight + base_weight + base_multiplier + named_multiplier + periodic_multiplier1266			);1267			assert_eq!(logger::log(), vec![(root(), 2600u32)]);12681269			// Will include anon and anon periodic1270			let actual_weight = Scheduler::on_initialize(2);1271			let call_weight = MaximumSchedulerWeight::get() / 2 + MaximumSchedulerWeight::get() / 3;1272			assert_eq!(actual_weight, call_weight + base_weight + base_multiplier * 2 + periodic_multiplier);1273			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);12741275			// Will include named only1276			let actual_weight = Scheduler::on_initialize(3);1277			let call_weight = MaximumSchedulerWeight::get() / 3;1278			assert_eq!(actual_weight, call_weight + base_weight + base_multiplier + named_multiplier);1279			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32), (root(), 3u32)]);12801281			// Will contain none1282			let actual_weight = Scheduler::on_initialize(4);1283			assert_eq!(actual_weight, 0);1284		});1285	}12861287	#[test]1288	fn root_calls_works() {1289		new_test_ext().execute_with(|| {1290			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1291			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1292			assert_ok!(Scheduler::schedule_named(Origin::root(), 1u32.encode(), 4, None, 127, call));1293			assert_ok!(Scheduler::schedule(Origin::root(), 4, None, 127, call2));1294			run_to_block(3);1295			// Scheduled calls are in the agenda.1296			assert_eq!(Agenda::<Test>::get(4).len(), 2);1297			assert!(logger::log().is_empty());1298			assert_ok!(Scheduler::cancel_named(Origin::root(), 1u32.encode()));1299			assert_ok!(Scheduler::cancel(Origin::root(), 4, 1));1300			// Scheduled calls are made NONE, so should not effect state1301			run_to_block(100);1302			assert!(logger::log().is_empty());1303		});1304	}13051306	#[test]1307	fn fails_to_schedule_task_in_the_past() {1308		new_test_ext().execute_with(|| {1309			run_to_block(3);13101311			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1312			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));13131314			assert_err!(1315				Scheduler::schedule_named(Origin::root(), 1u32.encode(), 2, None, 127, call),1316				Error::<Test>::TargetBlockNumberInPast,1317			);13181319			assert_err!(1320				Scheduler::schedule(Origin::root(), 2, None, 127, call2.clone()),1321				Error::<Test>::TargetBlockNumberInPast,1322			);13231324			assert_err!(1325				Scheduler::schedule(Origin::root(), 3, None, 127, call2),1326				Error::<Test>::TargetBlockNumberInPast,1327			);1328		});1329	}13301331	#[test]1332	fn should_use_orign() {1333		new_test_ext().execute_with(|| {1334			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1335			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1336			assert_ok!(1337				Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)1338			);1339			assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));1340			run_to_block(3);1341			// Scheduled calls are in the agenda.1342			assert_eq!(Agenda::<Test>::get(4).len(), 2);1343			assert!(logger::log().is_empty());1344			assert_ok!(Scheduler::cancel_named(system::RawOrigin::Signed(1).into(), 1u32.encode()));1345			assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));1346			// Scheduled calls are made NONE, so should not effect state1347			run_to_block(100);1348			assert!(logger::log().is_empty());1349		});1350	}13511352	#[test]1353	fn should_check_orign() {1354		new_test_ext().execute_with(|| {1355			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1356			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1357			assert_noop!(1358				Scheduler::schedule_named(system::RawOrigin::Signed(2).into(), 1u32.encode(), 4, None, 127, call),1359				BadOrigin1360			);1361			assert_noop!(Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2), BadOrigin);1362		});1363	}13641365	#[test]1366	fn should_check_orign_for_cancel() {1367		new_test_ext().execute_with(|| {1368			let call = Box::new(Call::Logger(logger::Call::log_without_filter(69, 1000)));1369			let call2 = Box::new(Call::Logger(logger::Call::log_without_filter(42, 1000)));1370			assert_ok!(1371				Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)1372			);1373			assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));1374			run_to_block(3);1375			// Scheduled calls are in the agenda.1376			assert_eq!(Agenda::<Test>::get(4).len(), 2);1377			assert!(logger::log().is_empty());1378			assert_noop!(Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()), BadOrigin);1379			assert_noop!(Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1), BadOrigin);1380			assert_noop!(Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()), BadOrigin);1381			assert_noop!(Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1), BadOrigin);1382			run_to_block(5);1383			assert_eq!(1384				logger::log(),1385				vec![(system::RawOrigin::Signed(1).into(), 69u32), (system::RawOrigin::Signed(1).into(), 42u32)]1386			);1387		});1388	}13891390	#[test]1391	fn migration_to_v2_works() {1392		new_test_ext().execute_with(|| {1393			for i in 0..3u64 {1394				let k = i.twox_64_concat();1395				let old = vec![1396					Some(ScheduledV1 {1397						maybe_id: None,1398						priority: i as u8 + 10,1399						call: Call::Logger(logger::Call::log(96, 100)),1400						maybe_periodic: None,1401					}),1402					None,1403					Some(ScheduledV1 {1404						maybe_id: Some(b"test".to_vec()),1405						priority: 123,1406						call: Call::Logger(logger::Call::log(69, 1000)),1407						maybe_periodic: Some((456u64, 10)),1408					}),1409				];1410				frame_support::migration::put_storage_value(1411					b"Scheduler",1412					b"Agenda",1413					&k,1414					old,1415				);1416			}14171418			assert_eq!(StorageVersion::get(), Releases::V1);14191420			assert!(Scheduler::migrate_v1_to_t2());14211422			assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![1423				(1424					0,1425					vec![1426					Some(ScheduledV2 {1427						maybe_id: None,1428						priority: 10,1429						call: Call::Logger(logger::Call::log(96, 100)),1430						maybe_periodic: None,1431						origin: root(),1432						_phantom: PhantomData::<u64>::default(),1433					}),1434					None,1435					Some(ScheduledV2 {1436						maybe_id: Some(b"test".to_vec()),1437						priority: 123,1438						call: Call::Logger(logger::Call::log(69, 1000)),1439						maybe_periodic: Some((456u64, 10)),1440						origin: root(),1441						_phantom: PhantomData::<u64>::default(),1442					}),1443				]),1444				(1445					1,1446					vec![1447						Some(ScheduledV2 {1448							maybe_id: None,1449							priority: 11,1450							call: Call::Logger(logger::Call::log(96, 100)),1451							maybe_periodic: None,1452							origin: root(),1453							_phantom: PhantomData::<u64>::default(),1454						}),1455						None,1456						Some(ScheduledV2 {1457							maybe_id: Some(b"test".to_vec()),1458							priority: 123,1459							call: Call::Logger(logger::Call::log(69, 1000)),1460							maybe_periodic: Some((456u64, 10)),1461							origin: root(),1462							_phantom: PhantomData::<u64>::default(),1463						}),1464					]1465				),1466				(1467					2,1468					vec![1469						Some(ScheduledV2 {1470							maybe_id: None,1471							priority: 12,1472							call: Call::Logger(logger::Call::log(96, 100)),1473							maybe_periodic: None,1474							origin: root(),1475							_phantom: PhantomData::<u64>::default(),1476						}),1477						None,1478						Some(ScheduledV2 {1479							maybe_id: Some(b"test".to_vec()),1480							priority: 123,1481							call: Call::Logger(logger::Call::log(69, 1000)),1482							maybe_periodic: Some((456u64, 10)),1483							origin: root(),1484							_phantom: PhantomData::<u64>::default(),1485						}),1486					]1487				)1488			]);14891490			assert_eq!(StorageVersion::get(), Releases::V2);1491		});1492	}14931494	#[test]1495	fn test_migrate_origin() {1496		new_test_ext().execute_with(|| {1497			for i in 0..3u64 {1498				let k = i.twox_64_concat();1499				let old: Vec<Option<Scheduled<_, _, u32, u64>>> = vec![1500					Some(Scheduled {1501						maybe_id: None,1502						priority: i as u8 + 10,1503						call: Call::Logger(logger::Call::log(96, 100)),1504						origin: 3u32,1505						maybe_periodic: None,1506						_phantom: Default::default(),1507					}),1508					None,1509					Some(Scheduled {1510						maybe_id: Some(b"test".to_vec()),1511						priority: 123,1512						origin: 2u32,1513						call: Call::Logger(logger::Call::log(69, 1000)),1514						maybe_periodic: Some((456u64, 10)),1515						_phantom: Default::default(),1516					}),1517				];1518				frame_support::migration::put_storage_value(1519					b"Scheduler",1520					b"Agenda",1521					&k,1522					old,1523				);1524			}15251526			impl Into<OriginCaller> for u32 {1527				fn into(self) -> OriginCaller {1528					match self {1529						3u32 => system::RawOrigin::Root.into(),1530						2u32 => system::RawOrigin::None.into(),1531						_ => unreachable!("test make no use of it"),1532					}1533				}1534			}15351536			Scheduler::migrate_origin::<u32>();15371538			assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![1539				(1540					0,1541					vec![1542					Some(ScheduledV2::<_, _, OriginCaller, u64> {1543						maybe_id: None,1544						priority: 10,1545						call: Call::Logger(logger::Call::log(96, 100)),1546						maybe_periodic: None,1547						origin: system::RawOrigin::Root.into(),1548						_phantom: PhantomData::<u64>::default(),1549					}),1550					None,1551					Some(ScheduledV2 {1552						maybe_id: Some(b"test".to_vec()),1553						priority: 123,1554						call: Call::Logger(logger::Call::log(69, 1000)),1555						maybe_periodic: Some((456u64, 10)),1556						origin: system::RawOrigin::None.into(),1557						_phantom: PhantomData::<u64>::default(),1558					}),1559				]),1560				(1561					1,1562					vec![1563						Some(ScheduledV2 {1564							maybe_id: None,1565							priority: 11,1566							call: Call::Logger(logger::Call::log(96, 100)),1567							maybe_periodic: None,1568							origin: system::RawOrigin::Root.into(),1569							_phantom: PhantomData::<u64>::default(),1570						}),1571						None,1572						Some(ScheduledV2 {1573							maybe_id: Some(b"test".to_vec()),1574							priority: 123,1575							call: Call::Logger(logger::Call::log(69, 1000)),1576							maybe_periodic: Some((456u64, 10)),1577							origin: system::RawOrigin::None.into(),1578							_phantom: PhantomData::<u64>::default(),1579						}),1580					]1581				),1582				(1583					2,1584					vec![1585						Some(ScheduledV2 {1586							maybe_id: None,1587							priority: 12,1588							call: Call::Logger(logger::Call::log(96, 100)),1589							maybe_periodic: None,1590							origin: system::RawOrigin::Root.into(),1591							_phantom: PhantomData::<u64>::default(),1592						}),1593						None,1594						Some(ScheduledV2 {1595							maybe_id: Some(b"test".to_vec()),1596							priority: 123,1597							call: Call::Logger(logger::Call::log(69, 1000)),1598							maybe_periodic: Some((456u64, 10)),1599							origin: system::RawOrigin::None.into(),1600							_phantom: PhantomData::<u64>::default(),1601						}),1602					]1603				)1604			]);1605		});1606	}1607}