git.delta.rocks / unique-network / refs/commits / 73e89cc4a2f1

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};67use pallet_nft::*;68// use pallet_nft_transaction_payment::{self as nft_transaction_payment};69use nft_data_structs::*;70pub use weights::WeightInfo;7172/// Our pallet's configuration trait. All our types and constants go in here. If the73/// pallet is dependent on specific other pallets, then their configuration traits74/// should be added to our implied traits list.75///76/// `system::Config` should always be included in our implied traits.77/// // 78pub trait Config: system::Config79{ 8081	/// The overarching event type.82	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;8384	/// The aggregated origin which the dispatch will take.85	type Origin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>86		+ From<Self::PalletsOrigin> + IsType<<Self as system::Config>::Origin>;8788	/// The caller origin, overarching type of all pallets origins.89	type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + Clone + Eq;9091	/// The aggregated call type.92	type Call: Parameter + Dispatchable<Origin=<Self as Config>::Origin> + GetDispatchInfo + From<system::Call<Self>>;9394	/// The maximum weight that may be scheduled per block for any dispatchables of less priority95	/// than `schedule::HARD_DEADLINE`.96	type MaximumWeight: Get<Weight>;9798	/// Required origin to schedule or cancel calls.99	type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::Origin>;100101	/// The maximum number of scheduled calls in the queue for a single block.102	/// Not strictly enforced, but used for weight estimation.103	type MaxScheduledPerBlock: Get<u32>;104105	/// Sponsoring function106	type Sponsoring: SponsoringResolve<Self::AccountId, <Self as Config>::Call>;107108	/// Weight information for extrinsics in this pallet.109	type WeightInfo: WeightInfo;110}111112// pub type SelfWeightInfo<T> = <T as system::Config>::WeightInfo;113114/// Just a simple index for naming period tasks.115pub type PeriodicIndex = u32;116/// The location of a scheduled task that can be used to remove it.117pub type TaskAddress<BlockNumber> = (BlockNumber, u32);118119#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]120#[derive(Clone, RuntimeDebug, Encode, Decode)]121struct ScheduledV1<Call, BlockNumber> {122	maybe_id: Option<Vec<u8>>,123	priority: schedule::Priority,124	call: Call,125	maybe_periodic: Option<schedule::Period<BlockNumber>>,126}127128/// Information regarding an item to be executed in the future.129#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]130#[derive(Clone, RuntimeDebug, Encode, Decode)]131pub struct ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId> {132	/// The unique identity for this task, if there is one.133	maybe_id: Option<Vec<u8>>,134	/// This task's priority.135	priority: schedule::Priority,136	/// The call to be dispatched.137	call: Call,138	/// If the call is periodic, then this points to the information concerning that.139	maybe_periodic: Option<schedule::Period<BlockNumber>>,140	/// The origin to dispatch the call.141	origin: PalletsOrigin,142	_phantom: PhantomData<AccountId>,143}144145/// The current version of Scheduled struct.146pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> = ScheduledV2<Call, BlockNumber, PalletsOrigin, AccountId>;147148// A value placed in storage that represents the current version of the Scheduler storage.149// This value is used by the `on_runtime_upgrade` logic to determine whether we run150// storage migration logic.151#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug)]152enum Releases {153	V1,154	V2,155}156157impl Default for Releases {158	fn default() -> Self {159		Releases::V1160	}161}162163#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug)]164pub struct CallSpec {165166	module: u32,167	method: u32,168}169170decl_storage! {171	trait Store for Module<T: Config> as Scheduler {172		/// Items to be executed, indexed by the block number that they should be executed on.173		pub Agenda: map hasher(twox_64_concat) T::BlockNumber174			=> Vec<Option<Scheduled<<T as Config>::Call, T::BlockNumber, T::PalletsOrigin, T::AccountId>>>;175176		pub SpecAgenda: map hasher(twox_64_concat) T::BlockNumber177			=> Vec<Option<CallSpec>>;			178179		/// Lookup from identity to the block number and index of the task.180		Lookup: map hasher(twox_64_concat) Vec<u8> => Option<TaskAddress<T::BlockNumber>>;181182		/// Storage version of the pallet.183		///184		/// New networks start with last version.185		StorageVersion build(|_| Releases::V2): Releases;186	}187}188189decl_event!(190	pub enum Event<T> where <T as system::Config>::BlockNumber {191		/// Scheduled some task. \[when, index\]192		Scheduled(BlockNumber, u32),193		/// Canceled some task. \[when, index\]194		Canceled(BlockNumber, u32),195		/// Dispatched some task. \[task, id, result\]196		Dispatched(TaskAddress<BlockNumber>, Option<Vec<u8>>, DispatchResult),197	}198);199200decl_error! {201	pub enum Error for Module<T: Config> {202		/// Failed to schedule a call203		FailedToSchedule,204		/// Cannot find the scheduled call.205		NotFound,206		/// Given target block number is in the past.207		TargetBlockNumberInPast,208		/// Reschedule failed because it does not change scheduled time.209		RescheduleNoChange,210	}211}212213decl_module! {214	/// Scheduler module declaration.215	pub struct Module<T: Config> for enum Call 216	where 217		origin: <T as system::Config>::Origin218	{219		type Error = Error<T>;220		fn deposit_event() = default;221222223		/// Anonymously schedule a task.224		///225		/// # <weight>226		/// - S = Number of already scheduled calls227		/// - Base Weight: 22.29 + .126 * S µs228		/// - DB Weight:229		///     - Read: Agenda230		///     - Write: Agenda231		/// - Will use base weight of 25 which should be good for up to 30 scheduled calls232		/// # </weight>233		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]234		fn schedule(origin,235			when: T::BlockNumber,236			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,237			priority: schedule::Priority,238			call: Box<<T as Config>::Call>,239		) 240		{241			let origin = <T as Config>::Origin::from(origin);242			Self::do_schedule(DispatchTime::At(when), maybe_periodic, priority, origin.caller().clone(), *call)?;243		}244245		/// Cancel an anonymously scheduled task.246		///247		/// # <weight>248		/// - S = Number of already scheduled calls249		/// - Base Weight: 22.15 + 2.869 * S µs250		/// - DB Weight:251		///     - Read: Agenda252		///     - Write: Agenda, Lookup253		/// - Will use base weight of 100 which should be good for up to 30 scheduled calls254		/// # </weight>255		#[weight = <T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get())]256		fn cancel(origin, when: T::BlockNumber, index: u32) {257			T::ScheduleOrigin::ensure_origin(origin.clone())?;258			let origin = <T as Config>::Origin::from(origin);259			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;260		}261262		/// Schedule a named task.263		///264		/// # <weight>265		/// - S = Number of already scheduled calls266		/// - Base Weight: 29.6 + .159 * S µs267		/// - DB Weight:268		///     - Read: Agenda, Lookup269		///     - Write: Agenda, Lookup270		/// - Will use base weight of 35 which should be good for more than 30 scheduled calls271		/// # </weight>272		#[weight = <T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get())]273		fn schedule_named(origin,274			id: Vec<u8>,275			when: T::BlockNumber,276			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,277			priority: schedule::Priority,278			call: Box<<T as Config>::Call>,279		) {280			T::ScheduleOrigin::ensure_origin(origin.clone())?;281			let origin = <T as Config>::Origin::from(origin);282			Self::do_schedule_named(283				id, DispatchTime::At(when), maybe_periodic, priority, origin.caller().clone(), *call284			)?;285		}286287		/// Cancel a named scheduled task.288		///289		/// # <weight>290		/// - S = Number of already scheduled calls291		/// - Base Weight: 24.91 + 2.907 * S µs292		/// - DB Weight:293		///     - Read: Agenda, Lookup294		///     - Write: Agenda, Lookup295		/// - Will use base weight of 100 which should be good for up to 30 scheduled calls296		/// # </weight>297		#[weight = <T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get())]298		fn cancel_named(origin, id: Vec<u8>) {299			T::ScheduleOrigin::ensure_origin(origin.clone())?;300			let origin = <T as Config>::Origin::from(origin);301			Self::do_cancel_named(Some(origin.caller().clone()), id)?;302		}303304		/// Anonymously schedule a task after a delay.305		///306		/// # <weight>307		/// Same as [`schedule`].308		/// # </weight>309		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]310		fn schedule_after(origin,311			after: T::BlockNumber,312			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,313			priority: schedule::Priority,314			call: Box<<T as Config>::Call>,315		) {316			T::ScheduleOrigin::ensure_origin(origin.clone())?;317			let origin = <T as Config>::Origin::from(origin);318			Self::do_schedule(319				DispatchTime::After(after), maybe_periodic, priority, origin.caller().clone(), *call320			)?;321		}322323		/// Schedule a named task after a delay.324		///325		/// # <weight>326		/// Same as [`schedule_named`].327		/// # </weight>328		#[weight = <T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get())]329		fn schedule_named_after(origin,330			id: Vec<u8>,331			after: T::BlockNumber,332			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,333			priority: schedule::Priority,334			call: Box<<T as Config>::Call>,335		) {336			T::ScheduleOrigin::ensure_origin(origin.clone())?;337			let origin = <T as Config>::Origin::from(origin);338			Self::do_schedule_named(339				id, DispatchTime::After(after), maybe_periodic, priority, origin.caller().clone(), *call340			)?;341		}342343		/// Execute the scheduled calls344		///345		/// # <weight>346		/// - S = Number of already scheduled calls347		/// - N = Named scheduled calls348		/// - P = Periodic Calls349		/// - Base Weight: 9.243 + 23.45 * S µs350		/// - DB Weight:351		///     - Read: Agenda + Lookup * N + Agenda(Future) * P352		///     - Write: Agenda + Lookup * N  + Agenda(future) * P353		/// # </weight>354		fn on_initialize(now: T::BlockNumber) -> Weight {355			let limit = T::MaximumWeight::get();356			let mut queued = Agenda::<T>::take(now).into_iter()357				.enumerate()358				.filter_map(|(index, s)| s.map(|inner| (index as u32, inner)))359				.collect::<Vec<_>>();360			if queued.len() as u32 > T::MaxScheduledPerBlock::get() {361				log::warn!(362					target: "runtime::scheduler",363					"Warning: This block has more items queued in Scheduler than \364					expected from the runtime configuration. An update might be needed."365				);366			}367			queued.sort_by_key(|(_, s)| s.priority);368			let base_weight: Weight = T::DbWeight::get().reads_writes(1, 2); // Agenda + Agenda(next)369			let mut total_weight: Weight = 0;370			queued.into_iter()371				.enumerate()372				.scan(base_weight, |cumulative_weight, (order, (index, s))| {373					*cumulative_weight = cumulative_weight374						.saturating_add(s.call.get_dispatch_info().weight);375376					let origin = <<T as Config>::Origin as From<T::PalletsOrigin>>::from(377						s.origin.clone()378					).into();379380					if ensure_signed(origin).is_ok() {381						 // AccountData for inner call origin accountdata.382						*cumulative_weight = cumulative_weight383							.saturating_add(T::DbWeight::get().reads_writes(1, 1));384					}385386					if s.maybe_id.is_some() {387						// Remove/Modify Lookup388						*cumulative_weight = cumulative_weight.saturating_add(T::DbWeight::get().writes(1));389					}390					if s.maybe_periodic.is_some() {391						// Read/Write Agenda for future block392						*cumulative_weight = cumulative_weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));393					}394395					Some((order, index, *cumulative_weight, s))396				})397				.filter_map(|(order, index, cumulative_weight, mut s)| {398					// We allow a scheduled call if any is true:399					// - It's priority is `HARD_DEADLINE`400					// - It does not push the weight past the limit.401					// - It is the first item in the schedule402					if s.priority <= schedule::HARD_DEADLINE || cumulative_weight <= limit || order == 0 {403404						let origin = <<T as Config>::Origin as From<T::PalletsOrigin>>::from(405							s.origin.clone()406						).into();407						let sender = ensure_signed(origin).unwrap_or(T::AccountId::default());408						let who_will_pay = T::Sponsoring::resolve(&sender, &s.call.clone()).unwrap_or(409							sender);410						let sponsor = T::PalletsOrigin::from(system::RawOrigin::Signed(who_will_pay));411						let r = s.call.clone().dispatch(sponsor.into());412						let maybe_id = s.maybe_id.clone();413						if let &Some((period, count)) = &s.maybe_periodic {414							if count > 1 {415								s.maybe_periodic = Some((period, count - 1));416							} else {417								s.maybe_periodic = None;418							}419							let next = now + period;420							// If scheduled is named, place it's information in `Lookup`421							if let Some(ref id) = s.maybe_id {422								let next_index = Agenda::<T>::decode_len(now + period).unwrap_or(0);423								Lookup::<T>::insert(id, (next, next_index as u32));424							}425							Agenda::<T>::append(next, Some(s));426						} else {427							if let Some(ref id) = s.maybe_id {428								Lookup::<T>::remove(id);429							}430						}431						Self::deposit_event(RawEvent::Dispatched(432							(now, index),433							maybe_id,434							r.map(|_| ()).map_err(|e| e.error)435						));436						total_weight = cumulative_weight;437						None438					} else {439						Some(Some(s))440					}441				})442				.for_each(|unused| {443					let next = now + One::one();444					Agenda::<T>::append(next, unused);445				});446447			total_weight448		}449	}450}451452impl<T: Config> Module<T> {453	/// Migrate storage format from V1 to V2.454	/// Return true if migration is performed.455	pub fn migrate_v1_to_t2() -> bool {456		if StorageVersion::get() == Releases::V1 {457			StorageVersion::put(Releases::V2);458459			Agenda::<T>::translate::<460				Vec<Option<ScheduledV1<<T as Config>::Call, T::BlockNumber>>>, _461			>(|_, agenda| Some(462				agenda463					.into_iter()464					.map(|schedule| schedule.map(|schedule| ScheduledV2 {465						maybe_id: schedule.maybe_id,466						priority: schedule.priority,467						call: schedule.call,468						maybe_periodic: schedule.maybe_periodic,469						origin: system::RawOrigin::Root.into(),470						_phantom: Default::default(),471					}))472					.collect::<Vec<_>>()473			));474475			true476		} else {477			false478		}479	}480481	/// Helper to migrate scheduler when the pallet origin type has changed.482	pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {483		Agenda::<T>::translate::<484			Vec<Option<Scheduled<<T as Config>::Call, T::BlockNumber, OldOrigin, T::AccountId>>>, _485		>(|_, agenda| Some(486			agenda487				.into_iter()488				.map(|schedule| schedule.map(|schedule| Scheduled {489					maybe_id: schedule.maybe_id,490					priority: schedule.priority,491					call: schedule.call,492					maybe_periodic: schedule.maybe_periodic,493					origin: schedule.origin.into(),494					_phantom: Default::default(),495				}))496				.collect::<Vec<_>>()497		));498	}499500	fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {501		let now = frame_system::Pallet::<T>::block_number();502503		let when = match when {504			DispatchTime::At(x) => x,505			// The current block has already completed it's scheduled tasks, so506			// Schedule the task at lest one block after this current block.507			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one())508		};509510		if when <= now {511			return Err(Error::<T>::TargetBlockNumberInPast.into())512		}513514		Ok(when)515	}516517	fn do_schedule(518		when: DispatchTime<T::BlockNumber>,519		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,520		priority: schedule::Priority,521		origin: T::PalletsOrigin,522		call: <T as Config>::Call523	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {524		let when = Self::resolve_time(when)?;525526		// sanitize maybe_periodic527		let maybe_periodic = maybe_periodic528			.filter(|p| p.1 > 1 && !p.0.is_zero())529			// Remove one from the number of repetitions since we will schedule one now.530			.map(|(p, c)| (p, c - 1));531		let s = Some(Scheduled {532			maybe_id: None, priority, call, maybe_periodic, origin, _phantom: PhantomData::<T::AccountId>::default(),533		});534		Agenda::<T>::append(when, s);535		let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;536		if index > T::MaxScheduledPerBlock::get() {537			log::warn!(538				target: "runtime::scheduler",539				"Warning: There are more items queued in the Scheduler than \540				expected from the runtime configuration. An update might be needed.",541			);542		}543		Self::deposit_event(RawEvent::Scheduled(when, index));544545		Ok((when, index))546	}547548	fn do_cancel(549		origin: Option<T::PalletsOrigin>,550		(when, index): TaskAddress<T::BlockNumber>551	) -> Result<(), DispatchError> {552		let scheduled = Agenda::<T>::try_mutate(553			when,554			|agenda| {555				agenda.get_mut(index as usize)556					.map_or(Ok(None), |s| -> Result<Option<Scheduled<_, _, _, _>>, DispatchError> {557						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {558							if *o != s.origin {559								return Err(BadOrigin.into());560							}561						};562						Ok(s.take())563					})564			},565		)?;566		if let Some(s) = scheduled {567			if let Some(id) = s.maybe_id {568				Lookup::<T>::remove(id);569			}570			Self::deposit_event(RawEvent::Canceled(when, index));571			Ok(())572		} else {573			Err(Error::<T>::NotFound)?574		}575	}576577	fn do_reschedule(578		(when, index): TaskAddress<T::BlockNumber>,579		new_time: DispatchTime<T::BlockNumber>,580	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {581		let new_time = Self::resolve_time(new_time)?;582583		if new_time == when {584			return Err(Error::<T>::RescheduleNoChange.into());585		}586587		Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {588			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;589			let task = task.take().ok_or(Error::<T>::NotFound)?;590			Agenda::<T>::append(new_time, Some(task));591			Ok(())592		})?;593594		let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;595		Self::deposit_event(RawEvent::Canceled(when, index));596		Self::deposit_event(RawEvent::Scheduled(new_time, new_index));597598		Ok((new_time, new_index))599	}600601	fn do_schedule_named(602		id: Vec<u8>,603		when: DispatchTime<T::BlockNumber>,604		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,605		priority: schedule::Priority,606		origin: T::PalletsOrigin,607		call: <T as Config>::Call,608	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {609		// ensure id it is unique610		if Lookup::<T>::contains_key(&id) {611			return Err(Error::<T>::FailedToSchedule)?612		}613614		let when = Self::resolve_time(when)?;615616		// sanitize maybe_periodic617		let maybe_periodic = maybe_periodic618			.filter(|p| p.1 > 1 && !p.0.is_zero())619			// Remove one from the number of repetitions since we will schedule one now.620			.map(|(p, c)| (p, c - 1));621622		let s = Scheduled {623			maybe_id: Some(id.clone()), priority, call, maybe_periodic, origin, _phantom: Default::default()624		};625		Agenda::<T>::append(when, Some(s));626		let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;627		if index > T::MaxScheduledPerBlock::get() {628			log::warn!(629				target: "runtime::scheduler",630				"Warning: There are more items queued in the Scheduler than \631				expected from the runtime configuration. An update might be needed.",632			);633		}634		let address = (when, index);635		Lookup::<T>::insert(&id, &address);636		Self::deposit_event(RawEvent::Scheduled(when, index));637638		Ok(address)639	}640641	fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: Vec<u8>) -> DispatchResult {642		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {643			if let Some((when, index)) = lookup.take() {644				let i = index as usize;645				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {646					if let Some(s) = agenda.get_mut(i) {647						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {648							if *o != s.origin {649								return Err(BadOrigin.into());650							}651						}652						*s = None;653					}654					Ok(())655				})?;656				Self::deposit_event(RawEvent::Canceled(when, index));657				Ok(())658			} else {659				Err(Error::<T>::NotFound)?660			}661		})662	}663664	fn do_reschedule_named(665		id: Vec<u8>,666		new_time: DispatchTime<T::BlockNumber>,667	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {668		let new_time = Self::resolve_time(new_time)?;669670		Lookup::<T>::try_mutate_exists(id, |lookup| -> Result<TaskAddress<T::BlockNumber>, DispatchError> {671			let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;672673			if new_time == when {674				return Err(Error::<T>::RescheduleNoChange.into());675			}676677			Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {678				let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;679				let task = task.take().ok_or(Error::<T>::NotFound)?;680				Agenda::<T>::append(new_time, Some(task));681682				Ok(())683			})?;684685			let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;686			Self::deposit_event(RawEvent::Canceled(when, index));687			Self::deposit_event(RawEvent::Scheduled(new_time, new_index));688689			*lookup = Some((new_time, new_index));690691			Ok((new_time, new_index))692		})693	}694}695696impl<T: Config> schedule::Anon<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin> for Module<T> {697	type Address = TaskAddress<T::BlockNumber>;698699	fn schedule(700		when: DispatchTime<T::BlockNumber>,701		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,702		priority: schedule::Priority,703		origin: T::PalletsOrigin,704		call: <T as Config>::Call705	) -> Result<Self::Address, DispatchError> {706		Self::do_schedule(when, maybe_periodic, priority, origin, call)707	}708709	fn cancel((when, index): Self::Address) -> Result<(), ()> {710		Self::do_cancel(None, (when, index)).map_err(|_| ())711	}712713	fn reschedule(714		address: Self::Address,715		when: DispatchTime<T::BlockNumber>,716	) -> Result<Self::Address, DispatchError> {717		Self::do_reschedule(address, when)718	}719720	fn next_dispatch_time((when, index): Self::Address) -> Result<T::BlockNumber, ()> {721		Agenda::<T>::get(when).get(index as usize).ok_or(()).map(|_| when)722	}723}724725impl<T: Config> schedule::Named<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin> for Module<T> {726	type Address = TaskAddress<T::BlockNumber>;727728	fn schedule_named(729		id: Vec<u8>,730		when: DispatchTime<T::BlockNumber>,731		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,732		priority: schedule::Priority,733		origin: T::PalletsOrigin,734		call: <T as Config>::Call,735	) -> Result<Self::Address, ()> {736		Self::do_schedule_named(id, when, maybe_periodic, priority, origin, call).map_err(|_| ())737	}738739	fn cancel_named(id: Vec<u8>) -> Result<(), ()> {740		Self::do_cancel_named(None, id).map_err(|_| ())741	}742743	fn reschedule_named(744		id: Vec<u8>,745		when: DispatchTime<T::BlockNumber>,746	) -> Result<Self::Address, DispatchError> {747		Self::do_reschedule_named(id, when)748	}749750	fn next_dispatch_time(id: Vec<u8>) -> Result<T::BlockNumber, ()> {751		Lookup::<T>::get(id).and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when)).ok_or(())752	}753}754755#[cfg(test)]756mod tests {757	use super::*;758759	use frame_support::{760		parameter_types, assert_ok, ord_parameter_types,761		assert_noop, assert_err, Hashable,762		traits::{OnInitialize, OnFinalize, Filter},763		weights::constants::RocksDbWeight,764	};765	use sp_core::H256;766	use sp_runtime::{767		Perbill,768		testing::Header,769		traits::{BlakeTwo256, IdentityLookup},770	};771	use frame_system::{EnsureOneOf, EnsureRoot, EnsureSignedBy};772	use substrate_test_utils::assert_eq_uvec;773	use crate as scheduler;774775	mod logger {776		use super::*;777		use std::cell::RefCell;778779		thread_local! {780			static LOG: RefCell<Vec<(OriginCaller, u32)>> = RefCell::new(Vec::new());781		}782		pub fn log() -> Vec<(OriginCaller, u32)> {783			LOG.with(|log| log.borrow().clone())784		}785		pub trait Config: system::Config {786			type Event: From<Event> + Into<<Self as system::Config>::Event>;787		}788		decl_event! {789			pub enum Event {790				Logged(u32, Weight),791			}792		}793		decl_module! {794			pub struct Module<T: Config> for enum Call795			where796				origin: <T as system::Config>::Origin,797				<T as system::Config>::Origin: OriginTrait<PalletsOrigin = OriginCaller>798			{799				fn deposit_event() = default;800801				#[weight = *weight]802				fn log(origin, i: u32, weight: Weight) {803					Self::deposit_event(Event::Logged(i, weight));804					LOG.with(|log| {805						log.borrow_mut().push((origin.caller().clone(), i));806					})807				}808809				#[weight = *weight]810				fn log_without_filter(origin, i: u32, weight: Weight) {811					Self::deposit_event(Event::Logged(i, weight));812					LOG.with(|log| {813						log.borrow_mut().push((origin.caller().clone(), i));814					})815				}816			}817		}818	}819820	type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;821	type Block = frame_system::mocking::MockBlock<Test>;822823	frame_support::construct_runtime!(824		pub enum Test where825			Block = Block,826			NodeBlock = Block,827			UncheckedExtrinsic = UncheckedExtrinsic,828		{829			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},830			Logger: logger::{Pallet, Call, Event},831			Scheduler: scheduler::{Pallet, Call, Storage, Event<T>},832		}833	);834835	// Scheduler must dispatch with root and no filter, this tests base filter is indeed not used.836	pub struct BaseFilter;837	impl Filter<Call> for BaseFilter {838		fn filter(call: &Call) -> bool {839			!matches!(call, Call::Logger(logger::Call::log(_, _)))840		}841	}842843	parameter_types! {844		pub const BlockHashCount: u64 = 250;845		pub BlockWeights: frame_system::limits::BlockWeights =846			frame_system::limits::BlockWeights::simple_max(2_000_000_000_000);847	}848	impl system::Config for Test {849		type BaseCallFilter = BaseFilter;850		type BlockWeights = ();851		type BlockLength = ();852		type DbWeight = RocksDbWeight;853		type Origin = Origin;854		type Call = Call;855		type Index = u64;856		type BlockNumber = u64;857		type Hash = H256;858		type Hashing = BlakeTwo256;859		type AccountId = u64;860		type Lookup = IdentityLookup<Self::AccountId>;861		type Header = Header;862		type Event = Event;863		type BlockHashCount = BlockHashCount;864		type Version = ();865		type PalletInfo = PalletInfo;866		type AccountData = ();867		type OnNewAccount = ();868		type OnKilledAccount = ();869		type SystemWeightInfo = ();870		type SS58Prefix = ();871		type OnSetCode = ();872	}873	impl logger::Config for Test {874		type Event = Event;875	}876	parameter_types! {877		pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * BlockWeights::get().max_block;878		pub const MaxScheduledPerBlock: u32 = 10;879	}880	ord_parameter_types! {881		pub const One: u64 = 1;882	}883884	impl Config for Test {885		type Event = Event;886		type Origin = Origin;887		type PalletsOrigin = OriginCaller;888		type Call = Call;889		type MaximumWeight = MaximumSchedulerWeight;890		type ScheduleOrigin = EnsureOneOf<u64, EnsureRoot<u64>, EnsureSignedBy<One, u64>>;891		type MaxScheduledPerBlock = MaxScheduledPerBlock;892		type WeightInfo = ();893	}894895	pub fn new_test_ext() -> sp_io::TestExternalities {896		let t = system::GenesisConfig::default().build_storage::<Test>().unwrap();897		t.into()898	}899900	fn run_to_block(n: u64) {901		while System::block_number() < n {902			Scheduler::on_finalize(System::block_number());903			System::set_block_number(System::block_number() + 1);904			Scheduler::on_initialize(System::block_number());905		}906	}907908	fn root() -> OriginCaller {909		system::RawOrigin::Root.into()910	}911912	#[test]913	fn basic_scheduling_works() {914		new_test_ext().execute_with(|| {915			let call = Call::Logger(logger::Call::log(42, 1000));916			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));917			assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call));918			run_to_block(3);919			assert!(logger::log().is_empty());920			run_to_block(4);921			assert_eq!(logger::log(), vec![(root(), 42u32)]);922			run_to_block(100);923			assert_eq!(logger::log(), vec![(root(), 42u32)]);924		});925	}926927	#[test]928	fn schedule_after_works() {929		new_test_ext().execute_with(|| {930			run_to_block(2);931			let call = Call::Logger(logger::Call::log(42, 1000));932			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));933			// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6934			assert_ok!(Scheduler::do_schedule(DispatchTime::After(3), None, 127, root(), call));935			run_to_block(5);936			assert!(logger::log().is_empty());937			run_to_block(6);938			assert_eq!(logger::log(), vec![(root(), 42u32)]);939			run_to_block(100);940			assert_eq!(logger::log(), vec![(root(), 42u32)]);941		});942	}943944	#[test]945	fn schedule_after_zero_works() {946		new_test_ext().execute_with(|| {947			run_to_block(2);948			let call = Call::Logger(logger::Call::log(42, 1000));949			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));950			assert_ok!(Scheduler::do_schedule(DispatchTime::After(0), None, 127, root(), call));951			// Will trigger on the next block.952			run_to_block(3);953			assert_eq!(logger::log(), vec![(root(), 42u32)]);954			run_to_block(100);955			assert_eq!(logger::log(), vec![(root(), 42u32)]);956		});957	}958959	#[test]960	fn periodic_scheduling_works() {961		new_test_ext().execute_with(|| {962			// at #4, every 3 blocks, 3 times.963			assert_ok!(Scheduler::do_schedule(964				DispatchTime::At(4), Some((3, 3)), 127, root(), Call::Logger(logger::Call::log(42, 1000))965			));966			run_to_block(3);967			assert!(logger::log().is_empty());968			run_to_block(4);969			assert_eq!(logger::log(), vec![(root(), 42u32)]);970			run_to_block(6);971			assert_eq!(logger::log(), vec![(root(), 42u32)]);972			run_to_block(7);973			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);974			run_to_block(9);975			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);976			run_to_block(10);977			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);978			run_to_block(100);979			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);980		});981	}982983	#[test]984	fn reschedule_works() {985		new_test_ext().execute_with(|| {986			let call = Call::Logger(logger::Call::log(42, 1000));987			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));988			assert_eq!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call).unwrap(), (4, 0));989990			run_to_block(3);991			assert!(logger::log().is_empty());992993			assert_eq!(Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(), (6, 0));994995			assert_noop!(Scheduler::do_reschedule((6, 0), DispatchTime::At(6)), Error::<Test>::RescheduleNoChange);996997			run_to_block(4);998			assert!(logger::log().is_empty());9991000			run_to_block(6);1001			assert_eq!(logger::log(), vec![(root(), 42u32)]);10021003			run_to_block(100);1004			assert_eq!(logger::log(), vec![(root(), 42u32)]);1005		});1006	}10071008	#[test]1009	fn reschedule_named_works() {1010		new_test_ext().execute_with(|| {1011			let call = Call::Logger(logger::Call::log(42, 1000));1012			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));1013			assert_eq!(Scheduler::do_schedule_named(1014				1u32.encode(), DispatchTime::At(4), None, 127, root(), call1015			).unwrap(), (4, 0));10161017			run_to_block(3);1018			assert!(logger::log().is_empty());10191020			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(), (6, 0));10211022			assert_noop!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)), Error::<Test>::RescheduleNoChange);10231024			run_to_block(4);1025			assert!(logger::log().is_empty());10261027			run_to_block(6);1028			assert_eq!(logger::log(), vec![(root(), 42u32)]);10291030			run_to_block(100);1031			assert_eq!(logger::log(), vec![(root(), 42u32)]);1032		});1033	}10341035	#[test]1036	fn reschedule_named_perodic_works() {1037		new_test_ext().execute_with(|| {1038			let call = Call::Logger(logger::Call::log(42, 1000));1039			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(&call));1040			assert_eq!(Scheduler::do_schedule_named(1041				1u32.encode(), DispatchTime::At(4), Some((3, 3)), 127, root(), call1042			).unwrap(), (4, 0));10431044			run_to_block(3);1045			assert!(logger::log().is_empty());10461047			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(5)).unwrap(), (5, 0));1048			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(), (6, 0));10491050			run_to_block(5);1051			assert!(logger::log().is_empty());10521053			run_to_block(6);1054			assert_eq!(logger::log(), vec![(root(), 42u32)]);10551056			assert_eq!(Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(10)).unwrap(), (10, 0));10571058			run_to_block(9);1059			assert_eq!(logger::log(), vec![(root(), 42u32)]);10601061			run_to_block(10);1062			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);10631064			run_to_block(13);1065			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);10661067			run_to_block(100);1068			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);1069		});1070	}10711072	#[test]1073	fn cancel_named_scheduling_works_with_normal_cancel() {1074		new_test_ext().execute_with(|| {1075			// at #4.1076			Scheduler::do_schedule_named(1077				1u32.encode(), DispatchTime::At(4), None, 127, root(), Call::Logger(logger::Call::log(69, 1000))1078			).unwrap();1079			let i = Scheduler::do_schedule(1080				DispatchTime::At(4), None, 127, root(), Call::Logger(logger::Call::log(42, 1000))1081			).unwrap();1082			run_to_block(3);1083			assert!(logger::log().is_empty());1084			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1085			assert_ok!(Scheduler::do_cancel(None, i));1086			run_to_block(100);1087			assert!(logger::log().is_empty());1088		});1089	}10901091	#[test]1092	fn cancel_named_periodic_scheduling_works() {1093		new_test_ext().execute_with(|| {1094			// at #4, every 3 blocks, 3 times.1095			Scheduler::do_schedule_named(1096				1u32.encode(),1097				DispatchTime::At(4),1098				Some((3, 3)),1099				127,1100				root(),1101				Call::Logger(logger::Call::log(42, 1000))1102			).unwrap();1103			// same id results in error.1104			assert!(Scheduler::do_schedule_named(1105				1u32.encode(),1106				DispatchTime::At(4),1107				None,1108				127,1109				root(),1110				Call::Logger(logger::Call::log(69, 1000))1111			).is_err());1112			// different id is ok.1113			Scheduler::do_schedule_named(1114				2u32.encode(), DispatchTime::At(8), None, 127, root(), Call::Logger(logger::Call::log(69, 1000))1115			).unwrap();1116			run_to_block(3);1117			assert!(logger::log().is_empty());1118			run_to_block(4);1119			assert_eq!(logger::log(), vec![(root(), 42u32)]);1120			run_to_block(6);1121			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));1122			run_to_block(100);1123			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1124		});1125	}11261127	#[test]1128	fn scheduler_respects_weight_limits() {1129		new_test_ext().execute_with(|| {1130			assert_ok!(Scheduler::do_schedule(1131				DispatchTime::At(4),1132				None,1133				127,1134				root(),1135				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1136			));1137			assert_ok!(Scheduler::do_schedule(1138				DispatchTime::At(4),1139				None,1140				127,1141				root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1142			));1143			// 69 and 42 do not fit together1144			run_to_block(4);1145			assert_eq!(logger::log(), vec![(root(), 42u32)]);1146			run_to_block(5);1147			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1148		});1149	}11501151	#[test]1152	fn scheduler_respects_hard_deadlines_more() {1153		new_test_ext().execute_with(|| {1154			assert_ok!(Scheduler::do_schedule(1155				DispatchTime::At(4),1156				None,1157				0,1158				root(),1159				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1160			));1161			assert_ok!(Scheduler::do_schedule(1162				DispatchTime::At(4),1163				None,1164				0,1165				root(),1166				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1167			));1168			// With base weights, 69 and 42 should not fit together, but do because of hard deadlines1169			run_to_block(4);1170			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);1171		});1172	}11731174	#[test]1175	fn scheduler_respects_priority_ordering() {1176		new_test_ext().execute_with(|| {1177			assert_ok!(Scheduler::do_schedule(1178				DispatchTime::At(4),1179				None,1180				1,1181				root(),1182				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))1183			));1184			assert_ok!(Scheduler::do_schedule(1185				DispatchTime::At(4),1186				None,1187				0,1188				root(),1189				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1190			));1191			run_to_block(4);1192			assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);1193		});1194	}11951196	#[test]1197	fn scheduler_respects_priority_ordering_with_soft_deadlines() {1198		new_test_ext().execute_with(|| {1199			assert_ok!(Scheduler::do_schedule(1200				DispatchTime::At(4),1201				None,1202				255,1203				root(), Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1204			));1205			assert_ok!(Scheduler::do_schedule(1206				DispatchTime::At(4),1207				None,1208				127,1209				root(), Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1210			));1211			assert_ok!(Scheduler::do_schedule(1212				DispatchTime::At(4),1213				None,1214				126,1215				root(), Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))1216			));12171218			// 2600 does not fit with 69 or 42, but has higher priority, so will go through1219			run_to_block(4);1220			assert_eq!(logger::log(), vec![(root(), 2600u32)]);1221			// 69 and 42 fit together1222			run_to_block(5);1223			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);1224		});1225	}12261227	#[test]1228	fn on_initialize_weight_is_correct() {1229		new_test_ext().execute_with(|| {1230			let base_weight: Weight = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);1231			let base_multiplier = 0;1232			let named_multiplier = <Test as frame_system::Config>::DbWeight::get().writes(1);1233			let periodic_multiplier = <Test as frame_system::Config>::DbWeight::get().reads_writes(1, 1);12341235			// Named1236			assert_ok!(1237				Scheduler::do_schedule_named(1238					1u32.encode(), DispatchTime::At(1), None, 255, root(),1239					Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))1240				)1241			);1242			// Anon Periodic1243			assert_ok!(Scheduler::do_schedule(1244				DispatchTime::At(1),1245				Some((1000, 3)),1246				128,1247				root(),1248				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))1249			));1250			// Anon1251			assert_ok!(Scheduler::do_schedule(1252				DispatchTime::At(1),1253				None,1254				127,1255				root(),1256				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))1257			));1258			// Named Periodic1259			assert_ok!(Scheduler::do_schedule_named(1260				2u32.encode(), DispatchTime::At(1), Some((1000, 3)), 126, root(),1261				Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2)))1262			);12631264			// Will include the named periodic only1265			let actual_weight = Scheduler::on_initialize(1);1266			let call_weight = MaximumSchedulerWeight::get() / 2;1267			assert_eq!(1268				actual_weight, call_weight + base_weight + base_multiplier + named_multiplier + periodic_multiplier1269			);1270			assert_eq!(logger::log(), vec![(root(), 2600u32)]);12711272			// Will include anon and anon periodic1273			let actual_weight = Scheduler::on_initialize(2);1274			let call_weight = MaximumSchedulerWeight::get() / 2 + MaximumSchedulerWeight::get() / 3;1275			assert_eq!(actual_weight, call_weight + base_weight + base_multiplier * 2 + periodic_multiplier);1276			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);12771278			// Will include named only1279			let actual_weight = Scheduler::on_initialize(3);1280			let call_weight = MaximumSchedulerWeight::get() / 3;1281			assert_eq!(actual_weight, call_weight + base_weight + base_multiplier + named_multiplier);1282			assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32), (root(), 3u32)]);12831284			// Will contain none1285			let actual_weight = Scheduler::on_initialize(4);1286			assert_eq!(actual_weight, 0);1287		});1288	}12891290	#[test]1291	fn root_calls_works() {1292		new_test_ext().execute_with(|| {1293			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1294			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1295			assert_ok!(Scheduler::schedule_named(Origin::root(), 1u32.encode(), 4, None, 127, call));1296			assert_ok!(Scheduler::schedule(Origin::root(), 4, None, 127, call2));1297			run_to_block(3);1298			// Scheduled calls are in the agenda.1299			assert_eq!(Agenda::<Test>::get(4).len(), 2);1300			assert!(logger::log().is_empty());1301			assert_ok!(Scheduler::cancel_named(Origin::root(), 1u32.encode()));1302			assert_ok!(Scheduler::cancel(Origin::root(), 4, 1));1303			// Scheduled calls are made NONE, so should not effect state1304			run_to_block(100);1305			assert!(logger::log().is_empty());1306		});1307	}13081309	#[test]1310	fn fails_to_schedule_task_in_the_past() {1311		new_test_ext().execute_with(|| {1312			run_to_block(3);13131314			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1315			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));13161317			assert_err!(1318				Scheduler::schedule_named(Origin::root(), 1u32.encode(), 2, None, 127, call),1319				Error::<Test>::TargetBlockNumberInPast,1320			);13211322			assert_err!(1323				Scheduler::schedule(Origin::root(), 2, None, 127, call2.clone()),1324				Error::<Test>::TargetBlockNumberInPast,1325			);13261327			assert_err!(1328				Scheduler::schedule(Origin::root(), 3, None, 127, call2),1329				Error::<Test>::TargetBlockNumberInPast,1330			);1331		});1332	}13331334	#[test]1335	fn should_use_orign() {1336		new_test_ext().execute_with(|| {1337			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1338			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1339			assert_ok!(1340				Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)1341			);1342			assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));1343			run_to_block(3);1344			// Scheduled calls are in the agenda.1345			assert_eq!(Agenda::<Test>::get(4).len(), 2);1346			assert!(logger::log().is_empty());1347			assert_ok!(Scheduler::cancel_named(system::RawOrigin::Signed(1).into(), 1u32.encode()));1348			assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));1349			// Scheduled calls are made NONE, so should not effect state1350			run_to_block(100);1351			assert!(logger::log().is_empty());1352		});1353	}13541355	#[test]1356	fn should_check_orign() {1357		new_test_ext().execute_with(|| {1358			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));1359			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));1360			assert_noop!(1361				Scheduler::schedule_named(system::RawOrigin::Signed(2).into(), 1u32.encode(), 4, None, 127, call),1362				BadOrigin1363			);1364			assert_noop!(Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2), BadOrigin);1365		});1366	}13671368	#[test]1369	fn should_check_orign_for_cancel() {1370		new_test_ext().execute_with(|| {1371			let call = Box::new(Call::Logger(logger::Call::log_without_filter(69, 1000)));1372			let call2 = Box::new(Call::Logger(logger::Call::log_without_filter(42, 1000)));1373			assert_ok!(1374				Scheduler::schedule_named(system::RawOrigin::Signed(1).into(), 1u32.encode(), 4, None, 127, call)1375			);1376			assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2));1377			run_to_block(3);1378			// Scheduled calls are in the agenda.1379			assert_eq!(Agenda::<Test>::get(4).len(), 2);1380			assert!(logger::log().is_empty());1381			assert_noop!(Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()), BadOrigin);1382			assert_noop!(Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1), BadOrigin);1383			assert_noop!(Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()), BadOrigin);1384			assert_noop!(Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1), BadOrigin);1385			run_to_block(5);1386			assert_eq!(1387				logger::log(),1388				vec![(system::RawOrigin::Signed(1).into(), 69u32), (system::RawOrigin::Signed(1).into(), 42u32)]1389			);1390		});1391	}13921393	#[test]1394	fn migration_to_v2_works() {1395		new_test_ext().execute_with(|| {1396			for i in 0..3u64 {1397				let k = i.twox_64_concat();1398				let old = vec![1399					Some(ScheduledV1 {1400						maybe_id: None,1401						priority: i as u8 + 10,1402						call: Call::Logger(logger::Call::log(96, 100)),1403						maybe_periodic: None,1404					}),1405					None,1406					Some(ScheduledV1 {1407						maybe_id: Some(b"test".to_vec()),1408						priority: 123,1409						call: Call::Logger(logger::Call::log(69, 1000)),1410						maybe_periodic: Some((456u64, 10)),1411					}),1412				];1413				frame_support::migration::put_storage_value(1414					b"Scheduler",1415					b"Agenda",1416					&k,1417					old,1418				);1419			}14201421			assert_eq!(StorageVersion::get(), Releases::V1);14221423			assert!(Scheduler::migrate_v1_to_t2());14241425			assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![1426				(1427					0,1428					vec![1429					Some(ScheduledV2 {1430						maybe_id: None,1431						priority: 10,1432						call: Call::Logger(logger::Call::log(96, 100)),1433						maybe_periodic: None,1434						origin: root(),1435						_phantom: PhantomData::<u64>::default(),1436					}),1437					None,1438					Some(ScheduledV2 {1439						maybe_id: Some(b"test".to_vec()),1440						priority: 123,1441						call: Call::Logger(logger::Call::log(69, 1000)),1442						maybe_periodic: Some((456u64, 10)),1443						origin: root(),1444						_phantom: PhantomData::<u64>::default(),1445					}),1446				]),1447				(1448					1,1449					vec![1450						Some(ScheduledV2 {1451							maybe_id: None,1452							priority: 11,1453							call: Call::Logger(logger::Call::log(96, 100)),1454							maybe_periodic: None,1455							origin: root(),1456							_phantom: PhantomData::<u64>::default(),1457						}),1458						None,1459						Some(ScheduledV2 {1460							maybe_id: Some(b"test".to_vec()),1461							priority: 123,1462							call: Call::Logger(logger::Call::log(69, 1000)),1463							maybe_periodic: Some((456u64, 10)),1464							origin: root(),1465							_phantom: PhantomData::<u64>::default(),1466						}),1467					]1468				),1469				(1470					2,1471					vec![1472						Some(ScheduledV2 {1473							maybe_id: None,1474							priority: 12,1475							call: Call::Logger(logger::Call::log(96, 100)),1476							maybe_periodic: None,1477							origin: root(),1478							_phantom: PhantomData::<u64>::default(),1479						}),1480						None,1481						Some(ScheduledV2 {1482							maybe_id: Some(b"test".to_vec()),1483							priority: 123,1484							call: Call::Logger(logger::Call::log(69, 1000)),1485							maybe_periodic: Some((456u64, 10)),1486							origin: root(),1487							_phantom: PhantomData::<u64>::default(),1488						}),1489					]1490				)1491			]);14921493			assert_eq!(StorageVersion::get(), Releases::V2);1494		});1495	}14961497	#[test]1498	fn test_migrate_origin() {1499		new_test_ext().execute_with(|| {1500			for i in 0..3u64 {1501				let k = i.twox_64_concat();1502				let old: Vec<Option<Scheduled<_, _, u32, u64>>> = vec![1503					Some(Scheduled {1504						maybe_id: None,1505						priority: i as u8 + 10,1506						call: Call::Logger(logger::Call::log(96, 100)),1507						origin: 3u32,1508						maybe_periodic: None,1509						_phantom: Default::default(),1510					}),1511					None,1512					Some(Scheduled {1513						maybe_id: Some(b"test".to_vec()),1514						priority: 123,1515						origin: 2u32,1516						call: Call::Logger(logger::Call::log(69, 1000)),1517						maybe_periodic: Some((456u64, 10)),1518						_phantom: Default::default(),1519					}),1520				];1521				frame_support::migration::put_storage_value(1522					b"Scheduler",1523					b"Agenda",1524					&k,1525					old,1526				);1527			}15281529			impl Into<OriginCaller> for u32 {1530				fn into(self) -> OriginCaller {1531					match self {1532						3u32 => system::RawOrigin::Root.into(),1533						2u32 => system::RawOrigin::None.into(),1534						_ => unreachable!("test make no use of it"),1535					}1536				}1537			}15381539			Scheduler::migrate_origin::<u32>();15401541			assert_eq_uvec!(Agenda::<Test>::iter().collect::<Vec<_>>(), vec![1542				(1543					0,1544					vec![1545					Some(ScheduledV2::<_, _, OriginCaller, u64> {1546						maybe_id: None,1547						priority: 10,1548						call: Call::Logger(logger::Call::log(96, 100)),1549						maybe_periodic: None,1550						origin: system::RawOrigin::Root.into(),1551						_phantom: PhantomData::<u64>::default(),1552					}),1553					None,1554					Some(ScheduledV2 {1555						maybe_id: Some(b"test".to_vec()),1556						priority: 123,1557						call: Call::Logger(logger::Call::log(69, 1000)),1558						maybe_periodic: Some((456u64, 10)),1559						origin: system::RawOrigin::None.into(),1560						_phantom: PhantomData::<u64>::default(),1561					}),1562				]),1563				(1564					1,1565					vec![1566						Some(ScheduledV2 {1567							maybe_id: None,1568							priority: 11,1569							call: Call::Logger(logger::Call::log(96, 100)),1570							maybe_periodic: None,1571							origin: system::RawOrigin::Root.into(),1572							_phantom: PhantomData::<u64>::default(),1573						}),1574						None,1575						Some(ScheduledV2 {1576							maybe_id: Some(b"test".to_vec()),1577							priority: 123,1578							call: Call::Logger(logger::Call::log(69, 1000)),1579							maybe_periodic: Some((456u64, 10)),1580							origin: system::RawOrigin::None.into(),1581							_phantom: PhantomData::<u64>::default(),1582						}),1583					]1584				),1585				(1586					2,1587					vec![1588						Some(ScheduledV2 {1589							maybe_id: None,1590							priority: 12,1591							call: Call::Logger(logger::Call::log(96, 100)),1592							maybe_periodic: None,1593							origin: system::RawOrigin::Root.into(),1594							_phantom: PhantomData::<u64>::default(),1595						}),1596						None,1597						Some(ScheduledV2 {1598							maybe_id: Some(b"test".to_vec()),1599							priority: 123,1600							call: Call::Logger(logger::Call::log(69, 1000)),1601							maybe_periodic: Some((456u64, 10)),1602							origin: system::RawOrigin::None.into(),1603							_phantom: PhantomData::<u64>::default(),1604						}),1605					]1606				)1607			]);1608		});1609	}1610}