difftreelog
fix style
in: master
1 file changed
pallets/scheduler/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Original license:18// This file is part of Substrate.1920// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.21// SPDX-License-Identifier: Apache-2.02223// Licensed under the Apache License, Version 2.0 (the "License");24// you may not use this file except in compliance with the License.25// You may obtain a copy of the License at26//27// <http://www.apache.org/licenses/LICENSE-2.0>28//29// Unless required by applicable law or agreed to in writing, software30// distributed under the License is distributed on an "AS IS" BASIS,31// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.32// See the License for the specific language governing permissions and33// limitations under the License.3435//! # Unique scheduler36//! A Pallet for scheduling dispatches.37//!38//! - [`Config`]39//! - [`Call`]40//! - [`Pallet`]41//!42//! ## Overview43//!44//! This Pallet exposes capabilities for scheduling dispatches to occur at a45//! specified block number or at a specified period. These scheduled dispatches46//! should be named and may be canceled.47//!48//! **NOTE:** The unique scheduler is designed for deferred transaction calls by block number.49//! Any user can book a call of a certain transaction to a specific block number.50//! Also possible to book a call with a certain frequency.51//!52//! Key differences from the original pallet:53//! <https://crates.io/crates/pallet-scheduler>54//! Schedule Id restricted by 16 bytes. Identificator for booked call.55//! Priority limited by HARD DEADLINE (<= 63). Calls over maximum weight don't include to block.56//! The maximum weight that may be scheduled per block for any dispatchables of less priority than `schedule::HARD_DEADLINE`.57//! Maybe_periodic limit is 100 calls. Reserved for future sponsored transaction support.58//! At 100 calls reserved amount is not so much and this is avoid potential problems with balance locks.59//! Any account allowed to schedule any calls. Account withdraw implemented through default transaction logic.60//!61//! ## Interface62//!63//! ### Dispatchable Functions64//!65//! * `schedule_named` - augments the `schedule` interface with an additional `Vec<u8>` parameter66//! that can be used for identification.67//! * `cancel_named` - the named complement to the cancel function.6869// Ensure we're `no_std` when compiling for Wasm.70#![cfg_attr(not(feature = "std"), no_std)]7172#[cfg(feature = "runtime-benchmarks")]73mod benchmarking;7475pub mod weights;7677use sp_core::H160;78use codec::{Codec, Decode, Encode};79use frame_system::{self as system, ensure_signed};80pub use pallet::*;81use scale_info::TypeInfo;82use sp_runtime::{83 traits::{BadOrigin, One, Saturating, Zero},84 RuntimeDebug, DispatchErrorWithPostInfo,85};86use sp_std::{borrow::Borrow, cmp::Ordering, marker::PhantomData, prelude::*};8788use frame_support::{89 dispatch::{DispatchError, DispatchResult, Dispatchable, UnfilteredDispatchable, Parameter},90 traits::{91 schedule::{self, DispatchTime, MaybeHashed},92 NamedReservableCurrency, EnsureOrigin, Get, IsType, OriginTrait, PrivilegeCmp,93 StorageVersion,94 },95 weights::{Weight},96};9798pub use weights::WeightInfo;99100/// The location of a scheduled task that can be used to remove it.101pub type TaskAddress<BlockNumber> = (BlockNumber, u32);102pub const MAX_TASK_ID_LENGTH_IN_BYTES: u8 = 16;103104type ScheduledId = [u8; MAX_TASK_ID_LENGTH_IN_BYTES as usize];105pub type CallOrHashOf<T> =106 MaybeHashed<<T as Config>::RuntimeCall, <T as frame_system::Config>::Hash>;107108/// Information regarding an item to be executed in the future.109#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]110#[derive(Clone, RuntimeDebug, Encode, Decode, TypeInfo)]111pub struct ScheduledV3<Call, BlockNumber, PalletsOrigin, AccountId> {112 /// The unique identity for this task, if there is one.113 maybe_id: Option<ScheduledId>,114 /// This task's priority.115 priority: schedule::Priority,116 /// The call to be dispatched.117 call: Call,118 /// If the call is periodic, then this points to the information concerning that.119 maybe_periodic: Option<schedule::Period<BlockNumber>>,120 /// The origin to dispatch the call.121 origin: PalletsOrigin,122 _phantom: PhantomData<AccountId>,123}124125pub type ScheduledV3Of<T> = ScheduledV3<126 CallOrHashOf<T>,127 <T as frame_system::Config>::BlockNumber,128 <T as Config>::PalletsOrigin,129 <T as frame_system::Config>::AccountId,130>;131132pub type ScheduledOf<T> = ScheduledV3Of<T>;133134/// The current version of Scheduled struct.135pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> =136 ScheduledV3<Call, BlockNumber, PalletsOrigin, AccountId>;137138pub enum ScheduledEnsureOriginSuccess<AccountId> {139 Root,140 Signed(AccountId),141 Unsigned,142}143144#[cfg(feature = "runtime-benchmarks")]145mod preimage_provider {146 use frame_support::traits::PreimageRecipient;147 pub trait PreimageProviderAndMaybeRecipient<H>: PreimageRecipient<H> {}148 impl<H, T: PreimageRecipient<H>> PreimageProviderAndMaybeRecipient<H> for T {}149}150151#[cfg(not(feature = "runtime-benchmarks"))]152mod preimage_provider {153 use frame_support::traits::PreimageProvider;154 pub trait PreimageProviderAndMaybeRecipient<H>: PreimageProvider<H> {}155 impl<H, T: PreimageProvider<H>> PreimageProviderAndMaybeRecipient<H> for T {}156}157158pub use preimage_provider::PreimageProviderAndMaybeRecipient;159160pub(crate) trait MarginalWeightInfo: WeightInfo {161 fn item(periodic: bool, named: bool, resolved: Option<bool>) -> Weight {162 match (periodic, named, resolved) {163 (_, false, None) => Self::on_initialize_aborted(2) - Self::on_initialize_aborted(1),164 (_, true, None) => {165 Self::on_initialize_named_aborted(2) - Self::on_initialize_named_aborted(1)166 }167 (false, false, Some(false)) => Self::on_initialize(2) - Self::on_initialize(1),168 (false, true, Some(false)) => {169 Self::on_initialize_named(2) - Self::on_initialize_named(1)170 }171 (true, false, Some(false)) => {172 Self::on_initialize_periodic(2) - Self::on_initialize_periodic(1)173 }174 (true, true, Some(false)) => {175 Self::on_initialize_periodic_named_resolved(2)176 - Self::on_initialize_periodic_named_resolved(1)177 }178 (false, false, Some(true)) => Self::on_initialize(2) - Self::on_initialize(1),179 (false, true, Some(true)) => {180 Self::on_initialize_named_resolved(2) - Self::on_initialize_named_resolved(1)181 }182 (true, false, Some(true)) => {183 Self::on_initialize_periodic_resolved(2) - Self::on_initialize_periodic_resolved(1)184 }185 (true, true, Some(true)) => {186 Self::on_initialize_periodic_named_resolved(2)187 - Self::on_initialize_periodic_named_resolved(1)188 }189 }190 }191}192impl<T: WeightInfo> MarginalWeightInfo for T {}193194#[frame_support::pallet]195pub mod pallet {196 use super::*;197 use frame_support::{198 dispatch::PostDispatchInfo,199 pallet_prelude::*,200 traits::{201 schedule::{LookupError, LOWEST_PRIORITY},202 PreimageProvider,203 },204 };205 use frame_system::pallet_prelude::*;206207 /// The current storage version.208 const STORAGE_VERSION: StorageVersion = StorageVersion::new(3);209210 #[pallet::pallet]211 #[pallet::generate_store(pub(super) trait Store)]212 #[pallet::storage_version(STORAGE_VERSION)]213 #[pallet::without_storage_info]214 pub struct Pallet<T>(_);215216 /// `system::Config` should always be included in our implied traits.217 #[pallet::config]218 pub trait Config: frame_system::Config {219 /// The overarching event type.220 type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;221222 /// The aggregated origin which the dispatch will take.223 type RuntimeOrigin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>224 + From<Self::PalletsOrigin>225 + IsType<<Self as system::Config>::RuntimeOrigin>;226227 /// The caller origin, overarching type of all pallets origins.228 type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + Clone + Eq + TypeInfo;229230 type Currency: NamedReservableCurrency<Self::AccountId, ReserveIdentifier = ScheduledId>;231232 /// The aggregated call type.233 type RuntimeCall: Parameter234 + Dispatchable<Origin = <Self as Config>::RuntimeOrigin, PostInfo = PostDispatchInfo>235 + UnfilteredDispatchable<Origin = <Self as system::Config>::RuntimeOrigin>236 + GetDispatchInfo237 + From<system::RuntimeCall<Self>>;238239 /// The maximum weight that may be scheduled per block for any dispatchables of less240 /// priority than `schedule::HARD_DEADLINE`.241 #[pallet::constant]242 type MaximumWeight: Get<Weight>;243244 /// Required origin to schedule or cancel calls.245 type ScheduleOrigin: EnsureOrigin<246 <Self as system::Config>::RuntimeOrigin,247 Success = ScheduledEnsureOriginSuccess<Self::AccountId>,248 >;249250 /// Required origin to set/change calls' priority.251 type PrioritySetOrigin: EnsureOrigin<<Self as system::Config>::RuntimeOrigin>;252253 /// Compare the privileges of origins.254 ///255 /// This will be used when canceling a task, to ensure that the origin that tries256 /// to cancel has greater or equal privileges as the origin that created the scheduled task.257 ///258 /// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can259 /// be used. This will only check if two given origins are equal.260 type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;261262 /// The maximum number of scheduled calls in the queue for a single block.263 /// Not strictly enforced, but used for weight estimation.264 #[pallet::constant]265 type MaxScheduledPerBlock: Get<u32>;266267 /// Weight information for extrinsics in this pallet.268 type WeightInfo: WeightInfo;269270 /// The preimage provider with which we look up call hashes to get the call.271 type PreimageProvider: PreimageProviderAndMaybeRecipient<Self::Hash>;272273 /// If `Some` then the number of blocks to postpone execution for when the item is delayed.274 type NoPreimagePostponement: Get<Option<Self::BlockNumber>>;275276 /// Sponsoring function.277 // type SponsorshipHandler: SponsorshipHandler<Self::AccountId, <Self as Config>::Call>;278279 /// The helper type used for custom transaction fee logic.280 type CallExecutor: DispatchCall<Self, H160>;281 }282283 /// A Scheduler-Runtime interface for finer payment handling.284 pub trait DispatchCall<T: frame_system::Config + Config, SelfContainedSignedInfo> {285 /// Reserve (lock) the maximum spendings on a call, calculated from its weight and the repetition count.286 fn reserve_balance(287 id: ScheduledId,288 sponsor: <T as frame_system::Config>::AccountId,289 call: <T as Config>::RuntimeCall,290 count: u32,291 ) -> Result<(), DispatchError>;292293 /// Unreserve (unlock) a certain amount from the payer's reserved funds, returning the change.294 fn pay_for_call(295 id: ScheduledId,296 sponsor: <T as frame_system::Config>::AccountId,297 call: <T as Config>::RuntimeCall,298 ) -> Result<u128, DispatchError>;299300 /// Resolve the call dispatch, including any post-dispatch operations.301 fn dispatch_call(302 signer: Option<T::AccountId>,303 function: <T as Config>::RuntimeCall,304 ) -> Result<305 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,306 TransactionValidityError,307 >;308309 /// Release unspent reserved funds in case of a schedule cancel.310 fn cancel_reserve(311 id: ScheduledId,312 sponsor: <T as frame_system::Config>::AccountId,313 ) -> Result<u128, DispatchError>;314 }315316 /// Items to be executed, indexed by the block number that they should be executed on.317 #[pallet::storage]318 pub type Agenda<T: Config> =319 StorageMap<_, Twox64Concat, T::BlockNumber, Vec<Option<ScheduledV3Of<T>>>, ValueQuery>;320321 /// Lookup from identity to the block number and index of the task.322 #[pallet::storage]323 pub(crate) type Lookup<T: Config> =324 StorageMap<_, Twox64Concat, ScheduledId, TaskAddress<T::BlockNumber>>;325326 /// Events type.327 #[pallet::event]328 #[pallet::generate_deposit(pub(super) fn deposit_event)]329 pub enum Event<T: Config> {330 /// Scheduled some task.331 Scheduled { when: T::BlockNumber, index: u32 },332 /// Canceled some task.333 Canceled { when: T::BlockNumber, index: u32 },334 /// Scheduled task's priority has changed335 PriorityChanged {336 when: T::BlockNumber,337 index: u32,338 priority: schedule::Priority,339 },340 /// Dispatched some task.341 Dispatched {342 task: TaskAddress<T::BlockNumber>,343 id: Option<ScheduledId>,344 result: DispatchResult,345 },346 /// The call for the provided hash was not found so the task has been aborted.347 CallLookupFailed {348 task: TaskAddress<T::BlockNumber>,349 id: Option<ScheduledId>,350 error: LookupError,351 },352 }353354 #[pallet::error]355 pub enum Error<T> {356 /// Failed to schedule a call357 FailedToSchedule,358 /// Cannot find the scheduled call.359 NotFound,360 /// Given target block number is in the past.361 TargetBlockNumberInPast,362 /// Reschedule failed because it does not change scheduled time.363 RescheduleNoChange,364 }365366 #[pallet::hooks]367 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {368 /// Execute the scheduled calls369 fn on_initialize(now: T::BlockNumber) -> Weight {370 let limit = T::MaximumWeight::get();371372 let mut queued = Agenda::<T>::take(now)373 .into_iter()374 .enumerate()375 .filter_map(|(index, s)| Some((index as u32, s?)))376 .collect::<Vec<_>>();377378 if queued.len() as u32 > T::MaxScheduledPerBlock::get() {379 log::warn!(380 target: "runtime::scheduler",381 "Warning: This block has more items queued in Scheduler than \382 expected from the runtime configuration. An update might be needed."383 );384 }385386 queued.sort_by_key(|(_, s)| s.priority);387388 let next = now + One::one();389390 let mut total_weight: Weight = T::WeightInfo::on_initialize(0);391 for (order, (index, mut s)) in queued.into_iter().enumerate() {392 let named = s.maybe_id.is_some();393394 let (call, maybe_completed) = s.call.resolved::<T::PreimageProvider>();395 s.call = call;396397 let resolved = if let Some(completed) = maybe_completed {398 T::PreimageProvider::unrequest_preimage(&completed);399 true400 } else {401 false402 };403 let call = match s.call.as_value().cloned() {404 Some(c) => c,405 None => {406 // Preimage not available - postpone until some block.407 total_weight.saturating_accrue(T::WeightInfo::item(false, named, None));408 if let Some(delay) = T::NoPreimagePostponement::get() {409 let until = now.saturating_add(delay);410 if let Some(ref id) = s.maybe_id {411 let index = Agenda::<T>::decode_len(until).unwrap_or(0);412 Lookup::<T>::insert(id, (until, index as u32));413 }414 Agenda::<T>::append(until, Some(s));415 }416 continue;417 }418 };419420 let periodic = s.maybe_periodic.is_some();421 let call_weight = call.get_dispatch_info().weight;422 let mut item_weight = T::WeightInfo::item(periodic, named, Some(resolved));423 let origin = <<T as Config>::RuntimeOrigin as From<T::PalletsOrigin>>::from(424 s.origin.clone(),425 )426 .into();427 if ensure_signed(origin).is_ok() {428 // Weights of Signed dispatches expect their signing account to be whitelisted.429 item_weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));430 }431432 // We allow a scheduled call if any is true:433 // - It's priority is `HARD_DEADLINE`434 // - It does not push the weight past the limit.435 // - It is the first item in the schedule436 let hard_deadline = s.priority <= schedule::HARD_DEADLINE;437 let test_weight = total_weight438 .saturating_add(call_weight)439 .saturating_add(item_weight);440 if !hard_deadline && order > 0 && test_weight.all_gt(limit) {441 // Cannot be scheduled this block - postpone until next.442 total_weight.saturating_accrue(T::WeightInfo::item(false, named, None));443 if let Some(ref id) = s.maybe_id {444 // NOTE: We could reasonably not do this (in which case there would be one445 // block where the named and delayed item could not be referenced by name),446 // but we will do it anyway since it should be mostly free in terms of447 // weight and it is slightly cleaner.448 let index = Agenda::<T>::decode_len(next).unwrap_or(0);449 Lookup::<T>::insert(id, (next, index as u32));450 }451 Agenda::<T>::append(next, Some(s));452 continue;453 }454455 let scheduled_origin =456 <<T as Config>::RuntimeOrigin as From<T::PalletsOrigin>>::from(s.origin.clone());457 let ensured_origin =458 T::ScheduleOrigin::ensure_origin(scheduled_origin.into()).unwrap();459460 let r;461 match ensured_origin {462 ScheduledEnsureOriginSuccess::Root => {463 r = Ok(call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into()));464 }465 ScheduledEnsureOriginSuccess::Signed(sender) => {466 // Execute transaction via chain default pipeline467 // That means dispatch will be processed like any user's extrinsic e.g. transaction fees will be taken468 r = T::CallExecutor::dispatch_call(Some(sender), call.clone());469 }470 ScheduledEnsureOriginSuccess::Unsigned => {471 // Unsigned version of the above472 r = T::CallExecutor::dispatch_call(None, call.clone());473 }474 }475476 let mut actual_call_weight: Weight = item_weight;477 let result: Result<_, DispatchError> = match r {478 Ok(o) => match o {479 Ok(di) => {480 actual_call_weight = di.actual_weight.unwrap_or(item_weight);481 Ok(())482 }483 Err(err) => Err(err.error),484 },485 Err(_) => {486 log::error!(487 target: "runtime::scheduler",488 "Warning: Scheduler has failed to execute a post-dispatch transaction. \489 This block might have become invalid.");490 Err(DispatchError::CannotLookup)491 } // todo possibly force a skip/return here, do something with the error492 };493494 total_weight.saturating_accrue(item_weight);495 total_weight.saturating_accrue(actual_call_weight);496497 Self::deposit_event(Event::Dispatched {498 task: (now, index),499 id: s.maybe_id.clone(),500 result,501 });502503 if let &Some((period, count)) = &s.maybe_periodic {504 if count > 1 {505 s.maybe_periodic = Some((period, count - 1));506 } else {507 s.maybe_periodic = None;508 }509 let wake = now + period;510 let is_canceled;511512 // If scheduled is named, place its information in `Lookup`513 if let Some(ref id) = s.maybe_id {514 is_canceled = Lookup::<T>::get(id).is_none();515 let wake_index = Agenda::<T>::decode_len(wake).unwrap_or(0);516517 if !is_canceled {518 Lookup::<T>::insert(id, (wake, wake_index as u32));519 }520 } else {521 is_canceled = false;522 }523524 if !is_canceled {525 Agenda::<T>::append(wake, Some(s));526 }527 } else if let Some(ref id) = s.maybe_id {528 Lookup::<T>::remove(id);529 }530 }531 total_weight532 }533 }534535 #[pallet::call]536 impl<T: Config> Pallet<T> {537 /// Schedule a named task.538 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]539 pub fn schedule_named(540 origin: OriginFor<T>,541 id: ScheduledId,542 when: T::BlockNumber,543 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,544 priority: Option<schedule::Priority>,545 call: Box<CallOrHashOf<T>>,546 ) -> DispatchResult {547 T::ScheduleOrigin::ensure_origin(origin.clone())?;548549 if priority.is_some() {550 T::PrioritySetOrigin::ensure_origin(origin.clone())?;551 }552553 let origin = <T as Config>::RuntimeOrigin::from(origin);554 Self::do_schedule_named(555 id,556 DispatchTime::At(when),557 maybe_periodic,558 priority.unwrap_or(LOWEST_PRIORITY),559 origin.caller().clone(),560 *call,561 )?;562 Ok(())563 }564565 /// Cancel a named scheduled task.566 #[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]567 pub fn cancel_named(origin: OriginFor<T>, id: ScheduledId) -> DispatchResult {568 T::ScheduleOrigin::ensure_origin(origin.clone())?;569 let origin = <T as Config>::RuntimeOrigin::from(origin);570 Self::do_cancel_named(Some(origin.caller().clone()), id)?;571 Ok(())572 }573574 /// Schedule a named task after a delay.575 ///576 /// # <weight>577 /// Same as [`schedule_named`](Self::schedule_named).578 /// # </weight>579 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]580 pub fn schedule_named_after(581 origin: OriginFor<T>,582 id: ScheduledId,583 after: T::BlockNumber,584 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,585 priority: Option<schedule::Priority>,586 call: Box<CallOrHashOf<T>>,587 ) -> DispatchResult {588 T::ScheduleOrigin::ensure_origin(origin.clone())?;589590 if priority.is_some() {591 T::PrioritySetOrigin::ensure_origin(origin.clone())?;592 }593594 let origin = <T as Config>::RuntimeOrigin::from(origin);595 Self::do_schedule_named(596 id,597 DispatchTime::After(after),598 maybe_periodic,599 priority.unwrap_or(LOWEST_PRIORITY),600 origin.caller().clone(),601 *call,602 )?;603 Ok(())604 }605606 #[pallet::weight(<T as Config>::WeightInfo::change_named_priority(T::MaxScheduledPerBlock::get()))]607 pub fn change_named_priority(608 origin: OriginFor<T>,609 id: ScheduledId,610 priority: schedule::Priority,611 ) -> DispatchResult {612 T::PrioritySetOrigin::ensure_origin(origin.clone())?;613 let origin = <T as Config>::Origin::from(origin);614 Self::do_change_named_priority(origin.caller().clone(), id, priority)615 }616 }617}618619impl<T: Config> Pallet<T> {620 #[cfg(feature = "try-runtime")]621 pub fn pre_migrate_to_v3() -> Result<(), &'static str> {622 Ok(())623 }624625 #[cfg(feature = "try-runtime")]626 pub fn post_migrate_to_v3() -> Result<(), &'static str> {627 use frame_support::dispatch::GetStorageVersion;628629 assert!(Self::current_storage_version() == 3);630 for k in Agenda::<T>::iter_keys() {631 let _ = Agenda::<T>::try_get(k).map_err(|()| "Invalid item in Agenda")?;632 }633 Ok(())634 }635636 /// Helper to migrate scheduler when the pallet origin type has changed.637 pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {638 Agenda::<T>::translate::<639 Vec<Option<Scheduled<CallOrHashOf<T>, T::BlockNumber, OldOrigin, T::AccountId>>>,640 _,641 >(|_, agenda| {642 Some(643 agenda644 .into_iter()645 .map(|schedule| {646 schedule.map(|schedule| Scheduled {647 maybe_id: schedule.maybe_id,648 priority: schedule.priority,649 call: schedule.call,650 maybe_periodic: schedule.maybe_periodic,651 origin: schedule.origin.into(),652 _phantom: Default::default(),653 })654 })655 .collect::<Vec<_>>(),656 )657 });658 }659660 fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {661 let now = frame_system::Pallet::<T>::block_number();662663 let when = match when {664 DispatchTime::At(x) => x,665 // The current block has already completed it's scheduled tasks, so666 // Schedule the task at lest one block after this current block.667 DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),668 };669670 if when <= now {671 return Err(Error::<T>::TargetBlockNumberInPast.into());672 }673674 Ok(when)675 }676677 fn do_schedule_named(678 id: ScheduledId,679 when: DispatchTime<T::BlockNumber>,680 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,681 priority: schedule::Priority,682 origin: T::PalletsOrigin,683 call: CallOrHashOf<T>,684 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {685 // ensure id it is unique686 if Lookup::<T>::contains_key(&id) {687 return Err(Error::<T>::FailedToSchedule)?;688 }689690 let when = Self::resolve_time(when)?;691692 call.ensure_requested::<T::PreimageProvider>();693694 // sanitize maybe_periodic695 let maybe_periodic = maybe_periodic696 .filter(|p| p.1 > 1 && !p.0.is_zero())697 // Remove one from the number of repetitions since we will schedule one now.698 .map(|(p, c)| (p, c - 1));699700 let s = Scheduled {701 maybe_id: Some(id.clone()),702 priority,703 call: call.clone(),704 maybe_periodic,705 origin: origin.clone(),706 _phantom: Default::default(),707 };708709 // reserve balance for periodic execution710 // let sender =711 // ensure_signed(<<T as Config>::Origin as From<T::PalletsOrigin>>::from(origin).into())?;712 // let repeats = match maybe_periodic {713 // Some(p) => p.1,714 // None => 1,715 // };716 // let _ = T::CallExecutor::reserve_balance(717 // id.clone(),718 // sender,719 // call.as_value().unwrap().clone(),720 // repeats,721 // );722723 Agenda::<T>::append(when, Some(s));724 let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;725 let address = (when, index);726 Lookup::<T>::insert(&id, &address);727 Self::deposit_event(Event::Scheduled { when, index });728729 Ok(address)730 }731732 fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: ScheduledId) -> DispatchResult {733 Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {734 if let Some((when, index)) = lookup.take() {735 let i = index as usize;736 Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {737 if let Some(s) = agenda.get_mut(i) {738 if let (Some(ref o), Some(ref s)) = (origin.clone(), s.borrow()) {739 if matches!(740 T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),741 Some(Ordering::Less) | None742 ) {743 return Err(BadOrigin.into());744 }745 // release balance reserve746 // let sender = ensure_signed(747 // <<T as Config>::Origin as From<T::PalletsOrigin>>::from(748 // origin.unwrap(),749 // )750 // .into(),751 // )?;752 // let _ = T::CallExecutor::cancel_reserve(id, sender);753754 s.call.ensure_unrequested::<T::PreimageProvider>();755 }756 *s = None;757 }758 Ok(())759 })?;760761 Self::deposit_event(Event::Canceled { when, index });762 Ok(())763 } else {764 Err(Error::<T>::NotFound)?765 }766 })767 }768769 fn do_change_named_priority(770 origin: T::PalletsOrigin,771 id: ScheduledId,772 priority: schedule::Priority,773 ) -> DispatchResult {774 match Lookup::<T>::get(id) {775 Some((when, index)) => {776 let i = index as usize;777 Agenda::<T>::try_mutate(when, |agenda| {778 if let Some(Some(s)) = agenda.get_mut(i) {779 if matches!(780 T::OriginPrivilegeCmp::cmp_privilege(&origin, &s.origin),781 Some(Ordering::Less) | None782 ) {783 return Err(BadOrigin.into());784 }785786 s.priority = priority;787 Self::deposit_event(Event::PriorityChanged {788 when,789 index,790 priority,791 });792 }793 Ok(())794 })795 }796 None => Err(Error::<T>::NotFound.into()),797 }798 }799}