git.delta.rocks / unique-network / refs/commits / 90587283b7f1

--- a/pallets/scheduler-v2/src/lib.rs
+++ b/pallets/scheduler-v2/src/lib.rs
@@ -77,13 +77,16 @@
 
 use codec::{Codec, Decode, Encode, MaxEncodedLen};
 use frame_support::{
-	dispatch::{DispatchError, DispatchResult, Dispatchable, GetDispatchInfo, Parameter, PostDispatchInfo},
+	dispatch::{
+		DispatchError, DispatchResult, Dispatchable, GetDispatchInfo, Parameter, PostDispatchInfo,
+	},
 	traits::{
 		schedule::{self, DispatchTime, LOWEST_PRIORITY},
 		EnsureOrigin, Get, IsType, OriginTrait, PrivilegeCmp, StorageVersion, PreimageRecipient,
 		ConstU32, UnfilteredDispatchable,
 	},
-	weights::Weight, unsigned::TransactionValidityError,
+	weights::Weight,
+	unsigned::TransactionValidityError,
 };
 
 use frame_system::{self as system};
@@ -318,8 +321,10 @@
 
 		/// The aggregated call type.
 		type RuntimeCall: Parameter
-			+ Dispatchable<RuntimeOrigin = <Self as Config>::RuntimeOrigin, PostInfo = PostDispatchInfo>
-			+ UnfilteredDispatchable<RuntimeOrigin = <Self as system::Config>::RuntimeOrigin>
+			+ Dispatchable<
+				RuntimeOrigin = <Self as Config>::RuntimeOrigin,
+				PostInfo = PostDispatchInfo,
+			> + UnfilteredDispatchable<RuntimeOrigin = <Self as system::Config>::RuntimeOrigin>
 			+ GetDispatchInfo
 			+ From<system::Call<Self>>;
 
@@ -940,7 +945,7 @@
 				}
 
 				return Err((Unavailable, Some(task)));
-			},
+			}
 		};
 
 		weight.check_accrue(T::WeightInfo::service_task(
@@ -979,7 +984,7 @@
 			Err(Overweight) => {
 				// Preserve Lookup -- the task will be postponed.
 				Err((Overweight, Some(task)))
-			},
+			}
 			Ok(result) => {
 				Self::deposit_event(Event::Dispatched {
 					task: (when, agenda_index),
@@ -987,7 +992,9 @@
 					result,
 				});
 
-				let is_canceled = task.maybe_id.as_ref()
+				let is_canceled = task
+					.maybe_id
+					.as_ref()
 					.map(|id| !Lookup::<T>::contains_key(id))
 					.unwrap_or(false);
 
@@ -1011,14 +1018,14 @@
 								});
 							}
 						}
-					},
+					}
 					_ => {
 						if let Some(ref id) = task.maybe_id {
 							Lookup::<T>::remove(id);
 						}
 
 						T::Preimages::drop(&task.call)
-					},
+					}
 				}
 				Ok(())
 			}
@@ -1056,12 +1063,12 @@
 		let r = match ensured_origin {
 			Ok(ScheduledEnsureOriginSuccess::Root) => {
 				Ok(call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into()))
-			},
+			}
 			Ok(ScheduledEnsureOriginSuccess::Signed(sender)) => {
 				// Execute transaction via chain default pipeline
 				// That means dispatch will be processed like any user's extrinsic e.g. transaction fees will be taken
 				T::CallExecutor::dispatch_call(Some(sender), call.clone())
-			},
+			}
 			Ok(ScheduledEnsureOriginSuccess::Unsigned) => {
 				// Unsigned version of the above
 				T::CallExecutor::dispatch_call(None, call.clone())

--- a/pallets/scheduler-v2/src/mock.rs
+++ b/pallets/scheduler-v2/src/mock.rs
@@ -39,9 +39,7 @@
 use crate as scheduler;
 use frame_support::{
 	ord_parameter_types, parameter_types,
-	traits::{
-		ConstU32, ConstU64, Contains, EqualPrivilegeOnly, OnFinalize, OnInitialize,
-	},
+	traits::{ConstU32, ConstU64, Contains, EqualPrivilegeOnly, OnFinalize, OnInitialize},
 	weights::constants::RocksDbWeight,
 };
 use frame_system::{EnsureRoot, RawOrigin};
@@ -136,7 +134,7 @@
 	pub BlockWeights: frame_system::limits::BlockWeights =
 		frame_system::limits::BlockWeights::simple_max(
 			Weight::from_ref_time(2_000_000_000_000)
-            // .set_proof_size(u64::MAX),
+			// .set_proof_size(u64::MAX),
 		);
 }
 impl system::Config for Test {
@@ -210,9 +208,9 @@
 	fn cancel_named(_s: u32) -> Weight {
 		Weight::from_ref_time(50)
 	}
-    fn change_named_priority(_s: u32, ) -> Weight {
-        Weight::from_ref_time(50)
-    }
+	fn change_named_priority(_s: u32) -> Weight {
+		Weight::from_ref_time(50)
+	}
 }
 parameter_types! {
 	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
@@ -220,8 +218,8 @@
 }
 
 pub struct EnsureSignedOneOrRoot;
