difftreelog
Reworked
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.028//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//! may be named or anonymous and may be canceled.47//!48//! **NOTE:** The scheduled calls will be dispatched with the default filter49//! for the origin: namely `frame_system::Config::BaseCallFilter` for all origin50//! except root which will get no filter. And not the filter contained in origin51//! use to call `fn schedule`.52//!53//! If a call is scheduled using proxy or whatever mecanism which adds filter,54//! then those filter will not be used when dispatching the schedule call.55//!56//! **NOTE:** The unique scheduler is designed for deferred transaction calls by block number.57//! Any user can book a call of a certain transaction to a specific block number.58//! Also possible to book a call with a certain frequency.59//!60//! Key differences from original pallet:61//! https://crates.io/crates/pallet-scheduler62//! Schedule Id restricted by 16 bytes63//! Priority limited by HARD DEADLINE (<= 63). Calls over maximum weight don't include to block64//! Maybe_periodic limit is 100 calls65//! Any account allowed to schedule any calls. Account withdraw implemented through default transaction logic.66//!67//! ## Interface68//!69//! ### Dispatchable Functions70//!71//! * `schedule` - schedule a dispatch, which may be periodic, to occur at a specified block and72//! with a specified priority.73//! * `cancel` - cancel a scheduled dispatch, specified by block number and index.74//! * `schedule_named` - augments the `schedule` interface with an additional `Vec<u8>` parameter75//! that can be used for identification.76//! * `cancel_named` - the named complement to the cancel function.7778// Ensure we're `no_std` when compiling for Wasm.79#![cfg_attr(not(feature = "std"), no_std)]8081#[cfg(feature = "runtime-benchmarks")]82mod benchmarking;8384pub mod weights;8586use sp_core::H160;87use codec::{Codec, Decode, Encode};88use frame_system::{self as system, ensure_signed};89pub use pallet::*;90use scale_info::TypeInfo;91use sp_runtime::{92 traits::{BadOrigin, One, Saturating, Zero},93 RuntimeDebug, DispatchErrorWithPostInfo,94};95use sp_std::{borrow::Borrow, cmp::Ordering, marker::PhantomData, prelude::*};9697use frame_support::{98 dispatch::{DispatchError, DispatchResult, Dispatchable, Parameter},99 traits::{100 schedule::{self, DispatchTime, MaybeHashed},101 NamedReservableCurrency, EnsureOrigin, Get, IsType, OriginTrait, PrivilegeCmp,102 StorageVersion,103 },104 weights::{GetDispatchInfo, Weight},105};106107pub use weights::WeightInfo;108109/// Just a simple index for naming period tasks.110pub type PeriodicIndex = u32;111/// The location of a scheduled task that can be used to remove it.112pub type TaskAddress<BlockNumber> = (BlockNumber, u32);113pub const MAX_TASK_ID_LENGTH_IN_BYTES: u8 = 16;114115type ScheduledId = [u8; MAX_TASK_ID_LENGTH_IN_BYTES as usize];116pub type CallOrHashOf<T> = MaybeHashed<<T as Config>::Call, <T as frame_system::Config>::Hash>;117118/// Information regarding an item to be executed in the future.119#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]120#[derive(Clone, RuntimeDebug, Encode, Decode, TypeInfo)]121pub struct ScheduledV3<Call, BlockNumber, PalletsOrigin, AccountId> {122 /// The unique identity for this task, if there is one.123 maybe_id: Option<ScheduledId>,124 /// This task's priority.125 priority: schedule::Priority,126 /// The call to be dispatched.127 call: Call,128 /// If the call is periodic, then this points to the information concerning that.129 maybe_periodic: Option<schedule::Period<BlockNumber>>,130 /// The origin to dispatch the call.131 origin: PalletsOrigin,132 _phantom: PhantomData<AccountId>,133}134135pub type ScheduledV3Of<T> = ScheduledV3<136 CallOrHashOf<T>,137 <T as frame_system::Config>::BlockNumber,138 <T as Config>::PalletsOrigin,139 <T as frame_system::Config>::AccountId,140>;141142pub type ScheduledOf<T> = ScheduledV3Of<T>;143144/// The current version of Scheduled struct.145pub type Scheduled<Call, BlockNumber, PalletsOrigin, AccountId> =146 ScheduledV3<Call, BlockNumber, PalletsOrigin, AccountId>;147148#[cfg(feature = "runtime-benchmarks")]149mod preimage_provider {150 use frame_support::traits::PreimageRecipient;151 pub trait PreimageProviderAndMaybeRecipient<H>: PreimageRecipient<H> {}152 impl<H, T: PreimageRecipient<H>> PreimageProviderAndMaybeRecipient<H> for T {}153}154155#[cfg(not(feature = "runtime-benchmarks"))]156mod preimage_provider {157 use frame_support::traits::PreimageProvider;158 pub trait PreimageProviderAndMaybeRecipient<H>: PreimageProvider<H> {}159 impl<H, T: PreimageProvider<H>> PreimageProviderAndMaybeRecipient<H> for T {}160}161162pub use preimage_provider::PreimageProviderAndMaybeRecipient;163164/// Weight templates for calculating actual fees165pub(crate) trait MarginalWeightInfo: WeightInfo {166 fn item(periodic: bool, named: bool, resolved: Option<bool>) -> Weight {167 match (periodic, named, resolved) {168 (_, false, None) => Self::on_initialize_aborted(2) - Self::on_initialize_aborted(1),169 (_, true, None) => {170 Self::on_initialize_named_aborted(2) - Self::on_initialize_named_aborted(1)171 }172 (false, false, Some(false)) => Self::on_initialize(2) - Self::on_initialize(1),173 (false, true, Some(false)) => {174 Self::on_initialize_named(2) - Self::on_initialize_named(1)175 }176 (true, false, Some(false)) => {177 Self::on_initialize_periodic(2) - Self::on_initialize_periodic(1)178 }179 (true, true, Some(false)) => {180 Self::on_initialize_periodic_named_resolved(2)181 - Self::on_initialize_periodic_named_resolved(1)182 }183 (false, false, Some(true)) => Self::on_initialize(2) - Self::on_initialize(1),184 (false, true, Some(true)) => {185 Self::on_initialize_named_resolved(2) - Self::on_initialize_named_resolved(1)186 }187 (true, false, Some(true)) => {188 Self::on_initialize_periodic_resolved(2) - Self::on_initialize_periodic_resolved(1)189 }190 (true, true, Some(true)) => {191 Self::on_initialize_periodic_named_resolved(2)192 - Self::on_initialize_periodic_named_resolved(1)193 }194 }195 }196}197impl<T: WeightInfo> MarginalWeightInfo for T {}198199#[frame_support::pallet]200pub mod pallet {201 use super::*;202 use frame_support::{203 dispatch::PostDispatchInfo,204 pallet_prelude::*,205 traits::{schedule::LookupError, PreimageProvider},206 };207 use frame_system::pallet_prelude::*;208209 /// The current storage version.210 const STORAGE_VERSION: StorageVersion = StorageVersion::new(3);211212 #[pallet::pallet]213 #[pallet::generate_store(pub(super) trait Store)]214 #[pallet::storage_version(STORAGE_VERSION)]215 #[pallet::without_storage_info]216 pub struct Pallet<T>(_);217218 /// `system::Config` should always be included in our implied traits.219 #[pallet::config]220 pub trait Config: frame_system::Config {221 /// The overarching event type.222 type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;223224 /// The aggregated origin which the dispatch will take.225 type Origin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>226 + From<Self::PalletsOrigin>227 + IsType<<Self as system::Config>::Origin>;228229 /// The caller origin, overarching type of all pallets origins.230 type PalletsOrigin: From<system::RawOrigin<Self::AccountId>> + Codec + Clone + Eq + TypeInfo;231232 type Currency: NamedReservableCurrency<Self::AccountId, ReserveIdentifier = ScheduledId>;233234 /// The aggregated call type.235 type Call: Parameter236 + Dispatchable<Origin = <Self as Config>::Origin, PostInfo = PostDispatchInfo>237 + GetDispatchInfo238 + From<system::Call<Self>>;239240 /// The maximum weight that may be scheduled per block for any dispatchables of less241 /// priority than `schedule::HARD_DEADLINE`.242 #[pallet::constant]243 type MaximumWeight: Get<Weight>;244245 /// Required origin to schedule or cancel calls.246 type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::Origin>;247248 /// Compare the privileges of origins.249 ///250 /// This will be used when canceling a task, to ensure that the origin that tries251 /// to cancel has greater or equal privileges as the origin that created the scheduled task.252 ///253 /// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can254 /// be used. This will only check if two given origins are equal.255 type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;256257 /// The maximum number of scheduled calls in the queue for a single block.258 /// Not strictly enforced, but used for weight estimation.259 #[pallet::constant]260 type MaxScheduledPerBlock: Get<u32>;261262 /// Weight information for extrinsics in this pallet.263 type WeightInfo: WeightInfo;264265 /// The preimage provider with which we look up call hashes to get the call.266 type PreimageProvider: PreimageProviderAndMaybeRecipient<Self::Hash>;267268 /// If `Some` then the number of blocks to postpone execution for when the item is delayed.269 type NoPreimagePostponement: Get<Option<Self::BlockNumber>>;270271 /// Sponsoring function. In this version sposorship is disabled272 // type SponsorshipHandler: SponsorshipHandler<Self::AccountId, <Self as Config>::Call>;273274 /// The helper type used for custom transaction fee logic.275 type CallExecutor: DispatchCall<Self, H160>;276 }277278 /// A Scheduler-Runtime interface for finer payment handling.279 pub trait DispatchCall<T: frame_system::Config + Config, SelfContainedSignedInfo> {280 /// Lock balance required for transaction payment281 fn reserve_balance(282 id: ScheduledId,283 sponsor: <T as frame_system::Config>::AccountId,284 call: <T as Config>::Call,285 count: u32,286 ) -> Result<(), DispatchError>;287288 /// Unlock centain amount from payer289 fn pay_for_call(290 id: ScheduledId,291 sponsor: <T as frame_system::Config>::AccountId,292 call: <T as Config>::Call,293 ) -> Result<u128, DispatchError>;294295 /// Resolve the call dispatch, including any post-dispatch operations.296 fn dispatch_call(297 signer: T::AccountId,298 function: <T as Config>::Call,299 ) -> Result<300 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,301 TransactionValidityError,302 >;303304 /// Cancel schedule reservation and unlock balance305 fn cancel_reserve(306 id: ScheduledId,307 sponsor: <T as frame_system::Config>::AccountId,308 ) -> Result<u128, DispatchError>;309 }310311 /// Items to be executed, indexed by the block number that they should be executed on.312 #[pallet::storage]313 pub type Agenda<T: Config> =314 StorageMap<_, Twox64Concat, T::BlockNumber, Vec<Option<ScheduledV3Of<T>>>, ValueQuery>;315316 /// Lookup from identity to the block number and index of the task.317 #[pallet::storage]318 pub(crate) type Lookup<T: Config> =319 StorageMap<_, Twox64Concat, ScheduledId, TaskAddress<T::BlockNumber>>;320321 /// Events type.322 #[pallet::event]323 #[pallet::generate_deposit(pub(super) fn deposit_event)]324 pub enum Event<T: Config> {325 /// Scheduled some task.326 Scheduled { when: T::BlockNumber, index: u32 },327 /// Canceled some task.328 Canceled { when: T::BlockNumber, index: u32 },329 /// Dispatched some task.330 Dispatched {331 task: TaskAddress<T::BlockNumber>,332 id: Option<ScheduledId>,333 result: DispatchResult,334 },335 /// The call for the provided hash was not found so the task has been aborted.336 CallLookupFailed {337 task: TaskAddress<T::BlockNumber>,338 id: Option<ScheduledId>,339 error: LookupError,340 },341 }342343 #[pallet::error]344 pub enum Error<T> {345 /// Failed to schedule a call346 FailedToSchedule,347 /// Cannot find the scheduled call.348 NotFound,349 /// Given target block number is in the past.350 TargetBlockNumberInPast,351 /// Reschedule failed because it does not change scheduled time.352 RescheduleNoChange,353 }354355 #[pallet::hooks]356 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {357 /// Execute the scheduled calls358 fn on_initialize(now: T::BlockNumber) -> Weight {359 let limit = T::MaximumWeight::get();360361 let mut queued = Agenda::<T>::take(now)362 .into_iter()363 .enumerate()364 .filter_map(|(index, s)| Some((index as u32, s?)))365 .collect::<Vec<_>>();366367 if queued.len() as u32 > T::MaxScheduledPerBlock::get() {368 log::warn!(369 target: "runtime::scheduler",370 "Warning: This block has more items queued in Scheduler than \371 expected from the runtime configuration. An update might be needed."372 );373 }374375 queued.sort_by_key(|(_, s)| s.priority);376377 let next = now + One::one();378379 let mut total_weight: Weight = T::WeightInfo::on_initialize(0);380 for (order, (index, mut s)) in queued.into_iter().enumerate() {381 let named = if let Some(ref id) = s.maybe_id {382 Lookup::<T>::remove(id);383 true384 } else {385 false386 };387388 let (call, maybe_completed) = s.call.resolved::<T::PreimageProvider>();389 s.call = call;390391 let resolved = if let Some(completed) = maybe_completed {392 T::PreimageProvider::unrequest_preimage(&completed);393 true394 } else {395 false396 };397 let call = match s.call.as_value().cloned() {398 Some(c) => c,399 None => {400 // Preimage not available - postpone until some block.401 total_weight.saturating_accrue(T::WeightInfo::item(false, named, None));402 if let Some(delay) = T::NoPreimagePostponement::get() {403 let until = now.saturating_add(delay);404 if let Some(ref id) = s.maybe_id {405 let index = Agenda::<T>::decode_len(until).unwrap_or(0);406 Lookup::<T>::insert(id, (until, index as u32));407 }408 Agenda::<T>::append(until, Some(s));409 }410 continue;411 }412 };413414 let periodic = s.maybe_periodic.is_some();415 let call_weight = call.get_dispatch_info().weight;416 let mut item_weight = T::WeightInfo::item(periodic, named, Some(resolved));417 let origin =418 <<T as Config>::Origin as From<T::PalletsOrigin>>::from(s.origin.clone())419 .into();420 if ensure_signed(origin).is_ok() {421 // Weights of Signed dispatches expect their signing account to be whitelisted.422 item_weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));423 }424425 // We allow a scheduled call if any is true:426 // - It's priority is `HARD_DEADLINE`427 // - It does not push the weight past the limit.428 // - It is the first item in the schedule429 let hard_deadline = s.priority <= schedule::HARD_DEADLINE;430 let test_weight = total_weight431 .saturating_add(call_weight)432 .saturating_add(item_weight);433 if !hard_deadline && order > 0 && test_weight > limit {434 // Cannot be scheduled this block - postpone until next.435 total_weight.saturating_accrue(T::WeightInfo::item(false, named, None));436 if let Some(ref id) = s.maybe_id {437 // NOTE: We could reasonably not do this (in which case there would be one438 // block where the named and delayed item could not be referenced by name),439 // but we will do it anyway since it should be mostly free in terms of440 // weight and it is slightly cleaner.441 let index = Agenda::<T>::decode_len(next).unwrap_or(0);442 Lookup::<T>::insert(id, (next, index as u32));443 }444 Agenda::<T>::append(next, Some(s));445 continue;446 }447448 // Sender is the account who signed transaction449 let sender = ensure_signed(450 <<T as Config>::Origin as From<T::PalletsOrigin>>::from(s.origin.clone())451 .into(),452 )453 .unwrap();454455 // // if call have id it was be reserved456 // if s.maybe_id.is_some() {457 // let _ = T::CallExecutor::pay_for_call(458 // s.maybe_id.unwrap(),459 // sender.clone(),460 // call.clone(),461 // );462 // }463464 // Execute transaction via chain default pipeline465 // That means dispatch will be processed like any user's extrinsic e.g. transaction fees will be taken466 let r = T::CallExecutor::dispatch_call(sender, call.clone());467468 let mut actual_call_weight: Weight = item_weight;469 let result: Result<_, DispatchError> = match r {470 Ok(o) => match o {471 Ok(di) => {472 actual_call_weight = di.actual_weight.unwrap_or(item_weight);473 Ok(())474 }475 Err(err) => Err(err.error),476 },477 Err(_) => {478 log::error!(479 target: "runtime::scheduler",480 "Warning: Scheduler has failed to execute a post-dispatch transaction. \481 This block might have become invalid.");482 Err(DispatchError::CannotLookup)483 } // todo possibly force a skip/return here, do something with the error484 };485486 total_weight.saturating_accrue(item_weight);487 total_weight.saturating_accrue(actual_call_weight);488489 Self::deposit_event(Event::Dispatched {490 task: (now, index),491 id: s.maybe_id.clone(),492 result,493 });494495 if let &Some((period, count)) = &s.maybe_periodic {496 if count > 1 {497 s.maybe_periodic = Some((period, count - 1));498 } else {499 s.maybe_periodic = None;500 }501 let wake = now + period;502 // If scheduled is named, place its information in `Lookup`503 if let Some(ref id) = s.maybe_id {504 let wake_index = Agenda::<T>::decode_len(wake).unwrap_or(0);505 Lookup::<T>::insert(id, (wake, wake_index as u32));506 }507 Agenda::<T>::append(wake, Some(s));508 }509 }510 /// Weight should be 0, because transaction already paid511 0512 }513 }514515 #[pallet::call]516 impl<T: Config> Pallet<T> {517 /// Schedule a named task.518 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]519 pub fn schedule_named(520 origin: OriginFor<T>,521 id: ScheduledId,522 when: T::BlockNumber,523 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,524 priority: schedule::Priority,525 call: Box<CallOrHashOf<T>>,526 ) -> DispatchResult {527 T::ScheduleOrigin::ensure_origin(origin.clone())?;528 let origin = <T as Config>::Origin::from(origin);529 Self::do_schedule_named(530 id,531 DispatchTime::At(when),532 maybe_periodic,533 priority,534 origin.caller().clone(),535 *call,536 )?;537 Ok(())538 }539540 /// Cancel a named scheduled task.541 #[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]542 pub fn cancel_named(origin: OriginFor<T>, id: ScheduledId) -> DispatchResult {543 T::ScheduleOrigin::ensure_origin(origin.clone())?;544 let origin = <T as Config>::Origin::from(origin);545 Self::do_cancel_named(Some(origin.caller().clone()), id)?;546 Ok(())547 }548549 /// Schedule a named task after a delay.550 ///551 /// # <weight>552 /// Same as [`schedule_named`](Self::schedule_named).553 /// # </weight>554 #[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]555 pub fn schedule_named_after(556 origin: OriginFor<T>,557 id: ScheduledId,558 after: T::BlockNumber,559 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,560 priority: schedule::Priority,561 call: Box<CallOrHashOf<T>>,562 ) -> DispatchResult {563 T::ScheduleOrigin::ensure_origin(origin.clone())?;564 let origin = <T as Config>::Origin::from(origin);565 Self::do_schedule_named(566 id,567 DispatchTime::After(after),568 maybe_periodic,569 priority,570 origin.caller().clone(),571 *call,572 )?;573 Ok(())574 }575 }576}577578impl<T: Config> Pallet<T> {579 #[cfg(feature = "try-runtime")]580 pub fn pre_migrate_to_v3() -> Result<(), &'static str> {581 Ok(())582 }583584 #[cfg(feature = "try-runtime")]585 pub fn post_migrate_to_v3() -> Result<(), &'static str> {586 use frame_support::dispatch::GetStorageVersion;587588 assert!(Self::current_storage_version() == 3);589 for k in Agenda::<T>::iter_keys() {590 let _ = Agenda::<T>::try_get(k).map_err(|()| "Invalid item in Agenda")?;591 }592 Ok(())593 }594595 /// Helper to migrate scheduler when the pallet origin type has changed.596 pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {597 Agenda::<T>::translate::<598 Vec<Option<Scheduled<CallOrHashOf<T>, T::BlockNumber, OldOrigin, T::AccountId>>>,599 _,600 >(|_, agenda| {601 Some(602 agenda603 .into_iter()604 .map(|schedule| {605 schedule.map(|schedule| Scheduled {606 maybe_id: schedule.maybe_id,607 priority: schedule.priority,608 call: schedule.call,609 maybe_periodic: schedule.maybe_periodic,610 origin: schedule.origin.into(),611 _phantom: Default::default(),612 })613 })614 .collect::<Vec<_>>(),615 )616 });617 }618619 fn resolve_time(when: DispatchTime<T::BlockNumber>) -> Result<T::BlockNumber, DispatchError> {620 let now = frame_system::Pallet::<T>::block_number();621622 let when = match when {623 DispatchTime::At(x) => x,624 // The current block has already completed it's scheduled tasks, so625 // Schedule the task at lest one block after this current block.626 DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),627 };628629 if when <= now {630 return Err(Error::<T>::TargetBlockNumberInPast.into());631 }632633 Ok(when)634 }635636 fn do_schedule_named(637 id: ScheduledId,638 when: DispatchTime<T::BlockNumber>,639 maybe_periodic: Option<schedule::Period<T::BlockNumber>>,640 priority: schedule::Priority,641 origin: T::PalletsOrigin,642 call: CallOrHashOf<T>,643 ) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {644 // ensure id it is unique645 if Lookup::<T>::contains_key(&id) {646 return Err(Error::<T>::FailedToSchedule)?;647 }648649 let when = Self::resolve_time(when)?;650651 call.ensure_requested::<T::PreimageProvider>();652653 // sanitize maybe_periodic654 let maybe_periodic = maybe_periodic655 .filter(|p| p.1 > 1 && !p.0.is_zero())656 // Remove one from the number of repetitions since we will schedule one now.657 .map(|(p, c)| (p, c - 1));658659 let s = Scheduled {660 maybe_id: Some(id.clone()),661 priority,662 call: call.clone(),663 maybe_periodic,664 origin: origin.clone(),665 _phantom: Default::default(),666 };667668 // reserve balance for periodic execution669 // let sender =670 // ensure_signed(<<T as Config>::Origin as From<T::PalletsOrigin>>::from(origin).into())?;671 // let repeats = match maybe_periodic {672 // Some(p) => p.1,673 // None => 1,674 // };675 // let _ = T::CallExecutor::reserve_balance(676 // id.clone(),677 // sender,678 // call.as_value().unwrap().clone(),679 // repeats,680 // );681682 Agenda::<T>::append(when, Some(s));683 let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;684 let address = (when, index);685 Lookup::<T>::insert(&id, &address);686 Self::deposit_event(Event::Scheduled { when, index });687688 Ok(address)689 }690691 fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: ScheduledId) -> DispatchResult {692 Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {693 if let Some((when, index)) = lookup.take() {694 let i = index as usize;695 Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {696 if let Some(s) = agenda.get_mut(i) {697 if let (Some(ref o), Some(ref s)) = (origin.clone(), s.borrow()) {698 if matches!(699 T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),700 Some(Ordering::Less) | None701 ) {702 return Err(BadOrigin.into());703 }704 // release balance reserve705 // let sender = ensure_signed(706 // <<T as Config>::Origin as From<T::PalletsOrigin>>::from(707 // origin.unwrap(),708 // )709 // .into(),710 // )?;711 // let _ = T::CallExecutor::cancel_reserve(id, sender);712713 s.call.ensure_unrequested::<T::PreimageProvider>();714 }715 *s = None;716 }717 Ok(())718 })?;719720 Self::deposit_event(Event::Canceled { when, index });721 Ok(())722 } else {723 Err(Error::<T>::NotFound)?724 }725 })726 }727}