difftreelog
Fmt code style
in: master
1 file changed
pallets/scheduler/src/lib.rsdiffbeforeafterboth1// This file is part of Substrate.23// Copyright (C) 2017-2022 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 Pallet for scheduling dispatches.20//!21//! - [`Config`]22//! - [`Call`]23//! - [`Pallet`]24//!25//! ## Overview26//!27//! This Pallet 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 a specified block and44//! with a specified priority.45//! * `cancel` - cancel a scheduled dispatch, specified by block number and index.46//! * `schedule_named` - augments the `schedule` interface with an additional `Vec<u8>` parameter47//! that can be used for identification.48//! * `cancel_named` - the named complement to the cancel function.4950// Ensure we're `no_std` when compiling for Wasm.51#![cfg_attr(not(feature = "std"), no_std)]5253#[cfg(feature = "runtime-benchmarks")]54mod benchmarking;55#[cfg(test)]56mod mock;57#[cfg(test)]58mod tests;59pub mod weights;6061use codec::{Codec, Decode, Encode};62use frame_support::{63 dispatch::{DispatchError, DispatchResult, Dispatchable, Parameter},64 traits::{65 schedule::{self, DispatchTime, MaybeHashed}, NamedReservableCurrency,66 EnsureOrigin, Get, IsType, OriginTrait, PrivilegeCmp, StorageVersion,67 },68 weights::{GetDispatchInfo, Weight},69};70use frame_system::{self as system, ensure_signed};71pub use pallet::*;72use scale_info::TypeInfo;73use sp_runtime::{74 traits::{BadOrigin, One, Saturating, Zero},75 RuntimeDebug,76 DispatchErrorWithPostInfo,77};78use sp_std::{borrow::Borrow, cmp::Ordering, marker::PhantomData, prelude::*};79use sp_core::H160;80pub use weights::WeightInfo;8182/// Just a simple index for naming period tasks.83pub type PeriodicIndex = u32;84/// The location of a scheduled task that can be used to remove it.85pub type TaskAddress<BlockNumber> = (BlockNumber, u32);86pub const MAX_TASK_ID_LENGTH_IN_BYTES: u8 = 16;8788type ScheduledId = [u8; MAX_TASK_ID_LENGTH_IN_BYTES as usize];89pub type CallOrHashOf<T> = MaybeHashed<<T as Config>::Call, <T as frame_system::Config>::Hash>;9091/// Information regarding an item to be executed in the future.92#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]93#[derive(Clone, RuntimeDebug, Encode, Decode, TypeInfo)]94pub struct ScheduledV3<Call, BlockNumber, PalletsOrigin, AccountId> {95 /// The unique identity for this task, if there is one.96 maybe_id: Option<ScheduledId>,97 /// This task's priority.98 priority: schedule::Priority,99 /// The call to be dispatched.100 call: Call,101 /// If the call is periodic, then this points to the information concerning that.102 maybe_periodic: Option<schedule::Period<BlockNumber>>,103 /// The origin to dispatch the call.104 origin: PalletsOrigin,105 _phantom: PhantomData<AccountId>,106}107108pub type ScheduledV3Of<T> = ScheduledV3<109 CallOrHashOf<T>,110 <T as frame_system::Config>::BlockNumber,111 <T as Config>::PalletsOrigin,112 <T as frame_system::Config>::AccountId,113>;114115pub type ScheduledOf<T> = ScheduledV3Of<T>;116117/// The current version of Scheduled struct.118pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> =119 ScheduledV3<Call, BlockNumber, PalletsOrigin, AccountId>;120121#[cfg(feature = "runtime-benchmarks")]122mod preimage_provider {123 use frame_support::traits::PreimageRecipient;124 pub trait PreimageProviderAndMaybeRecipient<H>: PreimageRecipient<H> {}125 impl<H, T: PreimageRecipient<H>> PreimageProviderAndMaybeRecipient<H> for T {}126}127128#[cfg(not(feature = "runtime-benchmarks"))]129mod preimage_provider {130 use frame_support::traits::PreimageProvider;131 pub trait PreimageProviderAndMaybeRecipient<H>: PreimageProvider<H> {}132 impl<H, T: PreimageProvider<H>> PreimageProviderAndMaybeRecipient<H> for T {}133}134135pub use preimage_provider::PreimageProviderAndMaybeRecipient;136137pub(crate) trait MarginalWeightInfo: WeightInfo {138 fn item(periodic: bool, named: bool, resolved: Option<bool>) -> Weight {139 match (periodic, named, resolved) {140 (_, false, None) => Self::on_initialize_aborted(2) - Self::on_initialize_aborted(1),141 (_, true, None) =>142 Self::on_initialize_named_aborted(2) - Self::on_initialize_named_aborted(1),143 (false, false, Some(false)) => Self::on_initialize(2) - Self::on_initialize(1),144 (false, true, Some(false)) =>145 Self::on_initialize_named(2) - Self::on_initialize_named(1),146 (true, false, Some(false)) =>147 Self::on_initialize_periodic(2) - Self::on_initialize_periodic(1),148 (true, true, Some(false)) =>149 Self::on_initialize_periodic_named(2) - Self::on_initialize_periodic_named(1),150 (false, false, Some(true)) =>151 Self::on_initialize_resolved(2) - Self::on_initialize_resolved(1),152 (false, true, Some(true)) =>153 Self::on_initialize_named_resolved(2) - Self::on_initialize_named_resolved(1),154 (true, false, Some(true)) =>155 Self::on_initialize_periodic_resolved(2) - Self::on_initialize_periodic_resolved(1),156 (true, true, Some(true)) =>157 Self::on_initialize_periodic_named_resolved(2) -158 Self::on_initialize_periodic_named_resolved(1),159 }160 }161}162impl<T: WeightInfo> MarginalWeightInfo for T {}163164#[frame_support::pallet]165pub mod pallet {166 use super::*;167 use frame_support::{168 dispatch::PostDispatchInfo,169 pallet_prelude::*,170 traits::{schedule::LookupError, PreimageProvider},171 };172 use frame_system::pallet_prelude::*;173174 /// The current storage version.175 const STORAGE_VERSION: StorageVersion = StorageVersion::new(3);176177 #[pallet::pallet]178 #[pallet::generate_store(pub(super) trait Store)]179 #[pallet::storage_version(STORAGE_VERSION)]180 #[pallet::without_storage_info]181 pub struct Pallet<T>(_);182183 /// `system::Config` should always be included in our implied traits.184 #[pallet::config]185 pub trait Config: frame_system::Config {186 /// The overarching event type.187 type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;188189 /// The aggregated origin which the dispatch will take.190 type Origin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>191 + From<Self::PalletsOrigin>192 + IsType<<Self as system::Config>::Origin>;193194 /// The caller origin, overarching type of all pallets origins.195 type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + Clone + Eq + TypeInfo;196197 type Currency: NamedReservableCurrency<Self::AccountId, ReserveIdentifier = ScheduledId>;198199 /// The aggregated call type.200 type Call: Parameter201 + Dispatchable<Origin = <Self as Config>::Origin, PostInfo = PostDispatchInfo>202 + GetDispatchInfo203 + From<system::Call<Self>>;204205 /// The maximum weight that may be scheduled per block for any dispatchables of less206 /// priority than `schedule::HARD_DEADLINE`.207 #[pallet::constant]208 type MaximumWeight: Get<Weight>;209210 /// Required origin to schedule or cancel calls.211 type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::Origin>;212213 /// Compare the privileges of origins.214 ///215 /// This will be used when canceling a task, to ensure that the origin that tries216 /// to cancel has greater or equal privileges as the origin that created the scheduled task.217 ///218 /// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can219 /// be used. This will only check if two given origins are equal.220 type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;221222 /// The maximum number of scheduled calls in the queue for a single block.223 /// Not strictly enforced, but used for weight estimation.224 #[pallet::constant]225 type MaxScheduledPerBlock: Get<u32>;226227 /// Weight information for extrinsics in this pallet.228 type WeightInfo: WeightInfo;229230 /// The preimage provider with which we look up call hashes to get the call.231 type PreimageProvider: PreimageProviderAndMaybeRecipient<Self::Hash>;232233 /// If `Some` then the number of blocks to postpone execution for when the item is delayed.234 type NoPreimagePostponement: Get<Option<Self::BlockNumber>>;235236 /// Sponsoring function.237 // type SponsorshipHandler: SponsorshipHandler<Self::AccountId, <Self as Config>::Call>;238239 /// The helper type used for custom transaction fee logic.240 type CallExecutor: DispatchCall<Self, H160>; 241 }242243 /// A Scheduler-Runtime interface for finer payment handling.244 pub trait DispatchCall<T: frame_system::Config + Config, SelfContainedSignedInfo> {245246 fn reserve_balance(247 id: ScheduledId,248 sponsor: <T as frame_system::Config>::AccountId,249 call: <T as Config>::Call,250 count: u32,251 ) -> Result<(), DispatchError>;252253 fn pay_for_call(254 id: ScheduledId,255 sponsor: <T as frame_system::Config>::AccountId,256 call: <T as Config>::Call,257 ) -> Result<u128, DispatchError>;258259 /// Resolve the call dispatch, including any post-dispatch operations.260 fn dispatch_call(261 signer: T::AccountId,262 function: <T as Config>::Call,263 ) -> Result<264 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,265 TransactionValidityError,266 >;267268 fn cancel_reserve(269 id: ScheduledId,270 sponsor: <T as frame_system::Config>::AccountId,271 ) -> Result<u128, DispatchError>;272 }273274 /// Items to be executed, indexed by the block number that they should be executed on.275 #[pallet::storage]276 pub type Agenda<T: Config> =277 StorageMap<_, Twox64Concat, T::BlockNumber, Vec<Option<ScheduledV3Of<T>>>, ValueQuery>;278279 /// Lookup from identity to the block number and index of the task.280 #[pallet::storage]281 pub(crate) type Lookup<T: Config> =282 StorageMap<_, Twox64Concat, ScheduledId, TaskAddress<T::BlockNumber>>;283284 /// Events type.285 #[pallet::event]286 #[pallet::generate_deposit(pub(super) fn deposit_event)]287 pub enum Event<T: Config> {288 /// Scheduled some task.289 Scheduled { when: T::BlockNumber, index: u32 },290 /// Canceled some task.291 Canceled { when: T::BlockNumber, index: u32 },292 /// Dispatched some task.293 Dispatched {294 task: TaskAddress<T::BlockNumber>,295 id: Option<ScheduledId>,296 result: DispatchResult,297 },298 /// The call for the provided hash was not found so the task has been aborted.299 CallLookupFailed {300 task: TaskAddress<T::BlockNumber>,301 id: Option<ScheduledId>,302 error: LookupError,303 },304 }305306 #[pallet::error]307 pub enum Error<T> {308 /// Failed to schedule a call309 FailedToSchedule,310 /// Cannot find the scheduled call.311 NotFound,312 /// Given target block number is in the past.313 TargetBlockNumberInPast,314 /// Reschedule failed because it does not change scheduled time.315 RescheduleNoChange,316 }317318 #[pallet::hooks]319 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {320 /// Execute the scheduled calls321 fn on_initialize(now: T::BlockNumber) -> Weight {322 let limit = T::MaximumWeight::get();323324 let mut queued = Agenda::<T>::take(now)325 .into_iter()326 .enumerate()327 .filter_map(|(index, s)| Some((index as u32, s?)))328 .collect::<Vec<_>>();329330 if queued.len() as u32 > T::MaxScheduledPerBlock::get() {331 log::warn!(332 target: "runtime::scheduler",333 "Warning: This block has more items queued in Scheduler than \334 expected from the runtime configuration. An update might be needed."335 );336 }337338 queued.sort_by_key(|(_, s)| s.priority);339340 let next = now + One::one();341342 let mut total_weight: Weight = T::WeightInfo::on_initialize(0);343 for (order, (index, mut s)) in queued.into_iter().enumerate() {344 let named = if let Some(ref id) = s.maybe_id {345 Lookup::<T>::remove(id);346 true347 } else {348 false349 };350351 let (call, maybe_completed) = s.call.resolved::<T::PreimageProvider>();352 s.call = call;353354 let resolved = if let Some(completed) = maybe_completed {355 T::PreimageProvider::unrequest_preimage(&completed);356 true357 } else {358 false359 };360361 let call = match s.call.as_value().cloned() {362 Some(c) => c,363 None => {364 // Preimage not available - postpone until some block.365 total_weight.saturating_accrue(T::WeightInfo::item(false, named, None));366 if let Some(delay) = T::NoPreimagePostponement::get() {367 let until = now.saturating_add(delay);368 if let Some(ref id) = s.maybe_id {369 let index = Agenda::<T>::decode_len(until).unwrap_or(0);370 Lookup::<T>::insert(id, (until, index as u32));371 }372 Agenda::<T>::append(until, Some(s));373 }374 continue375 },376 };377378 let periodic = s.maybe_periodic.is_some();379 let call_weight = call.get_dispatch_info().weight;380 let mut item_weight = T::WeightInfo::item(periodic, named, Some(resolved));381 let origin =382 <<T as Config>::Origin as From<T::PalletsOrigin>>::from(s.origin.clone())383 .into();384 if ensure_signed(origin).is_ok() {385 // Weights of Signed dispatches expect their signing account to be whitelisted.386 item_weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));387 }388389 // We allow a scheduled call if any is true:390 // - It's priority is `HARD_DEADLINE`391 // - It does not push the weight past the limit.392 // - It is the first item in the schedule393 let hard_deadline = s.priority <= schedule::HARD_DEADLINE;394 let test_weight =395 total_weight.saturating_add(call_weight).saturating_add(item_weight);396 if !hard_deadline && order > 0 && test_weight > limit {397 // Cannot be scheduled this block - postpone until next.398 total_weight.saturating_accrue(T::WeightInfo::item(false, named, None));399 if let Some(ref id) = s.maybe_id {400 // NOTE: We could reasonably not do this (in which case there would be one401 // block where the named and delayed item could not be referenced by name),402 // but we will do it anyway since it should be mostly free in terms of403 // weight and it is slightly cleaner.404 let index = Agenda::<T>::decode_len(next).unwrap_or(0);405 Lookup::<T>::insert(id, (next, index as u32));406 }407 Agenda::<T>::append(next, Some(s));408 continue409 }410411 let sender = ensure_signed(412 <<T as Config>::Origin as From<T::PalletsOrigin>>::from(s.origin.clone()).into(),413 ).unwrap();414415 // if call have id and periodic, it was be reserved 416 if s.maybe_id.is_some() && s.maybe_periodic.is_some()417 {418 let _ = T::CallExecutor::pay_for_call(419 s.maybe_id.unwrap(),420 sender.clone(),421 call.clone(),422 );423 } 424425 let r = T::CallExecutor::dispatch_call(sender, call.clone());426427 let mut actual_call_weight: Weight = item_weight; //PostDispatchInfo;428 let result: Result<_, DispatchError> = match r {429 Ok(o) => { match o {430 Ok(di) => {431 actual_call_weight = di.actual_weight.unwrap_or(item_weight);432 Ok(())433 },434 Err(err) => Err(err.error),435 }},436 Err(_) => { 437 log::info!(438 target: "runtime::scheduler",439 "Warning: Scheduler has failed to execute a post-dispatch transaction. \440 This block might have become invalid.");441 Err(DispatchError::CannotLookup)442 }443 // todo possibly force a skip/return here, do something with the error444 }; 445446 total_weight.saturating_accrue(item_weight);447 total_weight.saturating_accrue(actual_call_weight);448449 Self::deposit_event(Event::Dispatched {450 task: (now, index),451 id: s.maybe_id.clone(),452 result,453 });454455 if let &Some((period, count)) = &s.maybe_periodic {456 if count > 1 {457 s.maybe_periodic = Some((period, count - 1));458 } else {459 s.maybe_periodic = None;460 }461 let wake = now + period;462 // If scheduled is named, place its information in `Lookup`463 if let Some(ref id) = s.maybe_id {464 let wake_index = Agenda::<T>::decode_len(wake).unwrap_or(0);465 Lookup::<T>::insert(id, (wake, wake_index as u32));466 }467 Agenda::<T>::append(wake, Some(s));468 }469 }470 total_weight471 }472 }473474 #[pallet::call]475 impl<T: Config> Pallet<T> {476 /// Anonymously schedule a task.477 #[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]478 pub fn schedule(479 origin: OriginFor<T>,480 when: T::BlockNumber,481 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,482 priority: schedule::Priority,483 call: Box<CallOrHashOf<T>>,484 ) -> DispatchResult {485 T::ScheduleOrigin::ensure_origin(origin.clone())?;486 let origin = <T as Config>::Origin::from(origin);487 Self::do_schedule(488 DispatchTime::At(when),489 maybe_periodic,490 priority,491 origin.caller().clone(),492 *call,493 )?;494 Ok(())495 }496497 /// Cancel an anonymously scheduled task.498 #[pallet::weight(<T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get()))]499 pub fn cancel(origin: OriginFor<T>, when: T::BlockNumber, index: u32) -> DispatchResult {500 T::ScheduleOrigin::ensure_origin(origin.clone())?;501 let origin = <T as Config>::Origin::from(origin);502 Self::do_cancel(Some(origin.caller().clone()), (when, index))?;503 Ok(())504 }505506 /// Schedule a named task.507 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]508 pub fn schedule_named(509 origin: OriginFor<T>,510 id: ScheduledId,511 when: T::BlockNumber,512 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,513 priority: schedule::Priority,514 call: Box<CallOrHashOf<T>>,515 ) -> DispatchResult {516 T::ScheduleOrigin::ensure_origin(origin.clone())?;517 let origin = <T as Config>::Origin::from(origin);518 Self::do_schedule_named(519 id,520 DispatchTime::At(when),521 maybe_periodic,522 priority,523 origin.caller().clone(),524 *call,525 )?;526 Ok(())527 }528529 /// Cancel a named scheduled task.530 #[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]531 pub fn cancel_named(origin: OriginFor<T>, id: ScheduledId) -> DispatchResult {532 T::ScheduleOrigin::ensure_origin(origin.clone())?;533 let origin = <T as Config>::Origin::from(origin);534 Self::do_cancel_named(Some(origin.caller().clone()), id)?;535 Ok(())536 }537538 /// Anonymously schedule a task after a delay.539 ///540 /// # <weight>541 /// Same as [`schedule`].542 /// # </weight>543 #[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]544 pub fn schedule_after(545 origin: OriginFor<T>,546 after: T::BlockNumber,547 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,548 priority: schedule::Priority,549 call: Box<CallOrHashOf<T>>,550 ) -> DispatchResult {551 T::ScheduleOrigin::ensure_origin(origin.clone())?;552 let origin = <T as Config>::Origin::from(origin);553 Self::do_schedule(554 DispatchTime::After(after),555 maybe_periodic,556 priority,557 origin.caller().clone(),558 *call,559 )?;560 Ok(())561 }562563 /// Schedule a named task after a delay.564 ///565 /// # <weight>566 /// Same as [`schedule_named`](Self::schedule_named).567 /// # </weight>568 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]569 pub fn schedule_named_after(570 origin: OriginFor<T>,571 id: ScheduledId,572 after: T::BlockNumber,573 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,574 priority: schedule::Priority,575 call: Box<CallOrHashOf<T>>,576 ) -> DispatchResult {577 T::ScheduleOrigin::ensure_origin(origin.clone())?;578 let origin = <T as Config>::Origin::from(origin);579 Self::do_schedule_named(580 id,581 DispatchTime::After(after),582 maybe_periodic,583 priority,584 origin.caller().clone(),585 *call,586 )?;587 Ok(())588 }589 }590}591592impl<T: Config> Pallet<T> {593594 #[cfg(feature = "try-runtime")]595 pub fn pre_migrate_to_v3() -> Result<(), &'static str> {596 Ok(())597 }598599 #[cfg(feature = "try-runtime")]600 pub fn post_migrate_to_v3() -> Result<(), &'static str> {601 use frame_support::dispatch::GetStorageVersion;602603 assert!(Self::current_storage_version() == 3);604 for k in Agenda::<T>::iter_keys() {605 let _ = Agenda::<T>::try_get(k).map_err(|()| "Invalid item in Agenda")?;606 }607 Ok(())608 }609610 /// Helper to migrate scheduler when the pallet origin type has changed.611 pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {612 Agenda::<T>::translate::<613 Vec<Option<Scheduled<CallOrHashOf<T>, T::BlockNumber, OldOrigin, T::AccountId>>>,614 _,615 >(|_, agenda| {616 Some(617 agenda618 .into_iter()619 .map(|schedule| {620 schedule.map(|schedule| Scheduled {621 maybe_id: schedule.maybe_id,622 priority: schedule.priority,623 call: schedule.call,624 maybe_periodic: schedule.maybe_periodic,625 origin: schedule.origin.into(),626 _phantom: Default::default(),627 })628 })629 .collect::<Vec<_>>(),630 )631 });632 }633634 fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {635 let now = frame_system::Pallet::<T>::block_number();636637 let when = match when {638 DispatchTime::At(x) => x,639 // The current block has already completed it's scheduled tasks, so640 // Schedule the task at lest one block after this current block.641 DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),642 };643644 if when <= now {645 return Err(Error::<T>::TargetBlockNumberInPast.into())646 }647648 Ok(when)649 }650651 fn do_schedule(652 when: DispatchTime<T::BlockNumber>,653 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,654 priority: schedule::Priority,655 origin: T::PalletsOrigin,656 call: CallOrHashOf<T>,657 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {658 let when = Self::resolve_time(when)?;659 call.ensure_requested::<T::PreimageProvider>();660661 // sanitize maybe_periodic662 let maybe_periodic = maybe_periodic663 .filter(|p| p.1 > 1 && !p.0.is_zero())664 // Remove one from the number of repetitions since we will schedule one now.665 .map(|(p, c)| (p, c - 1));666 let s = Some(Scheduled {667 maybe_id: None,668 priority,669 call,670 maybe_periodic,671 origin,672 _phantom: PhantomData::<T::AccountId>::default(),673 });674 Agenda::<T>::append(when, s);675 let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;676 Self::deposit_event(Event::Scheduled { when, index });677678 Ok((when, index))679 }680681 fn do_cancel(682 origin: Option<T::PalletsOrigin>,683 (when, index): TaskAddress<T::BlockNumber>,684 ) -> Result<(), DispatchError> {685 let scheduled = Agenda::<T>::try_mutate(when, |agenda| {686 agenda.get_mut(index as usize).map_or(687 Ok(None),688 |s| -> Result<Option<Scheduled<_, _, _, _>>, DispatchError> {689 if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {690 if matches!(691 T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),692 Some(Ordering::Less) | None693 ) {694 return Err(BadOrigin.into())695 }696 };697 Ok(s.take())698 },699 )700 })?;701 if let Some(s) = scheduled {702 s.call.ensure_unrequested::<T::PreimageProvider>();703 if let Some(id) = s.maybe_id {704 Lookup::<T>::remove(id);705 }706 Self::deposit_event(Event::Canceled { when, index });707 Ok(())708 } else {709 Err(Error::<T>::NotFound)?710 }711 }712713 fn do_reschedule(714 (when, index): TaskAddress<T::BlockNumber>,715 new_time: DispatchTime<T::BlockNumber>,716 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {717 let new_time = Self::resolve_time(new_time)?;718719 if new_time == when {720 return Err(Error::<T>::RescheduleNoChange.into())721 }722723 Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {724 let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;725 let task = task.take().ok_or(Error::<T>::NotFound)?;726 Agenda::<T>::append(new_time, Some(task));727 Ok(())728 })?;729730 let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;731 Self::deposit_event(Event::Canceled { when, index });732 Self::deposit_event(Event::Scheduled { when: new_time, index: new_index });733734 Ok((new_time, new_index))735 }736737 fn do_schedule_named(738 id: ScheduledId,739 when: DispatchTime<T::BlockNumber>,740 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,741 priority: schedule::Priority,742 origin: T::PalletsOrigin,743 call: CallOrHashOf<T>,744 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {745 // ensure id it is unique746 if Lookup::<T>::contains_key(&id) {747 return Err(Error::<T>::FailedToSchedule)?748 }749750 let when = Self::resolve_time(when)?;751752 call.ensure_requested::<T::PreimageProvider>();753754 // sanitize maybe_periodic755 let maybe_periodic = maybe_periodic756 .filter(|p| p.1 > 1 && !p.0.is_zero())757 // Remove one from the number of repetitions since we will schedule one now.758 .map(|(p, c)| (p, c - 1));759760 let s = Scheduled {761 maybe_id: Some(id.clone()),762 priority,763 call: call.clone(),764 maybe_periodic,765 origin: origin.clone(),766 _phantom: Default::default(),767 };768769 // reserve balance for periodic execution 770 let sender = ensure_signed(771 <<T as Config>::Origin as From<T::PalletsOrigin>>::from(origin).into(),772 )?;773 let repeats = match maybe_periodic {774 Some(p) => p.1,775 None => 0,776 };777 let _ = T::CallExecutor::reserve_balance(id.clone(), sender, call.as_value().unwrap().clone(), repeats); 778779 Agenda::<T>::append(when, Some(s));780 let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;781 let address = (when, index);782 Lookup::<T>::insert(&id, &address);783 Self::deposit_event(Event::Scheduled { when, index });784785 Ok(address)786 }787788 fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: ScheduledId) -> DispatchResult {789 Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {790 if let Some((when, index)) = lookup.take() {791 let i = index as usize;792 Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {793 if let Some(s) = agenda.get_mut(i) {794 if let (Some(ref o), Some(ref s)) = (origin.clone(), s.borrow()) {795 if matches!(796 T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),797 Some(Ordering::Less) | None798 ) {799 return Err(BadOrigin.into())800 }801 // release balance reserve802 let sender = ensure_signed(803 <<T as Config>::Origin as From<T::PalletsOrigin>>::from(origin.unwrap()).into(),804 )?;805 let _ = T::CallExecutor::cancel_reserve(id, sender);806807 s.call.ensure_unrequested::<T::PreimageProvider>();808 }809 *s = None;810 }811 Ok(())812 })?;813814 Self::deposit_event(Event::Canceled { when, index });815 Ok(())816 } else {817 Err(Error::<T>::NotFound)?818 }819 })820 }821822 fn do_reschedule_named(823 id: ScheduledId,824 new_time: DispatchTime<T::BlockNumber>,825 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {826 let new_time = Self::resolve_time(new_time)?;827828 Lookup::<T>::try_mutate_exists(829 id,830 |lookup| -> Result<TaskAddress<T::BlockNumber>, DispatchError> {831 let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;832833 if new_time == when {834 return Err(Error::<T>::RescheduleNoChange.into())835 }836837 Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {838 let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;839 let task = task.take().ok_or(Error::<T>::NotFound)?;840 Agenda::<T>::append(new_time, Some(task));841842 Ok(())843 })?;844845 let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;846 Self::deposit_event(Event::Canceled { when, index });847 Self::deposit_event(Event::Scheduled { when: new_time, index: new_index });848849 *lookup = Some((new_time, new_index));850851 Ok((new_time, new_index))852 },853 )854 }855}856857impl<T: Config> schedule::v2::Anon<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin>858 for Pallet<T>859{860 type Address = TaskAddress<T::BlockNumber>;861 type Hash = T::Hash;862863 fn schedule(864 when: DispatchTime<T::BlockNumber>,865 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,866 priority: schedule::Priority,867 origin: T::PalletsOrigin,868 call: CallOrHashOf<T>,869 ) -> Result<Self::Address, DispatchError> {870 Self::do_schedule(when, maybe_periodic, priority, origin, call)871 }872873 fn cancel((when, index): Self::Address) -> Result<(), ()> {874 Self::do_cancel(None, (when, index)).map_err(|_| ())875 }876877 fn reschedule(878 address: Self::Address,879 when: DispatchTime<T::BlockNumber>,880 ) -> Result<Self::Address, DispatchError> {881 Self::do_reschedule(address, when)882 }883884 fn next_dispatch_time((when, index): Self::Address) -> Result<T::BlockNumber, ()> {885 Agenda::<T>::get(when).get(index as usize).ok_or(()).map(|_| when)886 }887}888889impl<T: Config> schedule::v2::Named<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin>890 for Pallet<T>891{892 type Address = TaskAddress<T::BlockNumber>;893 type Hash = T::Hash;894895 fn schedule_named(896 id: Vec<u8>,897 when: DispatchTime<T::BlockNumber>,898 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,899 priority: schedule::Priority,900 origin: T::PalletsOrigin,901 call: CallOrHashOf<T>,902 ) -> Result<Self::Address, ()> {903 let inner_id: ScheduledId = id.try_into().unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);904 Self::do_schedule_named(inner_id, when, maybe_periodic, priority, origin, call).map_err(|_| ())905 }906907 fn cancel_named(id: Vec<u8>) -> Result<(), ()> {908 let inner_id: ScheduledId = id.try_into().unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);909 Self::do_cancel_named(None, inner_id).map_err(|_| ())910 }911912 fn reschedule_named(913 id: Vec<u8>,914 when: DispatchTime<T::BlockNumber>,915 ) -> Result<Self::Address, DispatchError> {916 let inner_id: ScheduledId = id.try_into().unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);917 Self::do_reschedule_named(inner_id, when)918 }919920 fn next_dispatch_time(id: Vec<u8>) -> Result<T::BlockNumber, ()> {921 let inner_id: ScheduledId = id.try_into().unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);922 Lookup::<T>::get(inner_id)923 .and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when))924 .ok_or(())925 }926}