-impl<O: Into<Result<RawOrigin<u64>, O>> + From<RawOrigin<u64>>>
-	EnsureOrigin<O> for EnsureSignedOneOrRoot
+impl<O: Into<Result<RawOrigin<u64>, O>> + From<RawOrigin<u64>>> EnsureOrigin<O>
+	for EnsureSignedOneOrRoot
 {
 	type Success = ScheduledEnsureOriginSuccess<u64>;
 	fn try_origin(o: O) -> Result<Self::Success, O> {
@@ -235,19 +233,19 @@
 
 pub struct Executor;
 impl DispatchCall<Test, sp_core::H160> for Executor {
-    fn dispatch_call(
-        signer: Option<u64>,
-        function: RuntimeCall,
-    ) -> Result<
-        Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,
-        TransactionValidityError,
-    > {
-        let origin = match signer {
-            Some(who) => RuntimeOrigin::signed(who),
-            None => RuntimeOrigin::none(),
-        };
-        Ok(function.dispatch(origin))
-    }
+	fn dispatch_call(
+		signer: Option<u64>,
+		function: RuntimeCall,
+	) -> Result<
+		Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,
+		TransactionValidityError,
+	> {
+		let origin = match signer {
+			Some(who) => RuntimeOrigin::signed(who),
+			None => RuntimeOrigin::none(),
+		};
+		Ok(function.dispatch(origin))
+	}
 }
 
 impl Config for Test {
@@ -261,14 +259,16 @@
 	type WeightInfo = TestWeightInfo;
 	type OriginPrivilegeCmp = EqualPrivilegeOnly;
 	type Preimages = ();
-    type PrioritySetOrigin = EnsureRoot<u64>;
-    type CallExecutor = Executor;
+	type PrioritySetOrigin = EnsureRoot<u64>;
+	type CallExecutor = Executor;
 }
 
 pub type LoggerCall = logger::Call<Test>;
 
 pub fn new_test_ext() -> sp_io::TestExternalities {
-	let t = system::GenesisConfig::default().build_storage::<Test>().unwrap();
+	let t = system::GenesisConfig::default()
+		.build_storage::<Test>()
+		.unwrap();
 	t.into()
 }
 

48	new_test_ext().execute_with(|| {48	new_test_ext().execute_with(|| {
49		let call =49		let call = RuntimeCall::Logger(LoggerCall::log {
50			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_ref_time(10) });50			i: 42,
51			weight: Weight::from_ref_time(10),
52		});
51		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));53		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(
54			&call
71		run_to_block(2);75		run_to_block(2);
72		let call =76		let call = RuntimeCall::Logger(LoggerCall::log {
73			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_ref_time(10) });77			i: 42,
78			weight: Weight::from_ref_time(10),
79		});
74		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));80		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(
81			&call
95		run_to_block(2);103		run_to_block(2);
96		let call =104		let call = RuntimeCall::Logger(LoggerCall::log {
97			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_ref_time(10) });105			i: 42,
106			weight: Weight::from_ref_time(10),
107		});
98		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));108		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(
109			&call
243	new_test_ext().execute_with(|| {261	new_test_ext().execute_with(|| {
244		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight / 3 * 2 });262		let call = RuntimeCall::Logger(LoggerCall::log {
263			i: 42,
264			weight: max_weight / 3 * 2,
265		});
245		assert_ok!(Scheduler::do_schedule(266		assert_ok!(Scheduler::do_schedule(
246			DispatchTime::At(4),267			DispatchTime::At(4),
251		));272		));
252		let call = RuntimeCall::Logger(LoggerCall::log { i: 69, weight: max_weight / 3 * 2 });273		let call = RuntimeCall::Logger(LoggerCall::log {
274			i: 69,
275			weight: max_weight / 3 * 2,
276		});
253		assert_ok!(Scheduler::do_schedule(277		assert_ok!(Scheduler::do_schedule(
254			DispatchTime::At(4),278			DispatchTime::At(4),
272	new_test_ext().execute_with(|| {296	new_test_ext().execute_with(|| {
273		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight });297		let call = RuntimeCall::Logger(LoggerCall::log {
298			i: 42,
299			weight: max_weight,
300		});
274		assert_ok!(Scheduler::do_schedule(301		assert_ok!(Scheduler::do_schedule(
275			DispatchTime::At(4),302			DispatchTime::At(4),
300	new_test_ext().execute_with(|| {331	new_test_ext().execute_with(|| {
301		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: (max_weight / 3) * 2 });332		let call = RuntimeCall::Logger(LoggerCall::log {
333			i: 42,
334			weight: (max_weight / 3) * 2,
335		});
302		let call = <ScheduledCall<Test>>::new(call).unwrap();336		let call = <ScheduledCall<Test>>::new(call).unwrap();
303337
340	new_test_ext().execute_with(|| {378	new_test_ext().execute_with(|| {
341		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight / 3 });379		let call = RuntimeCall::Logger(LoggerCall::log {
380			i: 42,
381			weight: max_weight / 3,
382		});
342		assert_ok!(Scheduler::do_schedule(383		assert_ok!(Scheduler::do_schedule(
343			DispatchTime::At(4),384			DispatchTime::At(4),
348		));389		));
349		let call = RuntimeCall::Logger(LoggerCall::log { i: 69, weight: max_weight / 3 });390		let call = RuntimeCall::Logger(LoggerCall::log {
391			i: 69,
392			weight: max_weight / 3,
393		});
350		assert_ok!(Scheduler::do_schedule(394		assert_ok!(Scheduler::do_schedule(
351			DispatchTime::At(4),395			DispatchTime::At(4),
365		let max_weight: Weight = <Test as Config>::MaximumWeight::get();409		let max_weight: Weight = <Test as Config>::MaximumWeight::get();
366		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight / 5 * 2 });410		let call = RuntimeCall::Logger(LoggerCall::log {
411			i: 42,
412			weight: max_weight / 5 * 2,
413		});
367		assert_ok!(Scheduler::do_schedule(414		assert_ok!(Scheduler::do_schedule(
368			DispatchTime::At(4),415			DispatchTime::At(4),
373		));420		));
374		let call = RuntimeCall::Logger(LoggerCall::log { i: 69, weight: max_weight / 5 * 2 });421		let call = RuntimeCall::Logger(LoggerCall::log {
422			i: 69,
423			weight: max_weight / 5 * 2,
424		});
375		assert_ok!(Scheduler::do_schedule(425		assert_ok!(Scheduler::do_schedule(
376			DispatchTime::At(4),426			DispatchTime::At(4),
381		));431		));
382		let call = RuntimeCall::Logger(LoggerCall::log { i: 2600, weight: max_weight / 5 * 4 });432		let call = RuntimeCall::Logger(LoggerCall::log {
433			i: 2600,
434			weight: max_weight / 5 * 4,
435		});
383		assert_ok!(Scheduler::do_schedule(436		assert_ok!(Scheduler::do_schedule(
384			DispatchTime::At(4),437			DispatchTime::At(4),
676	new_test_ext().execute_with(|| {775	new_test_ext().execute_with(|| {
677		let call =776		let call = RuntimeCall::Logger(LoggerCall::log {
678			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_ref_time(10) });777			i: 42,
778			weight: Weight::from_ref_time(10),
779		});
679780
680		// Schedule both calls.781		// Schedule both calls.
709	new_test_ext().execute_with(|| {810	new_test_ext().execute_with(|| {
710		let call =811		let call = RuntimeCall::Logger(LoggerCall::log {
711			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_ref_time(10) });812			i: 42,
813			weight: Weight::from_ref_time(10),
814		});
712		let call = <ScheduledCall<Test>>::new(call).unwrap();815		let call = <ScheduledCall<Test>>::new(call).unwrap();
713816
744	new_test_ext().execute_with(|| {843	new_test_ext().execute_with(|| {
745		let call =844		let call = RuntimeCall::Logger(LoggerCall::log {
746			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_ref_time(10) });845			i: 42,
846			weight: Weight::from_ref_time(10),
847		});
747		let call = <ScheduledCall<Test>>::new(call).unwrap();848		let call = <ScheduledCall<Test>>::new(call).unwrap();
748		let mut addrs = Vec::<_>::default();849		let mut addrs = Vec::<_>::default();

--- a/runtime/common/scheduler.rs
+++ b/runtime/common/scheduler.rs
@@ -105,7 +105,6 @@
 	}
 }
 
-
 // impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>
 // 	DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor
 // where