git.delta.rocks / unique-network / refs/commits / f2ed65d6da99

5356 "pallet-transaction-payment-rpc-runtime-api",5356 "pallet-transaction-payment-rpc-runtime-api",
5357 "pallet-treasury",5357 "pallet-treasury",
5358 "pallet-unique",5358 "pallet-unique",
5359 "pallet-unq-scheduler",5359 "pallet-unique-scheduler",
5360 "pallet-xcm",5360 "pallet-xcm",
5361 "parachain-info",5361 "parachain-info",
5362 "parity-scale-codec 3.1.2",5362 "parity-scale-codec 3.1.2",
6646]6646]
66476647
6648[[package]]6648[[package]]
6649name = "pallet-unq-scheduler"6649name = "pallet-unique-scheduler"
6650version = "0.1.0"6650version = "0.1.0"
6651dependencies = [6651dependencies = [
6652 "frame-benchmarking",6652 "frame-benchmarking",
8590 "pallet-transaction-payment-rpc-runtime-api",8590 "pallet-transaction-payment-rpc-runtime-api",
8591 "pallet-treasury",8591 "pallet-treasury",
8592 "pallet-unique",8592 "pallet-unique",
8593 "pallet-unq-scheduler",8593 "pallet-unique-scheduler",
8594 "pallet-xcm",8594 "pallet-xcm",
8595 "parachain-info",8595 "parachain-info",
8596 "parity-scale-codec 3.1.2",8596 "parity-scale-codec 3.1.2",
12643 "pallet-transaction-payment-rpc-runtime-api",12643 "pallet-transaction-payment-rpc-runtime-api",
12644 "pallet-treasury",12644 "pallet-treasury",
12645 "pallet-unique",12645 "pallet-unique",
12646 "pallet-unq-scheduler",12646 "pallet-unique-scheduler",
12647 "pallet-xcm",12647 "pallet-xcm",
12648 "parachain-info",12648 "parachain-info",
12649 "parity-scale-codec 3.1.2",12649 "parity-scale-codec 3.1.2",
12688 "pallet-nonfungible",12688 "pallet-nonfungible",
12689 "pallet-refungible",12689 "pallet-refungible",
12690 "pallet-unique",12690 "pallet-unique",
12691 "pallet-unique-scheduler",
12691 "parity-scale-codec 3.1.2",12692 "parity-scale-codec 3.1.2",
12692 "rmrk-rpc",12693 "rmrk-rpc",
12693 "scale-info",12694 "scale-info",

65	--template .maintain/frame-weight-template.hbs --steps=50 --repeat=200 --heap-pages=4096 \65	--template .maintain/frame-weight-template.hbs --steps=50 --repeat=200 --heap-pages=4096 \
66	--output=./pallets/$(PALLET)/src/weights.rs66	--output=./pallets/$(PALLET)/src/weights.rs
67
68.PHONY: _bench2
69_bench2:
70	cargo run --release --features runtime-benchmarks,unique-runtime -- \
71	benchmark pallet --pallet pallet-$(PALLET) \
72	--wasm-execution compiled --extrinsic '*' \
73	--template .maintain/frame-weight-template.hbs --steps=50 --repeat=200 --heap-pages=4096 \
74	--output=./pallets/$(PALLET_DIR)/src/weights.rs
6775
68.PHONY: bench-evm-migration76.PHONY: bench-evm-migration
69bench-evm-migration:77bench-evm-migration:
93bench-structure:101bench-structure:
94	make _bench PALLET=structure102	make _bench PALLET=structure
103
104.PHONY: bench-scheduler
105bench-scheduler:
106	make _bench2 PALLET=unique-scheduler PALLET_DIR=scheduler
95107
96.PHONY: bench-rmrk-core108.PHONY: bench-rmrk-core
97bench-rmrk-core:109bench-rmrk-core:
98	make _bench PALLET=proxy-rmrk-core110	make _bench PALLET=proxy-rmrk-core
99111
100.PHONY: bench112.PHONY: bench
101bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-rmrk-core113bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-scheduler bench-rmrk-core
102114

20use frame_benchmarking::{benchmarks, account};20use frame_benchmarking::{benchmarks, account};
21use up_data_structs::{21use up_data_structs::{
22	CollectionMode, CreateCollectionData, CollectionId, Property, PropertyKey, PropertyValue,22	CollectionMode, CreateCollectionData, CollectionId, Property, PropertyKey, PropertyValue,
23	CollectionPermissions, NestingRule, MAX_COLLECTION_NAME_LENGTH,23	CollectionPermissions, NestingPermissions, MAX_COLLECTION_NAME_LENGTH,
24	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, MAX_PROPERTIES_PER_ITEM,24	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, MAX_PROPERTIES_PER_ITEM,
25};25};
26use frame_support::{26use frame_support::{
94			description,94			description,
95			token_prefix,95			token_prefix,
96			permissions: Some(CollectionPermissions {96			permissions: Some(CollectionPermissions {
97				nesting: Some(NestingRule::Permissive),97				nesting: Some(NestingPermissions {
98					token_owner: false,
99					admin: false,
100					restricted: None,
101					permissive: true,
102				}),
98				..Default::default()103				..Default::default()
99			}),104			}),
100			..Default::default()105			..Default::default()

23use pallet_evm_coder_substrate::dispatch_to_evm;23use pallet_evm_coder_substrate::dispatch_to_evm;
24use sp_std::vec::Vec;24use sp_std::vec::Vec;
25use up_data_structs::{25use up_data_structs::{Property, SponsoringRateLimit, OwnerRestrictedSet, AccessMode, CollectionPermissions};
26	Property, SponsoringRateLimit, NestingRule, OwnerRestrictedSet, AccessMode,
27	CollectionPermissions,
28};
29use alloc::format;26use alloc::format;
3027
220	fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {217	fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {
221		check_is_owner_or_admin(caller, self)?;218		check_is_owner_or_admin(caller, self)?;
219
222		let permissions = CollectionPermissions {220		let mut permissions = self.collection.permissions.clone();
223			nesting: Some(match enable {221		let mut nesting = permissions.nesting().clone();
224				false => NestingRule::Disabled,222		nesting.token_owner = enable;
225				true => NestingRule::Owner,223		nesting.restricted = None;
226			}),224		permissions.nesting = Some(nesting);
227			..Default::default()225
228		};
229		self.collection.permissions = <Pallet<T>>::clamp_permissions(226		self.collection.permissions = <Pallet<T>>::clamp_permissions(
230			self.collection.mode.clone(),227			self.collection.mode.clone(),
231			&self.collection.permissions,228			&self.collection.permissions,
246		if collections.is_empty() {243		if collections.is_empty() {
247			return Err("no addresses provided".into());244			return Err("no addresses provided".into());
248		}245		}
249		if collections.len() >= OwnerRestrictedSet::bound() {
250			return Err(Error::Revert(format!(
251				"out of bound: {} >= {}",
252				collections.len(),
253				OwnerRestrictedSet::bound()
254			)));
255		}
256		check_is_owner_or_admin(caller, self)?;246		check_is_owner_or_admin(caller, self)?;
257		let permissions = CollectionPermissions {247
248		let mut permissions = self.collection.permissions.clone();
258			nesting: Some(match enable {249		match enable {
259				false => NestingRule::Disabled,250			false => {
251				let mut nesting = permissions.nesting().clone();
252				nesting.token_owner = false;
253				nesting.restricted = None;
254				permissions.nesting = Some(nesting);
255			}
260				true => {256			true => {
261					let mut bv = OwnerRestrictedSet::new();257				let mut bv = OwnerRestrictedSet::new();
262					for i in collections {258				for i in collections {
263						bv.try_insert(crate::eth::map_eth_to_id(&i).ok_or_else(|| {259					bv.try_insert(crate::eth::map_eth_to_id(&i).ok_or(Error::Revert(
264							Error::Revert("can't convert address into collection id".into())260						"Can't convert address into collection id".into(),
265						})?)261					))?)
266						.map_err(|e| Error::Revert(format!("{:?}", e)))?;262					.map_err(|_| "too many collections")?;
267					}263				}
264				let mut nesting = permissions.nesting().clone();
265				nesting.token_owner = true;
268					NestingRule::OwnerRestricted(bv)266				nesting.restricted = Some(bv);
267				permissions.nesting = Some(nesting);
269				}268			}
270			}),269		};
271			..Default::default()270
272		};
273		self.collection.permissions = <Pallet<T>>::clamp_permissions(271		self.collection.permissions = <Pallet<T>>::clamp_permissions(
274			self.collection.mode.clone(),272			self.collection.mode.clone(),
275			&self.collection.permissions,273			&self.collection.permissions,

430		/// Not sufficient funds to perform action430		/// Not sufficient funds to perform action
431		NotSufficientFounds,431		NotSufficientFounds,
432432
433		/// Collection has nesting disabled433		/// User not passed nesting rule
434		NestingIsDisabled,434		UserIsNotAllowedToNest,
435		/// Only owner may nest tokens under this collection
436		OnlyOwnerAllowedToNest,
437		/// Only tokens from specific collections may nest tokens under this435		/// Only tokens from specific collections may nest tokens under this
438		SourceCollectionIsNotAllowedToNest,436		SourceCollectionIsNotAllowedToNest,
439437
1212		limit_default_clone!(old_limit, new_limit,1210		limit_default_clone!(old_limit, new_limit,
1213			access => {},1211			access => {},
1214			mint_mode => {},1212			mint_mode => {},
1215			nesting => {},1213			nesting => ensure!(
1214				// Permissive is only allowed for tests and internal usage of chain for now
1215				old_limit.permissive || !new_limit.permissive,
1216				<Error<T>>::NoPermission,
1217			),
1216		);1218		);
1217		Ok(new_limit)1219		Ok(new_limit)
1218	}1220	}

27};27};
28use up_data_structs::{28use up_data_structs::{
29	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,29	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,
30	mapping::TokenAddressMapping, NestingRule, budget::Budget, Property, PropertyPermission,30	mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission, PropertyKey,
31	PropertyKey, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild,31	PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild,
32};32};
33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
996		under: TokenId,996		under: TokenId,
997		nesting_budget: &dyn Budget,997		nesting_budget: &dyn Budget,
998	) -> DispatchResult {998	) -> DispatchResult {
999		fn ensure_sender_allowed<T: Config>(
1000			collection: CollectionId,
1001			token: TokenId,
1002			for_nest: (CollectionId, TokenId),
1003			sender: T::CrossAccountId,
1004			budget: &dyn Budget,
1005		) -> DispatchResult {
1006			ensure!(
1007				<PalletStructure<T>>::check_indirectly_owned(
1008					sender,
1009					collection,
1010					token,
1011					Some(for_nest),
1012					budget
1013				)?,
1014				<CommonError<T>>::OnlyOwnerAllowedToNest,
1015			);
1016			Ok(())
1017		}
1018		match handle.permissions.nesting() {999		let nesting = handle.permissions.nesting();
1019			NestingRule::Disabled => fail!(<CommonError<T>>::NestingIsDisabled),1000		if nesting.permissive {
1020			NestingRule::Owner => {1001			// Pass
1002		} else if nesting.token_owner
1021				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?1003			&& <PalletStructure<T>>::check_indirectly_owned(
1022			}1004				sender.clone(),
1005				handle.id,
1006				under,
1007				Some(from),
1008				nesting_budget,
1009			)? {
1010			// Pass
1011		} else if nesting.admin && handle.is_owner_or_admin(&sender) {
1012			// Pass
1013		} else {
1014			fail!(<CommonError<T>>::UserIsNotAllowedToNest);
1015		}
1016
1023			NestingRule::OwnerRestricted(whitelist) => {1017		if let Some(whitelist) = &nesting.restricted {
1024				ensure!(1018			ensure!(
1025					whitelist.contains(&from.0),1019				whitelist.contains(&from.0),
1026					<CommonError<T>>::SourceCollectionIsNotAllowedToNest1020				<CommonError<T>>::SourceCollectionIsNotAllowedToNest
1027				);1021			);
1028				ensure_sender_allowed::<T>(handle.id, under, from, sender, nesting_budget)?
1029			}1022		}
1030			NestingRule::Permissive => {}
1031		}
1032		Ok(())1023		Ok(())
1033	}1024	}
10341025

200					.try_into()200					.try_into()
201					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,201					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,
202				permissions: Some(CollectionPermissions {202				permissions: Some(CollectionPermissions {
203					nesting: Some(NestingRule::Owner),203					nesting: Some(NestingPermissions {
204						token_owner: true,
205						admin: false,
206						restricted: None,
207
208						permissive: false,
209					}),
204					..Default::default()210					..Default::default()
205				}),211				}),
206				..Default::default()212				..Default::default()
600				&budget,606				&budget,
601			)607			)
602			.map_err(|err| {608			.map_err(|err| {
603				if err == <CommonError<T>>::OnlyOwnerAllowedToNest.into() {609				if err == <CommonError<T>>::UserIsNotAllowedToNest.into() {
604					<Error<T>>::CannotAcceptNonOwnedNft.into()610					<Error<T>>::CannotAcceptNonOwnedNft.into()
605				} else {611				} else {
606					Self::map_unique_err_to_proxy(err)612					Self::map_unique_err_to_proxy(err)

1[package]1[package]
2name = "pallet-unq-scheduler"2name = "pallet-unique-scheduler"
3version = "0.1.0"3version = "0.1.0"
4authors = ["Unique Network <support@uniquenetwork.io>"]4authors = ["Unique Network <support@uniquenetwork.io>"]
5edition = "2021"5edition = "2021"

3434
35//! Scheduler pallet benchmarking.35//! Scheduler pallet benchmarking.
36
37#![cfg(feature = "runtime-benchmarks")]
3836
39use super::*;37use super::*;
38use frame_benchmarking::{benchmarks, account};
40use sp_std::{vec, prelude::*};39use frame_support::{
40	ensure,
41	traits::{OnInitialize},
42};
41use frame_system::RawOrigin;43use frame_system::RawOrigin;
42use frame_support::{ensure, traits::OnInitialize};44use sp_runtime::traits::Hash;
43use frame_benchmarking::{benchmarks, impl_benchmark_test_suite};45use sp_std::{prelude::*, vec};
4446
45use crate::Module as Scheduler;47use crate::Pallet as Scheduler;
46use frame_system::Pallet as System;48use frame_system::Pallet as System;
49use frame_support::traits::Currency;
4750
48const BLOCK_NUMBER: u32 = 2;51const BLOCK_NUMBER: u32 = 2;
4952
50// Add `n` named items to the schedule53/// Add `n` named items to the schedule.
54///
55/// For `resolved`:
56/// - `None`: aborted (hash without preimage)
57/// - `Some(true)`: hash resolves into call if possible, plain call otherwise
58/// - `Some(false)`: plain call
51fn fill_schedule<T: Config>(when: T::BlockNumber, n: u32) -> Result<(), &'static str> {59fn fill_schedule<T: Config>(
52	// Essentially a no-op call.60	when: T::BlockNumber,
61	n: u32,
62	periodic: bool,
63	resolved: Option<bool>,
64) -> Result<(), &'static str> {
65	let t = DispatchTime::At(when);
66	let caller = account("user", 0, 1);
67
68	// Give the sender account max funds for transfer (their account will never reasonably be killed).
53	let call = frame_system::Call::set_storage { items: vec![] };69	T::Currency::make_free_balance_be(&caller, T::Currency::minimum_balance());
70
54	for i in 0..n {71	for i in 0..n {
55		// Named schedule is strictly heavier than anonymous72		let (call, hash) = call_and_hash::<T>(i);
56		Scheduler::<T>::do_schedule_named(73		let call_or_hash = match resolved {
57			i.encode(),74			Some(_) => call.into(),
58			DispatchTime::At(when),75			None => CallOrHashOf::<T>::Hash(hash),
59			// Add periodicity76		};
77		let period = match periodic {
78			true => Some(((i + 100).into(), 100)),
79			false => None,
80		};
81
82		let slice_id: [u8; 4] = i.encode().try_into().unwrap();
83		let mut id: [u8; 16] = [0; 16];
60			Some((T::BlockNumber::one(), 100)),84		id[..4].clone_from_slice(&slice_id);
61			// HARD_DEADLINE priority means it gets executed no matter what85
62			0,
63			frame_system::RawOrigin::Root.into(),86		let origin = frame_system::RawOrigin::Signed(caller.clone()).into();
64			call.clone().into(),87		Scheduler::<T>::do_schedule_named(id, t, period, 0, origin, call_or_hash)?;
65		)?;
66	}88	}
67	ensure!(89	ensure!(
68		Agenda::<T>::get(when).len() == n as usize,90		Agenda::<T>::get(when).len() == n as usize,
71	Ok(())93	Ok(())
72}94}
95
96fn call_and_hash<T: Config>(i: u32) -> (<T as Config>::Call, T::Hash) {
97	// Essentially a no-op call.
98	let call: <T as Config>::Call = frame_system::Call::remark { remark: i.encode() }.into();
99	let hash = T::Hashing::hash_of(&call);
100	(call, hash)
101}
73102
74benchmarks! {103benchmarks! {
75	schedule {104	on_initialize_periodic_named_resolved {
76		let s in 0 .. T::MaxScheduledPerBlock::get();105		let s in 1 .. T::MaxScheduledPerBlock::get();
77		let when = BLOCK_NUMBER.into();106		let when = BLOCK_NUMBER.into();
78		let periodic = Some((T::BlockNumber::one(), 100));107		fill_schedule::<T>(when, s, true, Some(true))?;
108	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
109	verify {
110		assert_eq!(System::<T>::event_count(), s);
111		for i in 0..s {
112			assert_eq!(Agenda::<T>::get(when + (i + 100).into()).len(), 1 as usize);
113		}
114	}
115
116	on_initialize_named_resolved {
79		let priority = 0;117		let s in 1 .. T::MaxScheduledPerBlock::get();
80		// Essentially a no-op call.
81		let call = Box::new(frame_system::Call::set_storage { items: vec![] }.into());118		let when = BLOCK_NUMBER.into();
82119		fill_schedule::<T>(when, s, false, Some(true))?;
120	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
121	verify {
122		assert_eq!(System::<T>::event_count(), s);
123		assert!(Agenda::<T>::iter().count() == 0);
124	}
125
126	on_initialize_periodic {
127		let s in 1 .. T::MaxScheduledPerBlock::get();
128		let when = BLOCK_NUMBER.into();
83		fill_schedule::<T>(when, s)?;129		fill_schedule::<T>(when, s, true, Some(false))?;
84	}: _(RawOrigin::Root, when, periodic, priority, call)130	}: { Scheduler::<T>::on_initialize(when); }
85	verify {131	verify {
86		ensure!(132		assert_eq!(System::<T>::event_count(), s);
133		for i in 0..s {
87			Agenda::<T>::get(when).len() == (s + 1) as usize,134			assert_eq!(Agenda::<T>::get(when + (i + 100).into()).len(), 1 as usize);
88			"didn't add to schedule"135		}
89		);
90	}136	}
91137
92	cancel {138	on_initialize_periodic_resolved {
93		let s in 1 .. T::MaxScheduledPerBlock::get();139		let s in 1 .. T::MaxScheduledPerBlock::get();
94		let when = BLOCK_NUMBER.into();140		let when = BLOCK_NUMBER.into();
95
96		fill_schedule::<T>(when, s)?;141		fill_schedule::<T>(when, s, true, Some(true))?;
142	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
143	verify {
97		assert_eq!(Agenda::<T>::get(when).len(), s as usize);144		assert_eq!(System::<T>::event_count(), s );
145		for i in 0..s {
146			assert_eq!(Agenda::<T>::get(when + (i + 100).into()).len(), 1 as usize);
147		}
148	}
149
150	on_initialize_aborted {
151		let s in 1 .. T::MaxScheduledPerBlock::get();
152		let when = BLOCK_NUMBER.into();
153		fill_schedule::<T>(when, s, false, None)?;
98	}: _(RawOrigin::Root, when, 0)154	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
155	verify {
156		assert_eq!(System::<T>::event_count(), 0);
157	}
158
159	on_initialize_named_aborted {
160		let s in 1 .. T::MaxScheduledPerBlock::get();
161		let when = BLOCK_NUMBER.into();
162		fill_schedule::<T>(when, s, false, Some(false))?;
163	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
99	verify {164	verify {
165	}
166
167	on_initialize_named {
168		let s in 1 .. T::MaxScheduledPerBlock::get();
169		let when = BLOCK_NUMBER.into();
170		fill_schedule::<T>(when, s, false, None)?;
171	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
172	verify {
100		ensure!(173		assert_eq!(System::<T>::event_count(), 0);
174	}
175
176	on_initialize {
101			Lookup::<T>::get(0.encode()).is_none(),177		let s in 1 .. T::MaxScheduledPerBlock::get();
102			"didn't remove from lookup"178		let when = BLOCK_NUMBER.into();
179		fill_schedule::<T>(when, s, false, Some(false))?;
180	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
181	verify {
103		);182		assert_eq!(System::<T>::event_count(), s);
104		// Removed schedule is NONE
105		ensure!(183		assert!(Agenda::<T>::iter().count() == 0);
184	}
185
186	on_initialize_resolved {
106			Agenda::<T>::get(when)[0].is_none(),187		let s in 1 .. T::MaxScheduledPerBlock::get();
107			"didn't remove from schedule"188		let when = BLOCK_NUMBER.into();
189		fill_schedule::<T>(when, s, false, Some(true))?;
190	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }
191	verify {
108		);192		assert_eq!(System::<T>::event_count(), s);
109	}193		assert!(Agenda::<T>::iter().count() == 0);
194	}
110195
111	schedule_named {196	schedule_named {
197		let caller: T::AccountId = account("user", 0, 1);
198		let origin: RawOrigin<T::AccountId> = frame_system::RawOrigin::Signed(caller.clone());
112		let s in 0 .. T::MaxScheduledPerBlock::get();199		let s in 0 .. T::MaxScheduledPerBlock::get();
113		let id = s.encode();200		let slice_id: [u8; 4] = s.encode().try_into().unwrap();
201		let mut id: [u8; 16] =  [0; 16];
202		id[..4].clone_from_slice(&slice_id);
114		let when = BLOCK_NUMBER.into();203		let when = BLOCK_NUMBER.into();
115		let periodic = Some((T::BlockNumber::one(), 100));204		let periodic = Some((T::BlockNumber::one(), 100));
116		let priority = 0;205		let priority = 0;
117		// Essentially a no-op call.206		// Essentially a no-op call.
118		let call = Box::new(frame_system::Call::set_storage { items: vec![] }.into());207		let inner_call = frame_system::Call::set_storage { items: vec![] }.into();
119208		let call = Box::new(CallOrHashOf::<T>::Value(inner_call));
120		fill_schedule::<T>(when, s)?;209		fill_schedule::<T>(when, s, true, Some(false))?;
121	}: _(RawOrigin::Root, id, when, periodic, priority, call)210	}: _(origin, id, when, periodic, priority, call)
122	verify {211	verify {
123		ensure!(212		ensure!(
124			Agenda::<T>::get(when).len() == (s + 1) as usize,213			Agenda::<T>::get(when).len() == (s + 1) as usize,
127	}216	}
128217
129	cancel_named {218	cancel_named {
219		let caller: T::AccountId = account("user", 0, 1);
220		let origin: RawOrigin<T::AccountId> = frame_system::RawOrigin::Signed(caller.clone());
130		let s in 1 .. T::MaxScheduledPerBlock::get();221		let s in 1 .. T::MaxScheduledPerBlock::get();
131		let when = BLOCK_NUMBER.into();222		let when = BLOCK_NUMBER.into();
132223		let id = 0.encode().try_into().unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);
133		fill_schedule::<T>(when, s)?;224		fill_schedule::<T>(when, s, true, Some(false))?;
134	}: _(RawOrigin::Root, 0.encode())225	}: _(origin, id)
135	verify {226	verify {
136		ensure!(227		ensure!(
137			Lookup::<T>::get(0.encode()).is_none(),228			Lookup::<T>::get(id).is_none(),
138			"didn't remove from lookup"229			"didn't remove from lookup"
139		);230		);
140		// Removed schedule is NONE231		// Removed schedule is NONE
144		);235		);
145	}236	}
146237
147	// TODO [#7141]: Make this more complex and flexible so it can be used in automation.
148	#[extra]
149	on_initialize {
150		let s in 0 .. T::MaxScheduledPerBlock::get();
151		let when = BLOCK_NUMBER.into();
152		fill_schedule::<T>(when, s)?;
153	}: { Scheduler::<T>::on_initialize(BLOCK_NUMBER.into()); }238	impl_benchmark_test_suite!(Scheduler, crate::mock::new_test_ext(), crate::mock::Test);
154	verify {
155		assert_eq!(System::<T>::event_count(), s);
156		// Next block should have all the schedules again
157		ensure!(
158			Agenda::<T>::get(when + T::BlockNumber::one()).len() == s as usize,
159			"didn't append schedule"
160		);
161	}
162}239}
163
164impl_benchmark_test_suite!(Scheduler, crate::tests::new_test_ext(), crate::tests::Test,);
165240

60// Ensure we're `no_std` when compiling for Wasm.60// Ensure we're `no_std` when compiling for Wasm.
61#![cfg_attr(not(feature = "std"), no_std)]61#![cfg_attr(not(feature = "std"), no_std)]
6262
63// FIXME
64// #[cfg(feature = "runtime-benchmarks")]63#[cfg(feature = "runtime-benchmarks")]
65// mod benchmarking;64mod benchmarking;
6665
67pub mod weights;66pub mod weights;
6867
159				Self::on_initialize_periodic(2) - Self::on_initialize_periodic(1)158				Self::on_initialize_periodic(2) - Self::on_initialize_periodic(1)
160			}159			}
161			(true, true, Some(false)) => {160			(true, true, Some(false)) => {
162				Self::on_initialize_periodic_named(2) - Self::on_initialize_periodic_named(1)161				Self::on_initialize_periodic_named_resolved(2)
162					- Self::on_initialize_periodic_named_resolved(1)
163			}163			}
164			(false, false, Some(true)) => {164			(false, false, Some(true)) => Self::on_initialize(2) - Self::on_initialize(1),
165				Self::on_initialize_resolved(2) - Self::on_initialize_resolved(1)
166			}
167			(false, true, Some(true)) => {165			(false, true, Some(true)) => {
168				Self::on_initialize_named_resolved(2) - Self::on_initialize_named_resolved(1)166				Self::on_initialize_named_resolved(2) - Self::on_initialize_named_resolved(1)
169			}167			}
610		Ok(when)608		Ok(when)
611	}609	}
612610
613	fn do_schedule(
614		when: DispatchTime<T::BlockNumber>,
615		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
616		priority: schedule::Priority,
617		origin: T::PalletsOrigin,
618		call: CallOrHashOf<T>,
619	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {
620		let when = Self::resolve_time(when)?;
621		call.ensure_requested::<T::PreimageProvider>();
622
623		// sanitize maybe_periodic
624		let maybe_periodic = maybe_periodic
625			.filter(|p| p.1 > 1 && !p.0.is_zero())
626			// Remove one from the number of repetitions since we will schedule one now.
627			.map(|(p, c)| (p, c - 1));
628		let s = Some(Scheduled {
629			maybe_id: None,
630			priority,
631			call,
632			maybe_periodic,
633			origin,
634			_phantom: PhantomData::<T::AccountId>::default(),
635		});
636		Agenda::<T>::append(when, s);
637		let index = Agenda::<T>::decode_len(when).unwrap_or(1) as u32 - 1;
638		Self::deposit_event(Event::Scheduled { when, index });
639
640		Ok((when, index))
641	}
642
643	fn do_cancel(
644		origin: Option<T::PalletsOrigin>,
645		(when, index): TaskAddress<T::BlockNumber>,
646	) -> Result<(), DispatchError> {
647		let scheduled = Agenda::<T>::try_mutate(when, |agenda| {
648			agenda.get_mut(index as usize).map_or(
649				Ok(None),
650				|s| -> Result<Option<Scheduled<_, _, _, _>>, DispatchError> {
651					if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {
652						if matches!(
653							T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),
654							Some(Ordering::Less) | None
655						) {
656							return Err(BadOrigin.into());
657						}
658					};
659					Ok(s.take())
660				},
661			)
662		})?;
663		if let Some(s) = scheduled {
664			s.call.ensure_unrequested::<T::PreimageProvider>();
665			if let Some(id) = s.maybe_id {
666				Lookup::<T>::remove(id);
667			}
668			Self::deposit_event(Event::Canceled { when, index });
669			Ok(())
670		} else {
671			Err(Error::<T>::NotFound)?
672		}
673	}
674
675	fn do_reschedule(
676		(when, index): TaskAddress<T::BlockNumber>,
677		new_time: DispatchTime<T::BlockNumber>,
678	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {
679		let new_time = Self::resolve_time(new_time)?;
680
681		if new_time == when {
682			return Err(Error::<T>::RescheduleNoChange.into());
683		}
684
685		Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {
686			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;
687			let task = task.take().ok_or(Error::<T>::NotFound)?;
688			Agenda::<T>::append(new_time, Some(task));
689			Ok(())
690		})?;
691
692		let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;
693		Self::deposit_event(Event::Canceled { when, index });
694		Self::deposit_event(Event::Scheduled {
695			when: new_time,
696			index: new_index,
697		});
698
699		Ok((new_time, new_index))
700	}
701
702	fn do_schedule_named(611	fn do_schedule_named(
703		id: ScheduledId,612		id: ScheduledId,
789				Err(Error::<T>::NotFound)?698				Err(Error::<T>::NotFound)?
790			}699			}
791		})700		})
792	}
793
794	fn do_reschedule_named(
795		id: ScheduledId,
796		new_time: DispatchTime<T::BlockNumber>,
797	) -> Result<TaskAddress<T::BlockNumber>, DispatchError> {
798		let new_time = Self::resolve_time(new_time)?;
799
800		Lookup::<T>::try_mutate_exists(
801			id,
802			|lookup| -> Result<TaskAddress<T::BlockNumber>, DispatchError> {
803				let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;
804
805				if new_time == when {
806					return Err(Error::<T>::RescheduleNoChange.into());
807				}
808
809				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {
810					let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;
811					let task = task.take().ok_or(Error::<T>::NotFound)?;
812					Agenda::<T>::append(new_time, Some(task));
813
814					Ok(())
815				})?;
816
817				let new_index = Agenda::<T>::decode_len(new_time).unwrap_or(1) as u32 - 1;
818				Self::deposit_event(Event::Canceled { when, index });
819				Self::deposit_event(Event::Scheduled {
820					when: new_time,
821					index: new_index,
822				});
823
824				*lookup = Some((new_time, new_index));
825
826				Ok((new_time, new_index))
827			},
828		)
829	}
830}
831
832impl<T: Config> schedule::v2::Anon<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin>
833	for Pallet<T>
834{
835	type Address = TaskAddress<T::BlockNumber>;
836	type Hash = T::Hash;
837
838	fn schedule(
839		when: DispatchTime<T::BlockNumber>,
840		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
841		priority: schedule::Priority,
842		origin: T::PalletsOrigin,
843		call: CallOrHashOf<T>,
844	) -> Result<Self::Address, DispatchError> {
845		Self::do_schedule(when, maybe_periodic, priority, origin, call)
846	}
847
848	fn cancel((when, index): Self::Address) -> Result<(), ()> {
849		Self::do_cancel(None, (when, index)).map_err(|_| ())
850	}
851
852	fn reschedule(
853		address: Self::Address,
854		when: DispatchTime<T::BlockNumber>,
855	) -> Result<Self::Address, DispatchError> {
856		Self::do_reschedule(address, when)
857	}
858
859	fn next_dispatch_time((when, index): Self::Address) -> Result<T::BlockNumber, ()> {
860		Agenda::<T>::get(when)
861			.get(index as usize)
862			.ok_or(())
863			.map(|_| when)
864	}
865}
866
867impl<T: Config> schedule::v2::Named<T::BlockNumber, <T as Config>::Call, T::PalletsOrigin>
868	for Pallet<T>
869{
870	type Address = TaskAddress<T::BlockNumber>;
871	type Hash = T::Hash;
872
873	fn schedule_named(
874		id: Vec<u8>,
875		when: DispatchTime<T::BlockNumber>,
876		maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
877		priority: schedule::Priority,
878		origin: T::PalletsOrigin,
879		call: CallOrHashOf<T>,
880	) -> Result<Self::Address, ()> {
881		let inner_id: ScheduledId = id
882			.try_into()
883			.unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);
884		Self::do_schedule_named(inner_id, when, maybe_periodic, priority, origin, call)
885			.map_err(|_| ())
886	}
887
888	fn cancel_named(id: Vec<u8>) -> Result<(), ()> {
889		let inner_id: ScheduledId = id
890			.try_into()
891			.unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);
892		Self::do_cancel_named(None, inner_id).map_err(|_| ())
893	}
894
895	fn reschedule_named(
896		id: Vec<u8>,
897		when: DispatchTime<T::BlockNumber>,
898	) -> Result<Self::Address, DispatchError> {
899		let inner_id: ScheduledId = id
900			.try_into()
901			.unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);
902		Self::do_reschedule_named(inner_id, when)
903	}
904
905	fn next_dispatch_time(id: Vec<u8>) -> Result<T::BlockNumber, ()> {
906		let inner_id: ScheduledId = id
907			.try_into()
908			.unwrap_or([0; MAX_TASK_ID_LENGTH_IN_BYTES as usize]);
909		Lookup::<T>::get(inner_id)
910			.and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when))
911			.ok_or(())
912	}701	}
913}702}
914703