1#![cfg_attr(not(feature = "std"), no_std)]
99
100extern crate alloc;
101
102use alloc::{borrow::Cow, boxed::Box, vec, vec::Vec};
103use core::{fmt::Debug, marker::PhantomData};
104use pallet_prelude::{BlockNumberFor, HeaderFor};
105#[cfg(feature = "std")]
106use serde::Serialize;
107use sp_io::hashing::blake2_256;
108#[cfg(feature = "runtime-benchmarks")]
109use sp_runtime::traits::TrailingZeroInput;
110use sp_runtime::{
111 generic,
112 traits::{
113 self, AsTransactionAuthorizedOrigin, AtLeast32Bit, BadOrigin, BlockNumberProvider, Bounded,
114 CheckEqual, Dispatchable, Hash, Header, Lookup, LookupError, MaybeDisplay,
115 MaybeSerializeDeserialize, Member, One, Saturating, SimpleBitOps, StaticLookup, Zero,
116 },
117 transaction_validity::{
118 InvalidTransaction, TransactionLongevity, TransactionSource, TransactionValidity,
119 ValidTransaction,
120 },
121 DispatchError, RuntimeDebug,
122};
123use sp_version::RuntimeVersion;
124
125use codec::{Decode, DecodeWithMemTracking, Encode, EncodeLike, FullCodec, MaxEncodedLen};
126#[cfg(feature = "std")]
127use frame_support::traits::BuildGenesisConfig;
128use frame_support::{
129 dispatch::{
130 extract_actual_pays_fee, extract_actual_weight, DispatchClass, DispatchInfo,
131 DispatchResult, DispatchResultWithPostInfo, GetDispatchInfo, PerDispatchClass,
132 PostDispatchInfo,
133 },
134 ensure, impl_ensure_origin_with_arg_ignoring_arg,
135 migrations::MultiStepMigrator,
136 pallet_prelude::Pays,
137 storage::{self, StorageStreamIter},
138 traits::{
139 ConstU32, Contains, EnsureOrigin, EnsureOriginWithArg, Get, HandleLifetime,
140 OnKilledAccount, OnNewAccount, OnRuntimeUpgrade, OriginTrait, PalletInfo, SortedMembers,
141 StoredMap, TypedGet,
142 },
143 Parameter,
144};
145use scale_info::TypeInfo;
146use sp_core::storage::well_known_keys;
147use sp_runtime::{
148 traits::{DispatchInfoOf, PostDispatchInfoOf},
149 transaction_validity::TransactionValidityError,
150};
151use sp_weights::{RuntimeDbWeight, Weight};
152
153#[cfg(any(feature = "std", test))]
154use sp_io::TestExternalities;
155
156pub mod limits;
157#[cfg(test)]
158pub(crate) mod mock;
159
160pub mod offchain;
161
162mod extensions;
163#[cfg(feature = "std")]
164pub mod mocking;
165#[cfg(test)]
166mod tests;
167pub mod weights;
168
169pub mod migrations;
170
171pub use extensions::{
172 authorize_call::AuthorizeCall,
173 check_genesis::CheckGenesis,
174 check_mortality::CheckMortality,
175 check_non_zero_sender::CheckNonZeroSender,
176 check_nonce::{CheckNonce, ValidNonceInfo},
177 check_spec_version::CheckSpecVersion,
178 check_tx_version::CheckTxVersion,
179 check_weight::CheckWeight,
180 weight_reclaim::WeightReclaim,
181 weights::SubstrateWeight as SubstrateExtensionsWeight,
182 WeightInfo as ExtensionsWeightInfo,
183};
184pub use extensions::check_mortality::CheckMortality as CheckEra;
186pub use frame_support::dispatch::RawOrigin;
187use frame_support::traits::{Authorize, PostInherents, PostTransactions, PreInherents};
188use sp_core::storage::StateVersion;
189pub use weights::WeightInfo;
190
191const LOG_TARGET: &str = "runtime::system";
192
193pub fn extrinsics_root<H: Hash, E: codec::Encode>(
198 extrinsics: &[E],
199 state_version: StateVersion,
200) -> H::Output {
201 extrinsics_data_root::<H>(extrinsics.iter().map(codec::Encode::encode).collect(), state_version)
202}
203
204pub fn extrinsics_data_root<H: Hash>(xts: Vec<Vec<u8>>, state_version: StateVersion) -> H::Output {
209 H::ordered_trie_root(xts, state_version)
210}
211
212pub type ConsumedWeight = PerDispatchClass<Weight>;
214
215pub use pallet::*;
216
217pub trait SetCode<T: Config> {
219 fn set_code(code: Vec<u8>) -> DispatchResult;
221}
222
223impl<T: Config> SetCode<T> for () {
224 fn set_code(code: Vec<u8>) -> DispatchResult {
225 <Pallet<T>>::update_code_in_storage(&code);
226 Ok(())
227 }
228}
229
230pub trait ConsumerLimits {
232 fn max_consumers() -> RefCount;
234 fn max_overflow() -> RefCount;
240}
241
242impl<const Z: u32> ConsumerLimits for ConstU32<Z> {
243 fn max_consumers() -> RefCount {
244 Z
245 }
246 fn max_overflow() -> RefCount {
247 Z
248 }
249}
250
251impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal, MaxOverflow) {
252 fn max_consumers() -> RefCount {
253 MaxNormal::get()
254 }
255 fn max_overflow() -> RefCount {
256 MaxOverflow::get()
257 }
258}
259
260#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
263#[scale_info(skip_type_params(T))]
264pub struct CodeUpgradeAuthorization<T>
265where
266 T: Config,
267{
268 code_hash: T::Hash,
270 check_version: bool,
272}
273
274#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
275impl<T> CodeUpgradeAuthorization<T>
276where
277 T: Config,
278{
279 pub fn code_hash(&self) -> &T::Hash {
280 &self.code_hash
281 }
282}
283
284#[derive(
288 Clone,
289 Copy,
290 Eq,
291 PartialEq,
292 Default,
293 RuntimeDebug,
294 Encode,
295 Decode,
296 DecodeWithMemTracking,
297 TypeInfo,
298)]
299pub struct DispatchEventInfo {
300 pub weight: Weight,
302 pub class: DispatchClass,
304 pub pays_fee: Pays,
306}
307
308#[frame_support::pallet]
309pub mod pallet {
310 use crate::{self as frame_system, pallet_prelude::*, *};
311 use codec::HasCompact;
312 use frame_support::pallet_prelude::*;
313
314 pub mod config_preludes {
316 use super::{inject_runtime_type, DefaultConfig};
317 use frame_support::{derive_impl, traits::Get};
318
319 pub struct TestBlockHashCount<C: Get<u32>>(core::marker::PhantomData<C>);
325 impl<I: From<u32>, C: Get<u32>> Get<I> for TestBlockHashCount<C> {
326 fn get() -> I {
327 C::get().into()
328 }
329 }
330
331 pub struct TestDefaultConfig;
338
339 #[frame_support::register_default_impl(TestDefaultConfig)]
340 impl DefaultConfig for TestDefaultConfig {
341 type Nonce = u32;
342 type Hash = sp_core::hash::H256;
343 type Hashing = sp_runtime::traits::BlakeTwo256;
344 type AccountId = u64;
345 type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
346 type MaxConsumers = frame_support::traits::ConstU32<16>;
347 type AccountData = ();
348 type OnNewAccount = ();
349 type OnKilledAccount = ();
350 type SystemWeightInfo = ();
351 type ExtensionsWeightInfo = ();
352 type SS58Prefix = ();
353 type Version = ();
354 type BlockWeights = ();
355 type BlockLength = ();
356 type DbWeight = ();
357 #[inject_runtime_type]
358 type RuntimeEvent = ();
359 #[inject_runtime_type]
360 type RuntimeOrigin = ();
361 #[inject_runtime_type]
362 type RuntimeCall = ();
363 #[inject_runtime_type]
364 type PalletInfo = ();
365 #[inject_runtime_type]
366 type RuntimeTask = ();
367 type BaseCallFilter = frame_support::traits::Everything;
368 type BlockHashCount = TestBlockHashCount<frame_support::traits::ConstU32<10>>;
369 type OnSetCode = ();
370 type SingleBlockMigrations = ();
371 type MultiBlockMigrator = ();
372 type PreInherents = ();
373 type PostInherents = ();
374 type PostTransactions = ();
375 }
376
377 pub struct SolochainDefaultConfig;
391
392 #[frame_support::register_default_impl(SolochainDefaultConfig)]
393 impl DefaultConfig for SolochainDefaultConfig {
394 type Nonce = u32;
396
397 type Hash = sp_core::hash::H256;
399
400 type Hashing = sp_runtime::traits::BlakeTwo256;
402
403 type AccountId = sp_runtime::AccountId32;
405
406 type Lookup = sp_runtime::traits::AccountIdLookup<Self::AccountId, ()>;
408
409 type MaxConsumers = frame_support::traits::ConstU32<128>;
411
412 type AccountData = ();
414
415 type OnNewAccount = ();
417
418 type OnKilledAccount = ();
420
421 type SystemWeightInfo = ();
423
424 type ExtensionsWeightInfo = ();
426
427 type SS58Prefix = ();
429
430 type Version = ();
432
433 type BlockWeights = ();
435
436 type BlockLength = ();
438
439 type DbWeight = ();
441
442 #[inject_runtime_type]
444 type RuntimeEvent = ();
445
446 #[inject_runtime_type]
448 type RuntimeOrigin = ();
449
450 #[inject_runtime_type]
453 type RuntimeCall = ();
454
455 #[inject_runtime_type]
457 type RuntimeTask = ();
458
459 #[inject_runtime_type]
461 type PalletInfo = ();
462
463 type BaseCallFilter = frame_support::traits::Everything;
465
466 type BlockHashCount = TestBlockHashCount<frame_support::traits::ConstU32<256>>;
469
470 type OnSetCode = ();
472 type SingleBlockMigrations = ();
473 type MultiBlockMigrator = ();
474 type PreInherents = ();
475 type PostInherents = ();
476 type PostTransactions = ();
477 }
478
479 pub struct RelayChainDefaultConfig;
481
482 #[derive_impl(SolochainDefaultConfig as DefaultConfig, no_aggregated_types)]
484 #[frame_support::register_default_impl(RelayChainDefaultConfig)]
485 impl DefaultConfig for RelayChainDefaultConfig {}
486
487 pub struct ParaChainDefaultConfig;
489
490 #[derive_impl(SolochainDefaultConfig as DefaultConfig, no_aggregated_types)]
492 #[frame_support::register_default_impl(ParaChainDefaultConfig)]
493 impl DefaultConfig for ParaChainDefaultConfig {}
494 }
495
496 #[pallet::config(with_default, frame_system_config)]
498 #[pallet::disable_frame_system_supertrait_check]
499 pub trait Config: 'static + Eq + Clone {
500 #[pallet::no_default_bounds]
502 type RuntimeEvent: Parameter
503 + Member
504 + From<Event<Self>>
505 + Debug
506 + IsType<<Self as frame_system::Config>::RuntimeEvent>;
507
508 #[pallet::no_default_bounds]
519 type BaseCallFilter: Contains<Self::RuntimeCall>;
520
521 #[pallet::constant]
523 type BlockWeights: Get<limits::BlockWeights>;
524
525 #[pallet::constant]
527 type BlockLength: Get<limits::BlockLength>;
528
529 #[pallet::no_default_bounds]
531 type RuntimeOrigin: Into<Result<RawOrigin<Self::AccountId>, Self::RuntimeOrigin>>
532 + From<RawOrigin<Self::AccountId>>
533 + Clone
534 + OriginTrait<Call = Self::RuntimeCall, AccountId = Self::AccountId>
535 + AsTransactionAuthorizedOrigin;
536
537 #[docify::export(system_runtime_call)]
538 #[pallet::no_default_bounds]
540 type RuntimeCall: Parameter
541 + Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
542 + Debug
543 + GetDispatchInfo
544 + From<Call<Self>>
545 + Authorize;
546
547 #[pallet::no_default_bounds]
549 type RuntimeTask: Task;
550
551 type Nonce: Parameter
553 + HasCompact<Type: DecodeWithMemTracking>
554 + Member
555 + MaybeSerializeDeserialize
556 + Debug
557 + Default
558 + MaybeDisplay
559 + AtLeast32Bit
560 + Copy
561 + MaxEncodedLen;
562
563 type Hash: Parameter
565 + Member
566 + MaybeSerializeDeserialize
567 + Debug
568 + MaybeDisplay
569 + SimpleBitOps
570 + Ord
571 + Default
572 + Copy
573 + CheckEqual
574 + core::hash::Hash
575 + AsRef<[u8]>
576 + AsMut<[u8]>
577 + MaxEncodedLen;
578
579 type Hashing: Hash<Output = Self::Hash> + TypeInfo;
581
582 type AccountId: Parameter
584 + Member
585 + MaybeSerializeDeserialize
586 + Debug
587 + MaybeDisplay
588 + Ord
589 + MaxEncodedLen;
590
591 type Lookup: StaticLookup<Target = Self::AccountId>;
598
599 #[pallet::no_default]
602 type Block: Parameter + Member + traits::Block<Hash = Self::Hash>;
603
604 #[pallet::constant]
606 #[pallet::no_default_bounds]
607 type BlockHashCount: Get<BlockNumberFor<Self>>;
608
609 #[pallet::constant]
611 type DbWeight: Get<RuntimeDbWeight>;
612
613 #[pallet::constant]
615 type Version: Get<RuntimeVersion>;
616
617 #[pallet::no_default_bounds]
624 type PalletInfo: PalletInfo;
625
626 type AccountData: Member + FullCodec + Clone + Default + TypeInfo + MaxEncodedLen;
629
630 type OnNewAccount: OnNewAccount<Self::AccountId>;
632
633 type OnKilledAccount: OnKilledAccount<Self::AccountId>;
637
638 type SystemWeightInfo: WeightInfo;
640
641 type ExtensionsWeightInfo: extensions::WeightInfo;
643
644 #[pallet::constant]
650 type SS58Prefix: Get<u16>;
651
652 #[pallet::no_default_bounds]
660 type OnSetCode: SetCode<Self>;
661
662 type MaxConsumers: ConsumerLimits;
664
665 type SingleBlockMigrations: OnRuntimeUpgrade;
672
673 type MultiBlockMigrator: MultiStepMigrator;
678
679 type PreInherents: PreInherents;
683
684 type PostInherents: PostInherents;
688
689 type PostTransactions: PostTransactions;
693 }
694
695 #[pallet::pallet]
696 pub struct Pallet<T>(_);
697
698 #[pallet::hooks]
699 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
700 #[cfg(feature = "std")]
701 fn integrity_test() {
702 T::BlockWeights::get().validate().expect("The weights are invalid.");
703 }
704 }
705
706 #[pallet::call(weight = <T as Config>::SystemWeightInfo)]
707 impl<T: Config> Pallet<T> {
708 #[pallet::call_index(0)]
712 #[pallet::weight(T::SystemWeightInfo::remark(remark.len() as u32))]
713 pub fn remark(_origin: OriginFor<T>, remark: Vec<u8>) -> DispatchResultWithPostInfo {
714 let _ = remark; Ok(().into())
716 }
717
718 #[pallet::call_index(1)]
720 #[pallet::weight((T::SystemWeightInfo::set_heap_pages(), DispatchClass::Operational))]
721 pub fn set_heap_pages(origin: OriginFor<T>, pages: u64) -> DispatchResultWithPostInfo {
722 ensure_root(origin)?;
723 storage::unhashed::put_raw(well_known_keys::HEAP_PAGES, &pages.encode());
724 Self::deposit_log(generic::DigestItem::RuntimeEnvironmentUpdated);
725 Ok(().into())
726 }
727
728 #[pallet::call_index(2)]
730 #[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]
731 pub fn set_code(origin: OriginFor<T>, code: Vec<u8>) -> DispatchResultWithPostInfo {
732 ensure_root(origin)?;
733 Self::can_set_code(&code, true).into_result()?;
734 T::OnSetCode::set_code(code)?;
735 Ok(Some(T::BlockWeights::get().max_block).into())
737 }
738
739 #[pallet::call_index(3)]
744 #[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]
745 pub fn set_code_without_checks(
746 origin: OriginFor<T>,
747 code: Vec<u8>,
748 ) -> DispatchResultWithPostInfo {
749 ensure_root(origin)?;
750 Self::can_set_code(&code, false).into_result()?;
751 T::OnSetCode::set_code(code)?;
752 Ok(Some(T::BlockWeights::get().max_block).into())
753 }
754
755 #[pallet::call_index(4)]
757 #[pallet::weight((
758 T::SystemWeightInfo::set_storage(items.len() as u32),
759 DispatchClass::Operational,
760 ))]
761 pub fn set_storage(
762 origin: OriginFor<T>,
763 items: Vec<KeyValue>,
764 ) -> DispatchResultWithPostInfo {
765 ensure_root(origin)?;
766 for i in &items {
767 storage::unhashed::put_raw(&i.0, &i.1);
768 }
769 Ok(().into())
770 }
771
772 #[pallet::call_index(5)]
774 #[pallet::weight((
775 T::SystemWeightInfo::kill_storage(keys.len() as u32),
776 DispatchClass::Operational,
777 ))]
778 pub fn kill_storage(origin: OriginFor<T>, keys: Vec<Key>) -> DispatchResultWithPostInfo {
779 ensure_root(origin)?;
780 for key in &keys {
781 storage::unhashed::kill(key);
782 }
783 Ok(().into())
784 }
785
786 #[pallet::call_index(6)]
791 #[pallet::weight((
792 T::SystemWeightInfo::kill_prefix(subkeys.saturating_add(1)),
793 DispatchClass::Operational,
794 ))]
795 pub fn kill_prefix(
796 origin: OriginFor<T>,
797 prefix: Key,
798 subkeys: u32,
799 ) -> DispatchResultWithPostInfo {
800 ensure_root(origin)?;
801 let _ = storage::unhashed::clear_prefix(&prefix, Some(subkeys), None);
802 Ok(().into())
803 }
804
805 #[pallet::call_index(7)]
807 #[pallet::weight(T::SystemWeightInfo::remark_with_event(remark.len() as u32))]
808 pub fn remark_with_event(
809 origin: OriginFor<T>,
810 remark: Vec<u8>,
811 ) -> DispatchResultWithPostInfo {
812 let who = ensure_signed(origin)?;
813 let hash = T::Hashing::hash(&remark[..]);
814 Self::deposit_event(Event::Remarked { sender: who, hash });
815 Ok(().into())
816 }
817
818 #[cfg(feature = "experimental")]
819 #[pallet::call_index(8)]
820 #[pallet::weight(task.weight())]
821 pub fn do_task(_origin: OriginFor<T>, task: T::RuntimeTask) -> DispatchResultWithPostInfo {
822 if !task.is_valid() {
823 return Err(Error::<T>::InvalidTask.into())
824 }
825
826 Self::deposit_event(Event::TaskStarted { task: task.clone() });
827 if let Err(err) = task.run() {
828 Self::deposit_event(Event::TaskFailed { task, err });
829 return Err(Error::<T>::FailedTask.into())
830 }
831
832 Self::deposit_event(Event::TaskCompleted { task });
834
835 Ok(().into())
837 }
838
839 #[pallet::call_index(9)]
844 #[pallet::weight((T::SystemWeightInfo::authorize_upgrade(), DispatchClass::Operational))]
845 pub fn authorize_upgrade(origin: OriginFor<T>, code_hash: T::Hash) -> DispatchResult {
846 ensure_root(origin)?;
847 Self::do_authorize_upgrade(code_hash, true);
848 Ok(())
849 }
850
851 #[pallet::call_index(10)]
860 #[pallet::weight((T::SystemWeightInfo::authorize_upgrade(), DispatchClass::Operational))]
861 pub fn authorize_upgrade_without_checks(
862 origin: OriginFor<T>,
863 code_hash: T::Hash,
864 ) -> DispatchResult {
865 ensure_root(origin)?;
866 Self::do_authorize_upgrade(code_hash, false);
867 Ok(())
868 }
869
870 #[pallet::call_index(11)]
880 #[pallet::weight((T::SystemWeightInfo::apply_authorized_upgrade(), DispatchClass::Operational))]
881 pub fn apply_authorized_upgrade(
882 _: OriginFor<T>,
883 code: Vec<u8>,
884 ) -> DispatchResultWithPostInfo {
885 let res = Self::validate_code_is_authorized(&code)?;
886 AuthorizedUpgrade::<T>::kill();
887
888 match Self::can_set_code(&code, res.check_version) {
889 CanSetCodeResult::Ok => {},
890 CanSetCodeResult::MultiBlockMigrationsOngoing =>
891 return Err(Error::<T>::MultiBlockMigrationsOngoing.into()),
892 CanSetCodeResult::InvalidVersion(error) => {
893 Self::deposit_event(Event::RejectedInvalidAuthorizedUpgrade {
895 code_hash: res.code_hash,
896 error: error.into(),
897 });
898
899 return Ok(Pays::No.into())
901 },
902 };
903 T::OnSetCode::set_code(code)?;
904
905 Ok(PostDispatchInfo {
906 actual_weight: Some(T::BlockWeights::get().max_block),
908 pays_fee: Pays::No,
910 })
911 }
912 }
913
914 #[pallet::event]
916 pub enum Event<T: Config> {
917 ExtrinsicSuccess { dispatch_info: DispatchEventInfo },
919 ExtrinsicFailed { dispatch_error: DispatchError, dispatch_info: DispatchEventInfo },
921 CodeUpdated,
923 NewAccount { account: T::AccountId },
925 KilledAccount { account: T::AccountId },
927 Remarked { sender: T::AccountId, hash: T::Hash },
929 #[cfg(feature = "experimental")]
930 TaskStarted { task: T::RuntimeTask },
932 #[cfg(feature = "experimental")]
933 TaskCompleted { task: T::RuntimeTask },
935 #[cfg(feature = "experimental")]
936 TaskFailed { task: T::RuntimeTask, err: DispatchError },
938 UpgradeAuthorized { code_hash: T::Hash, check_version: bool },
940 RejectedInvalidAuthorizedUpgrade { code_hash: T::Hash, error: DispatchError },
942 }
943
944 #[pallet::error]
946 pub enum Error<T> {
947 InvalidSpecName,
950 SpecVersionNeedsToIncrease,
953 FailedToExtractRuntimeVersion,
957 NonDefaultComposite,
959 NonZeroRefCount,
961 CallFiltered,
963 MultiBlockMigrationsOngoing,
965 #[cfg(feature = "experimental")]
966 InvalidTask,
968 #[cfg(feature = "experimental")]
969 FailedTask,
971 NothingAuthorized,
973 Unauthorized,
975 }
976
977 #[pallet::origin]
979 pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
980
981 #[pallet::storage]
983 #[pallet::getter(fn account)]
984 pub type Account<T: Config> = StorageMap<
985 _,
986 Blake2_128Concat,
987 T::AccountId,
988 AccountInfo<T::Nonce, T::AccountData>,
989 ValueQuery,
990 >;
991
992 #[pallet::storage]
994 #[pallet::whitelist_storage]
995 pub(super) type ExtrinsicCount<T: Config> = StorageValue<_, u32>;
996
997 #[pallet::storage]
999 #[pallet::whitelist_storage]
1000 pub type InherentsApplied<T: Config> = StorageValue<_, bool, ValueQuery>;
1001
1002 #[pallet::storage]
1004 #[pallet::whitelist_storage]
1005 #[pallet::getter(fn block_weight)]
1006 pub type BlockWeight<T: Config> = StorageValue<_, ConsumedWeight, ValueQuery>;
1007
1008 #[pallet::storage]
1010 #[pallet::whitelist_storage]
1011 pub type AllExtrinsicsLen<T: Config> = StorageValue<_, u32>;
1012
1013 #[pallet::storage]
1015 #[pallet::getter(fn block_hash)]
1016 pub type BlockHash<T: Config> =
1017 StorageMap<_, Twox64Concat, BlockNumberFor<T>, T::Hash, ValueQuery>;
1018
1019 #[pallet::storage]
1021 #[pallet::getter(fn extrinsic_data)]
1022 #[pallet::unbounded]
1023 pub(super) type ExtrinsicData<T: Config> =
1024 StorageMap<_, Twox64Concat, u32, Vec<u8>, ValueQuery>;
1025
1026 #[pallet::storage]
1028 #[pallet::whitelist_storage]
1029 #[pallet::getter(fn block_number)]
1030 pub(super) type Number<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
1031
1032 #[pallet::storage]
1034 #[pallet::getter(fn parent_hash)]
1035 pub(super) type ParentHash<T: Config> = StorageValue<_, T::Hash, ValueQuery>;
1036
1037 #[pallet::storage]
1039 #[pallet::whitelist_storage]
1040 #[pallet::unbounded]
1041 #[pallet::getter(fn digest)]
1042 pub(super) type Digest<T: Config> = StorageValue<_, generic::Digest, ValueQuery>;
1043
1044 #[pallet::storage]
1052 #[pallet::whitelist_storage]
1053 #[pallet::disable_try_decode_storage]
1054 #[pallet::unbounded]
1055 pub(super) type Events<T: Config> =
1056 StorageValue<_, Vec<Box<EventRecord<T::RuntimeEvent, T::Hash>>>, ValueQuery>;
1057
1058 #[pallet::storage]
1060 #[pallet::whitelist_storage]
1061 #[pallet::getter(fn event_count)]
1062 pub(super) type EventCount<T: Config> = StorageValue<_, EventIndex, ValueQuery>;
1063
1064 #[pallet::storage]
1075 #[pallet::unbounded]
1076 #[pallet::getter(fn event_topics)]
1077 pub(super) type EventTopics<T: Config> =
1078 StorageMap<_, Blake2_128Concat, T::Hash, Vec<(BlockNumberFor<T>, EventIndex)>, ValueQuery>;
1079
1080 #[pallet::storage]
1082 #[pallet::unbounded]
1083 pub type LastRuntimeUpgrade<T: Config> = StorageValue<_, LastRuntimeUpgradeInfo>;
1084
1085 #[pallet::storage]
1087 pub(super) type UpgradedToU32RefCount<T: Config> = StorageValue<_, bool, ValueQuery>;
1088
1089 #[pallet::storage]
1092 pub(super) type UpgradedToTripleRefCount<T: Config> = StorageValue<_, bool, ValueQuery>;
1093
1094 #[pallet::storage]
1096 #[pallet::whitelist_storage]
1097 pub(super) type ExecutionPhase<T: Config> = StorageValue<_, Phase>;
1098
1099 #[pallet::storage]
1101 #[pallet::getter(fn authorized_upgrade)]
1102 pub(super) type AuthorizedUpgrade<T: Config> =
1103 StorageValue<_, CodeUpgradeAuthorization<T>, OptionQuery>;
1104
1105 #[pallet::storage]
1113 #[pallet::whitelist_storage]
1114 pub type ExtrinsicWeightReclaimed<T: Config> = StorageValue<_, Weight, ValueQuery>;
1115
1116 #[derive(frame_support::DefaultNoBound)]
1117 #[pallet::genesis_config]
1118 pub struct GenesisConfig<T: Config> {
1119 #[serde(skip)]
1120 pub _config: core::marker::PhantomData<T>,
1121 }
1122
1123 #[pallet::genesis_build]
1124 impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
1125 fn build(&self) {
1126 <BlockHash<T>>::insert::<_, T::Hash>(BlockNumberFor::<T>::zero(), hash69());
1127 <ParentHash<T>>::put::<T::Hash>(hash69());
1128 <LastRuntimeUpgrade<T>>::put(LastRuntimeUpgradeInfo::from(T::Version::get()));
1129 <UpgradedToU32RefCount<T>>::put(true);
1130 <UpgradedToTripleRefCount<T>>::put(true);
1131
1132 sp_io::storage::set(well_known_keys::EXTRINSIC_INDEX, &0u32.encode());
1133 }
1134 }
1135
1136 #[pallet::validate_unsigned]
1137 impl<T: Config> sp_runtime::traits::ValidateUnsigned for Pallet<T> {
1138 type Call = Call<T>;
1139 fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
1140 if let Call::apply_authorized_upgrade { ref code } = call {
1141 if let Ok(res) = Self::validate_code_is_authorized(&code[..]) {
1142 if Self::can_set_code(&code, false).is_ok() {
1143 return Ok(ValidTransaction {
1144 priority: u64::max_value(),
1145 requires: Vec::new(),
1146 provides: vec![res.code_hash.encode()],
1147 longevity: TransactionLongevity::max_value(),
1148 propagate: true,
1149 })
1150 }
1151 }
1152 }
1153
1154 #[cfg(feature = "experimental")]
1155 if let Call::do_task { ref task } = call {
1156 if task.is_valid() {
1157 return Ok(ValidTransaction {
1158 priority: u64::max_value(),
1159 requires: Vec::new(),
1160 provides: vec![T::Hashing::hash_of(&task.encode()).as_ref().to_vec()],
1161 longevity: TransactionLongevity::max_value(),
1162 propagate: true,
1163 })
1164 }
1165 }
1166
1167 Err(InvalidTransaction::Call.into())
1168 }
1169 }
1170}
1171
1172pub type Key = Vec<u8>;
1173pub type KeyValue = (Vec<u8>, Vec<u8>);
1174
1175#[derive(Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
1177#[cfg_attr(feature = "std", derive(Serialize, PartialEq, Eq, Clone))]
1178pub enum Phase {
1179 ApplyExtrinsic(u32),
1181 Finalization,
1183 Initialization,
1185}
1186
1187impl Default for Phase {
1188 fn default() -> Self {
1189 Self::Initialization
1190 }
1191}
1192
1193#[derive(Encode, Decode, RuntimeDebug, TypeInfo)]
1195#[cfg_attr(feature = "std", derive(Serialize, PartialEq, Eq, Clone))]
1196pub struct EventRecord<E: Parameter + Member, T> {
1197 pub phase: Phase,
1199 pub event: E,
1201 pub topics: Vec<T>,
1203}
1204
1205fn hash69<T: AsMut<[u8]> + Default>() -> T {
1208 let mut h = T::default();
1209 h.as_mut().iter_mut().for_each(|byte| *byte = 69);
1210 h
1211}
1212
1213type EventIndex = u32;
1218
1219pub type RefCount = u32;
1221
1222#[derive(Clone, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
1224pub struct AccountInfo<Nonce, AccountData> {
1225 pub nonce: Nonce,
1227 pub consumers: RefCount,
1230 pub providers: RefCount,
1233 pub sufficients: RefCount,
1236 pub data: AccountData,
1239}
1240
1241#[derive(RuntimeDebug, Encode, Decode, TypeInfo)]
1244#[cfg_attr(feature = "std", derive(PartialEq))]
1245pub struct LastRuntimeUpgradeInfo {
1246 pub spec_version: codec::Compact<u32>,
1247 pub spec_name: Cow<'static, str>,
1248}
1249
1250impl LastRuntimeUpgradeInfo {
1251 pub fn was_upgraded(&self, current: &RuntimeVersion) -> bool {
1255 current.spec_version > self.spec_version.0 || current.spec_name != self.spec_name
1256 }
1257}
1258
1259impl From<RuntimeVersion> for LastRuntimeUpgradeInfo {
1260 fn from(version: RuntimeVersion) -> Self {
1261 Self { spec_version: version.spec_version.into(), spec_name: version.spec_name }
1262 }
1263}
1264
1265pub struct EnsureRoot<AccountId>(core::marker::PhantomData<AccountId>);
1267impl<O: OriginTrait, AccountId> EnsureOrigin<O> for EnsureRoot<AccountId> {
1268 type Success = ();
1269 fn try_origin(o: O) -> Result<Self::Success, O> {
1270 match o.as_system_ref() {
1271 Some(RawOrigin::Root) => Ok(()),
1272 _ => Err(o),
1273 }
1274 }
1275
1276 #[cfg(feature = "runtime-benchmarks")]
1277 fn try_successful_origin() -> Result<O, ()> {
1278 Ok(O::root())
1279 }
1280}
1281
1282impl_ensure_origin_with_arg_ignoring_arg! {
1283 impl< { O: .., AccountId: Decode, T } >
1284 EnsureOriginWithArg<O, T> for EnsureRoot<AccountId>
1285 {}
1286}
1287
1288pub struct EnsureRootWithSuccess<AccountId, Success>(
1290 core::marker::PhantomData<(AccountId, Success)>,
1291);
1292impl<O: OriginTrait, AccountId, Success: TypedGet> EnsureOrigin<O>
1293 for EnsureRootWithSuccess<AccountId, Success>
1294{
1295 type Success = Success::Type;
1296 fn try_origin(o: O) -> Result<Self::Success, O> {
1297 match o.as_system_ref() {
1298 Some(RawOrigin::Root) => Ok(Success::get()),
1299 _ => Err(o),
1300 }
1301 }
1302
1303 #[cfg(feature = "runtime-benchmarks")]
1304 fn try_successful_origin() -> Result<O, ()> {
1305 Ok(O::root())
1306 }
1307}
1308
1309impl_ensure_origin_with_arg_ignoring_arg! {
1310 impl< { O: .., AccountId: Decode, Success: TypedGet, T } >
1311 EnsureOriginWithArg<O, T> for EnsureRootWithSuccess<AccountId, Success>
1312 {}
1313}
1314
1315pub struct EnsureWithSuccess<Ensure, AccountId, Success>(
1317 core::marker::PhantomData<(Ensure, AccountId, Success)>,
1318);
1319
1320impl<O: OriginTrait, Ensure: EnsureOrigin<O>, AccountId, Success: TypedGet> EnsureOrigin<O>
1321 for EnsureWithSuccess<Ensure, AccountId, Success>
1322{
1323 type Success = Success::Type;
1324
1325 fn try_origin(o: O) -> Result<Self::Success, O> {
1326 Ensure::try_origin(o).map(|_| Success::get())
1327 }
1328
1329 #[cfg(feature = "runtime-benchmarks")]
1330 fn try_successful_origin() -> Result<O, ()> {
1331 Ensure::try_successful_origin()
1332 }
1333}
1334
1335pub struct EnsureSigned<AccountId>(core::marker::PhantomData<AccountId>);
1337impl<O: OriginTrait<AccountId = AccountId>, AccountId: Decode + Clone> EnsureOrigin<O>
1338 for EnsureSigned<AccountId>
1339{
1340 type Success = AccountId;
1341 fn try_origin(o: O) -> Result<Self::Success, O> {
1342 match o.as_system_ref() {
1343 Some(RawOrigin::Signed(who)) => Ok(who.clone()),
1344 _ => Err(o),
1345 }
1346 }
1347
1348 #[cfg(feature = "runtime-benchmarks")]
1349 fn try_successful_origin() -> Result<O, ()> {
1350 let zero_account_id =
1351 AccountId::decode(&mut TrailingZeroInput::zeroes()).map_err(|_| ())?;
1352 Ok(O::signed(zero_account_id))
1353 }
1354}
1355
1356impl_ensure_origin_with_arg_ignoring_arg! {
1357 impl< { O: OriginTrait<AccountId = AccountId>, AccountId: Decode + Clone, T } >
1358 EnsureOriginWithArg<O, T> for EnsureSigned<AccountId>
1359 {}
1360}
1361
1362pub struct EnsureSignedBy<Who, AccountId>(core::marker::PhantomData<(Who, AccountId)>);
1364impl<
1365 O: OriginTrait<AccountId = AccountId>,
1366 Who: SortedMembers<AccountId>,
1367 AccountId: PartialEq + Clone + Ord + Decode,
1368 > EnsureOrigin<O> for EnsureSignedBy<Who, AccountId>
1369{
1370 type Success = AccountId;
1371 fn try_origin(o: O) -> Result<Self::Success, O> {
1372 match o.as_system_ref() {
1373 Some(RawOrigin::Signed(ref who)) if Who::contains(who) => Ok(who.clone()),
1374 _ => Err(o),
1375 }
1376 }
1377
1378 #[cfg(feature = "runtime-benchmarks")]
1379 fn try_successful_origin() -> Result<O, ()> {
1380 let first_member = match Who::sorted_members().first() {
1381 Some(account) => account.clone(),
1382 None => AccountId::decode(&mut TrailingZeroInput::zeroes()).map_err(|_| ())?,
1383 };
1384 Ok(O::signed(first_member))
1385 }
1386}
1387
1388impl_ensure_origin_with_arg_ignoring_arg! {
1389 impl< { O: OriginTrait<AccountId = AccountId>, Who: SortedMembers<AccountId>, AccountId: PartialEq + Clone + Ord + Decode, T } >
1390 EnsureOriginWithArg<O, T> for EnsureSignedBy<Who, AccountId>
1391 {}
1392}
1393
1394pub struct EnsureNone<AccountId>(core::marker::PhantomData<AccountId>);
1396impl<O: OriginTrait<AccountId = AccountId>, AccountId> EnsureOrigin<O> for EnsureNone<AccountId> {
1397 type Success = ();
1398 fn try_origin(o: O) -> Result<Self::Success, O> {
1399 match o.as_system_ref() {
1400 Some(RawOrigin::None) => Ok(()),
1401 _ => Err(o),
1402 }
1403 }
1404
1405 #[cfg(feature = "runtime-benchmarks")]
1406 fn try_successful_origin() -> Result<O, ()> {
1407 Ok(O::none())
1408 }
1409}
1410
1411impl_ensure_origin_with_arg_ignoring_arg! {
1412 impl< { O: OriginTrait<AccountId = AccountId>, AccountId, T } >
1413 EnsureOriginWithArg<O, T> for EnsureNone<AccountId>
1414 {}
1415}
1416
1417pub struct EnsureNever<Success>(core::marker::PhantomData<Success>);
1419impl<O, Success> EnsureOrigin<O> for EnsureNever<Success> {
1420 type Success = Success;
1421 fn try_origin(o: O) -> Result<Self::Success, O> {
1422 Err(o)
1423 }
1424
1425 #[cfg(feature = "runtime-benchmarks")]
1426 fn try_successful_origin() -> Result<O, ()> {
1427 Err(())
1428 }
1429}
1430
1431impl_ensure_origin_with_arg_ignoring_arg! {
1432 impl< { O, Success, T } >
1433 EnsureOriginWithArg<O, T> for EnsureNever<Success>
1434 {}
1435}
1436
1437#[docify::export]
1438pub fn ensure_signed<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<AccountId, BadOrigin>
1441where
1442 OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
1443{
1444 match o.into() {
1445 Ok(RawOrigin::Signed(t)) => Ok(t),
1446 _ => Err(BadOrigin),
1447 }
1448}
1449
1450pub fn ensure_signed_or_root<OuterOrigin, AccountId>(
1454 o: OuterOrigin,
1455) -> Result<Option<AccountId>, BadOrigin>
1456where
1457 OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
1458{
1459 match o.into() {
1460 Ok(RawOrigin::Root) => Ok(None),
1461 Ok(RawOrigin::Signed(t)) => Ok(Some(t)),
1462 _ => Err(BadOrigin),
1463 }
1464}
1465
1466pub fn ensure_root<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), BadOrigin>
1468where
1469 OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
1470{
1471 match o.into() {
1472 Ok(RawOrigin::Root) => Ok(()),
1473 _ => Err(BadOrigin),
1474 }
1475}
1476
1477pub fn ensure_none<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), BadOrigin>
1479where
1480 OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
1481{
1482 match o.into() {
1483 Ok(RawOrigin::None) => Ok(()),
1484 _ => Err(BadOrigin),
1485 }
1486}
1487
1488pub fn ensure_authorized<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), BadOrigin>
1491where
1492 OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
1493{
1494 match o.into() {
1495 Ok(RawOrigin::Authorized) => Ok(()),
1496 _ => Err(BadOrigin),
1497 }
1498}
1499
1500#[derive(RuntimeDebug)]
1502pub enum RefStatus {
1503 Referenced,
1504 Unreferenced,
1505}
1506
1507#[derive(Eq, PartialEq, RuntimeDebug)]
1509pub enum IncRefStatus {
1510 Created,
1512 Existed,
1514}
1515
1516#[derive(Eq, PartialEq, RuntimeDebug)]
1518pub enum DecRefStatus {
1519 Reaped,
1521 Exists,
1523}
1524
1525pub enum CanSetCodeResult<T: Config> {
1527 Ok,
1529 MultiBlockMigrationsOngoing,
1531 InvalidVersion(Error<T>),
1533}
1534
1535impl<T: Config> CanSetCodeResult<T> {
1536 pub fn into_result(self) -> Result<(), DispatchError> {
1538 match self {
1539 Self::Ok => Ok(()),
1540 Self::MultiBlockMigrationsOngoing =>
1541 Err(Error::<T>::MultiBlockMigrationsOngoing.into()),
1542 Self::InvalidVersion(err) => Err(err.into()),
1543 }
1544 }
1545
1546 pub fn is_ok(&self) -> bool {
1548 matches!(self, Self::Ok)
1549 }
1550}
1551
1552impl<T: Config> Pallet<T> {
1553 #[doc = docify::embed!("src/tests.rs", last_runtime_upgrade_spec_version_usage)]
1567 pub fn last_runtime_upgrade_spec_version() -> u32 {
1568 LastRuntimeUpgrade::<T>::get().map_or(0, |l| l.spec_version.0)
1569 }
1570
1571 pub fn account_exists(who: &T::AccountId) -> bool {
1573 Account::<T>::contains_key(who)
1574 }
1575
1576 pub fn update_code_in_storage(code: &[u8]) {
1582 storage::unhashed::put_raw(well_known_keys::CODE, code);
1583 Self::deposit_log(generic::DigestItem::RuntimeEnvironmentUpdated);
1584 Self::deposit_event(Event::CodeUpdated);
1585 }
1586
1587 pub fn inherents_applied() -> bool {
1589 InherentsApplied::<T>::get()
1590 }
1591
1592 pub fn note_inherents_applied() {
1597 InherentsApplied::<T>::put(true);
1598 }
1599
1600 #[deprecated = "Use `inc_consumers` instead"]
1602 pub fn inc_ref(who: &T::AccountId) {
1603 let _ = Self::inc_consumers(who);
1604 }
1605
1606 #[deprecated = "Use `dec_consumers` instead"]
1609 pub fn dec_ref(who: &T::AccountId) {
1610 let _ = Self::dec_consumers(who);
1611 }
1612
1613 #[deprecated = "Use `consumers` instead"]
1615 pub fn refs(who: &T::AccountId) -> RefCount {
1616 Self::consumers(who)
1617 }
1618
1619 #[deprecated = "Use `!is_provider_required` instead"]
1621 pub fn allow_death(who: &T::AccountId) -> bool {
1622 !Self::is_provider_required(who)
1623 }
1624
1625 pub fn inc_providers(who: &T::AccountId) -> IncRefStatus {
1627 Account::<T>::mutate(who, |a| {
1628 if a.providers == 0 && a.sufficients == 0 {
1629 a.providers = 1;
1631 Self::on_created_account(who.clone(), a);
1632 IncRefStatus::Created
1633 } else {
1634 a.providers = a.providers.saturating_add(1);
1635 IncRefStatus::Existed
1636 }
1637 })
1638 }
1639
1640 pub fn dec_providers(who: &T::AccountId) -> Result<DecRefStatus, DispatchError> {
1644 Account::<T>::try_mutate_exists(who, |maybe_account| {
1645 if let Some(mut account) = maybe_account.take() {
1646 if account.providers == 0 {
1647 log::error!(
1649 target: LOG_TARGET,
1650 "Logic error: Unexpected underflow in reducing provider",
1651 );
1652 account.providers = 1;
1653 }
1654 match (account.providers, account.consumers, account.sufficients) {
1655 (1, 0, 0) => {
1656 Pallet::<T>::on_killed_account(who.clone());
1659 Ok(DecRefStatus::Reaped)
1660 },
1661 (1, c, _) if c > 0 => {
1662 Err(DispatchError::ConsumerRemaining)
1664 },
1665 (x, _, _) => {
1666 account.providers = x - 1;
1669 *maybe_account = Some(account);
1670 Ok(DecRefStatus::Exists)
1671 },
1672 }
1673 } else {
1674 log::error!(
1675 target: LOG_TARGET,
1676 "Logic error: Account already dead when reducing provider",
1677 );
1678 Ok(DecRefStatus::Reaped)
1679 }
1680 })
1681 }
1682
1683 pub fn inc_sufficients(who: &T::AccountId) -> IncRefStatus {
1685 Account::<T>::mutate(who, |a| {
1686 if a.providers + a.sufficients == 0 {
1687 a.sufficients = 1;
1689 Self::on_created_account(who.clone(), a);
1690 IncRefStatus::Created
1691 } else {
1692 a.sufficients = a.sufficients.saturating_add(1);
1693 IncRefStatus::Existed
1694 }
1695 })
1696 }
1697
1698 pub fn dec_sufficients(who: &T::AccountId) -> DecRefStatus {
1702 Account::<T>::mutate_exists(who, |maybe_account| {
1703 if let Some(mut account) = maybe_account.take() {
1704 if account.sufficients == 0 {
1705 log::error!(
1707 target: LOG_TARGET,
1708 "Logic error: Unexpected underflow in reducing sufficients",
1709 );
1710 }
1711 match (account.sufficients, account.providers) {
1712 (0, 0) | (1, 0) => {
1713 Pallet::<T>::on_killed_account(who.clone());
1714 DecRefStatus::Reaped
1715 },
1716 (x, _) => {
1717 account.sufficients = x.saturating_sub(1);
1718 *maybe_account = Some(account);
1719 DecRefStatus::Exists
1720 },
1721 }
1722 } else {
1723 log::error!(
1724 target: LOG_TARGET,
1725 "Logic error: Account already dead when reducing provider",
1726 );
1727 DecRefStatus::Reaped
1728 }
1729 })
1730 }
1731
1732 pub fn providers(who: &T::AccountId) -> RefCount {
1734 Account::<T>::get(who).providers
1735 }
1736
1737 pub fn sufficients(who: &T::AccountId) -> RefCount {
1739 Account::<T>::get(who).sufficients
1740 }
1741
1742 pub fn reference_count(who: &T::AccountId) -> RefCount {
1744 let a = Account::<T>::get(who);
1745 a.providers + a.sufficients
1746 }
1747
1748 pub fn inc_consumers(who: &T::AccountId) -> Result<(), DispatchError> {
1753 Account::<T>::try_mutate(who, |a| {
1754 if a.providers > 0 {
1755 if a.consumers < T::MaxConsumers::max_consumers() {
1756 a.consumers = a.consumers.saturating_add(1);
1757 Ok(())
1758 } else {
1759 Err(DispatchError::TooManyConsumers)
1760 }
1761 } else {
1762 Err(DispatchError::NoProviders)
1763 }
1764 })
1765 }
1766
1767 pub fn inc_consumers_without_limit(who: &T::AccountId) -> Result<(), DispatchError> {
1771 Account::<T>::try_mutate(who, |a| {
1772 if a.providers > 0 {
1773 a.consumers = a.consumers.saturating_add(1);
1774 Ok(())
1775 } else {
1776 Err(DispatchError::NoProviders)
1777 }
1778 })
1779 }
1780
1781 pub fn dec_consumers(who: &T::AccountId) {
1784 Account::<T>::mutate(who, |a| {
1785 if a.consumers > 0 {
1786 a.consumers -= 1;
1787 } else {
1788 log::error!(
1789 target: LOG_TARGET,
1790 "Logic error: Unexpected underflow in reducing consumer",
1791 );
1792 }
1793 })
1794 }
1795
1796 pub fn consumers(who: &T::AccountId) -> RefCount {
1798 Account::<T>::get(who).consumers
1799 }
1800
1801 pub fn is_provider_required(who: &T::AccountId) -> bool {
1803 Account::<T>::get(who).consumers != 0
1804 }
1805
1806 pub fn can_dec_provider(who: &T::AccountId) -> bool {
1808 let a = Account::<T>::get(who);
1809 a.consumers == 0 || a.providers > 1
1810 }
1811
1812 pub fn can_accrue_consumers(who: &T::AccountId, amount: u32) -> bool {
1815 let a = Account::<T>::get(who);
1816 match a.consumers.checked_add(amount) {
1817 Some(c) => a.providers > 0 && c <= T::MaxConsumers::max_consumers(),
1818 None => false,
1819 }
1820 }
1821
1822 pub fn can_inc_consumer(who: &T::AccountId) -> bool {
1825 Self::can_accrue_consumers(who, 1)
1826 }
1827
1828 pub fn deposit_event(event: impl Into<T::RuntimeEvent>) {
1832 Self::deposit_event_indexed(&[], event.into());
1833 }
1834
1835 pub fn deposit_event_indexed(topics: &[T::Hash], event: T::RuntimeEvent) {
1843 let block_number = Self::block_number();
1844
1845 if block_number.is_zero() {
1847 return
1848 }
1849
1850 let phase = ExecutionPhase::<T>::get().unwrap_or_default();
1851 let event = EventRecord { phase, event, topics: topics.to_vec() };
1852
1853 let event_idx = {
1855 let old_event_count = EventCount::<T>::get();
1856 let new_event_count = match old_event_count.checked_add(1) {
1857 None => return,
1860 Some(nc) => nc,
1861 };
1862 EventCount::<T>::put(new_event_count);
1863 old_event_count
1864 };
1865
1866 Events::<T>::append(event);
1867
1868 for topic in topics {
1869 <EventTopics<T>>::append(topic, &(block_number, event_idx));
1870 }
1871 }
1872
1873 pub fn extrinsic_index() -> Option<u32> {
1875 storage::unhashed::get(well_known_keys::EXTRINSIC_INDEX)
1876 }
1877
1878 pub fn extrinsic_count() -> u32 {
1880 ExtrinsicCount::<T>::get().unwrap_or_default()
1881 }
1882
1883 pub fn all_extrinsics_len() -> u32 {
1884 AllExtrinsicsLen::<T>::get().unwrap_or_default()
1885 }
1886
1887 pub fn register_extra_weight_unchecked(weight: Weight, class: DispatchClass) {
1903 BlockWeight::<T>::mutate(|current_weight| {
1904 current_weight.accrue(weight, class);
1905 });
1906 }
1907
1908 pub fn initialize(number: &BlockNumberFor<T>, parent_hash: &T::Hash, digest: &generic::Digest) {
1910 ExecutionPhase::<T>::put(Phase::Initialization);
1912 storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &0u32);
1913 let entropy = (b"frame_system::initialize", parent_hash).using_encoded(blake2_256);
1914 storage::unhashed::put_raw(well_known_keys::INTRABLOCK_ENTROPY, &entropy[..]);
1915 <Number<T>>::put(number);
1916 <Digest<T>>::put(digest);
1917 <ParentHash<T>>::put(parent_hash);
1918 <BlockHash<T>>::insert(*number - One::one(), parent_hash);
1919
1920 BlockWeight::<T>::kill();
1922 }
1923
1924 pub fn resource_usage_report() {
1928 log::debug!(
1929 target: LOG_TARGET,
1930 "[{:?}] {} extrinsics, length: {} (normal {}%, op: {}%, mandatory {}%) / normal weight:\
1931 {} (ref_time: {}%, proof_size: {}%) op weight {} (ref_time {}%, proof_size {}%) / \
1932 mandatory weight {} (ref_time: {}%, proof_size: {}%)",
1933 Self::block_number(),
1934 Self::extrinsic_count(),
1935 Self::all_extrinsics_len(),
1936 sp_runtime::Percent::from_rational(
1937 Self::all_extrinsics_len(),
1938 *T::BlockLength::get().max.get(DispatchClass::Normal)
1939 ).deconstruct(),
1940 sp_runtime::Percent::from_rational(
1941 Self::all_extrinsics_len(),
1942 *T::BlockLength::get().max.get(DispatchClass::Operational)
1943 ).deconstruct(),
1944 sp_runtime::Percent::from_rational(
1945 Self::all_extrinsics_len(),
1946 *T::BlockLength::get().max.get(DispatchClass::Mandatory)
1947 ).deconstruct(),
1948 Self::block_weight().get(DispatchClass::Normal),
1949 sp_runtime::Percent::from_rational(
1950 Self::block_weight().get(DispatchClass::Normal).ref_time(),
1951 T::BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap_or(Bounded::max_value()).ref_time()
1952 ).deconstruct(),
1953 sp_runtime::Percent::from_rational(
1954 Self::block_weight().get(DispatchClass::Normal).proof_size(),
1955 T::BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap_or(Bounded::max_value()).proof_size()
1956 ).deconstruct(),
1957 Self::block_weight().get(DispatchClass::Operational),
1958 sp_runtime::Percent::from_rational(
1959 Self::block_weight().get(DispatchClass::Operational).ref_time(),
1960 T::BlockWeights::get().get(DispatchClass::Operational).max_total.unwrap_or(Bounded::max_value()).ref_time()
1961 ).deconstruct(),
1962 sp_runtime::Percent::from_rational(
1963 Self::block_weight().get(DispatchClass::Operational).proof_size(),
1964 T::BlockWeights::get().get(DispatchClass::Operational).max_total.unwrap_or(Bounded::max_value()).proof_size()
1965 ).deconstruct(),
1966 Self::block_weight().get(DispatchClass::Mandatory),
1967 sp_runtime::Percent::from_rational(
1968 Self::block_weight().get(DispatchClass::Mandatory).ref_time(),
1969 T::BlockWeights::get().get(DispatchClass::Mandatory).max_total.unwrap_or(Bounded::max_value()).ref_time()
1970 ).deconstruct(),
1971 sp_runtime::Percent::from_rational(
1972 Self::block_weight().get(DispatchClass::Mandatory).proof_size(),
1973 T::BlockWeights::get().get(DispatchClass::Mandatory).max_total.unwrap_or(Bounded::max_value()).proof_size()
1974 ).deconstruct(),
1975 );
1976 }
1977
1978 pub fn finalize() -> HeaderFor<T> {
1981 Self::resource_usage_report();
1982 ExecutionPhase::<T>::kill();
1983 AllExtrinsicsLen::<T>::kill();
1984 storage::unhashed::kill(well_known_keys::INTRABLOCK_ENTROPY);
1985 InherentsApplied::<T>::kill();
1986
1987 let number = <Number<T>>::get();
1998 let parent_hash = <ParentHash<T>>::get();
1999 let digest = <Digest<T>>::get();
2000
2001 let extrinsics = (0..ExtrinsicCount::<T>::take().unwrap_or_default())
2002 .map(ExtrinsicData::<T>::take)
2003 .collect();
2004 let extrinsics_root_state_version = T::Version::get().extrinsics_root_state_version();
2005 let extrinsics_root =
2006 extrinsics_data_root::<T::Hashing>(extrinsics, extrinsics_root_state_version);
2007
2008 let block_hash_count = T::BlockHashCount::get();
2010 let to_remove = number.saturating_sub(block_hash_count).saturating_sub(One::one());
2011
2012 if !to_remove.is_zero() {
2014 <BlockHash<T>>::remove(to_remove);
2015 }
2016
2017 let version = T::Version::get().state_version();
2018 let storage_root = T::Hash::decode(&mut &sp_io::storage::root(version)[..])
2019 .expect("Node is configured to use the same hash; qed");
2020
2021 HeaderFor::<T>::new(number, extrinsics_root, storage_root, parent_hash, digest)
2022 }
2023
2024 pub fn deposit_log(item: generic::DigestItem) {
2026 <Digest<T>>::append(item);
2027 }
2028
2029 #[cfg(any(feature = "std", test))]
2031 pub fn externalities() -> TestExternalities {
2032 TestExternalities::new(sp_core::storage::Storage {
2033 top: [
2034 (<BlockHash<T>>::hashed_key_for(BlockNumberFor::<T>::zero()), [69u8; 32].encode()),
2035 (<Number<T>>::hashed_key().to_vec(), BlockNumberFor::<T>::one().encode()),
2036 (<ParentHash<T>>::hashed_key().to_vec(), [69u8; 32].encode()),
2037 ]
2038 .into_iter()
2039 .collect(),
2040 children_default: Default::default(),
2041 })
2042 }
2043
2044 #[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2052 pub fn events() -> Vec<EventRecord<T::RuntimeEvent, T::Hash>> {
2053 Self::read_events_no_consensus().map(|e| *e).collect()
2055 }
2056
2057 pub fn event_no_consensus(index: usize) -> Option<T::RuntimeEvent> {
2062 Self::read_events_no_consensus().nth(index).map(|e| e.event.clone())
2063 }
2064
2065 pub fn read_events_no_consensus(
2070 ) -> impl Iterator<Item = Box<EventRecord<T::RuntimeEvent, T::Hash>>> {
2071 Events::<T>::stream_iter()
2072 }
2073
2074 pub fn read_events_for_pallet<E>() -> Vec<E>
2079 where
2080 T::RuntimeEvent: TryInto<E>,
2081 {
2082 Events::<T>::get()
2083 .into_iter()
2084 .map(|er| er.event)
2085 .filter_map(|e| e.try_into().ok())
2086 .collect::<_>()
2087 }
2088
2089 #[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2098 pub fn run_to_block_with<AllPalletsWithSystem>(
2099 n: BlockNumberFor<T>,
2100 mut hooks: RunToBlockHooks<T>,
2101 ) where
2102 AllPalletsWithSystem: frame_support::traits::OnInitialize<BlockNumberFor<T>>
2103 + frame_support::traits::OnFinalize<BlockNumberFor<T>>,
2104 {
2105 let mut bn = Self::block_number();
2106
2107 while bn < n {
2108 if !bn.is_zero() {
2110 (hooks.before_finalize)(bn);
2111 AllPalletsWithSystem::on_finalize(bn);
2112 (hooks.after_finalize)(bn);
2113 }
2114
2115 bn += One::one();
2116
2117 Self::set_block_number(bn);
2118 (hooks.before_initialize)(bn);
2119 AllPalletsWithSystem::on_initialize(bn);
2120 (hooks.after_initialize)(bn);
2121 }
2122 }
2123
2124 #[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2126 pub fn run_to_block<AllPalletsWithSystem>(n: BlockNumberFor<T>)
2127 where
2128 AllPalletsWithSystem: frame_support::traits::OnInitialize<BlockNumberFor<T>>
2129 + frame_support::traits::OnFinalize<BlockNumberFor<T>>,
2130 {
2131 Self::run_to_block_with::<AllPalletsWithSystem>(n, Default::default());
2132 }
2133
2134 #[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2137 pub fn set_block_number(n: BlockNumberFor<T>) {
2138 <Number<T>>::put(n);
2139 }
2140
2141 #[cfg(any(feature = "std", test))]
2143 pub fn set_extrinsic_index(extrinsic_index: u32) {
2144 storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &extrinsic_index)
2145 }
2146
2147 #[cfg(any(feature = "std", test))]
2150 pub fn set_parent_hash(n: T::Hash) {
2151 <ParentHash<T>>::put(n);
2152 }
2153
2154 #[cfg(any(feature = "std", test))]
2156 pub fn set_block_consumed_resources(weight: Weight, len: usize) {
2157 BlockWeight::<T>::mutate(|current_weight| {
2158 current_weight.set(weight, DispatchClass::Normal)
2159 });
2160 AllExtrinsicsLen::<T>::put(len as u32);
2161 }
2162
2163 pub fn reset_events() {
2168 <Events<T>>::kill();
2169 EventCount::<T>::kill();
2170 let _ = <EventTopics<T>>::clear(u32::max_value(), None);
2171 }
2172
2173 #[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2177 #[track_caller]
2178 pub fn assert_has_event(event: T::RuntimeEvent) {
2179 let warn = if Self::block_number().is_zero() {
2180 "WARNING: block number is zero, and events are not registered at block number zero.\n"
2181 } else {
2182 ""
2183 };
2184
2185 let events = Self::events();
2186 assert!(
2187 events.iter().any(|record| record.event == event),
2188 "{warn}expected event {event:?} not found in events {events:?}",
2189 );
2190 }
2191
2192 #[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2196 #[track_caller]
2197 pub fn assert_last_event(event: T::RuntimeEvent) {
2198 let warn = if Self::block_number().is_zero() {
2199 "WARNING: block number is zero, and events are not registered at block number zero.\n"
2200 } else {
2201 ""
2202 };
2203
2204 let last_event = Self::events()
2205 .last()
2206 .expect(&alloc::format!("{warn}events expected"))
2207 .event
2208 .clone();
2209 assert_eq!(
2210 last_event, event,
2211 "{warn}expected event {event:?} is not equal to the last event {last_event:?}",
2212 );
2213 }
2214
2215 pub fn runtime_version() -> RuntimeVersion {
2217 T::Version::get()
2218 }
2219
2220 pub fn account_nonce(who: impl EncodeLike<T::AccountId>) -> T::Nonce {
2222 Account::<T>::get(who).nonce
2223 }
2224
2225 pub fn inc_account_nonce(who: impl EncodeLike<T::AccountId>) {
2227 Account::<T>::mutate(who, |a| a.nonce += T::Nonce::one());
2228 }
2229
2230 pub fn note_extrinsic(encoded_xt: Vec<u8>) {
2235 ExtrinsicData::<T>::insert(Self::extrinsic_index().unwrap_or_default(), encoded_xt);
2236 }
2237
2238 pub fn note_applied_extrinsic(r: &DispatchResultWithPostInfo, info: DispatchInfo) {
2244 let weight = extract_actual_weight(r, &info)
2245 .saturating_add(T::BlockWeights::get().get(info.class).base_extrinsic);
2246 let class = info.class;
2247 let pays_fee = extract_actual_pays_fee(r, &info);
2248 let dispatch_event_info = DispatchEventInfo { weight, class, pays_fee };
2249
2250 Self::deposit_event(match r {
2251 Ok(_) => Event::ExtrinsicSuccess { dispatch_info: dispatch_event_info },
2252 Err(err) => {
2253 log::trace!(
2254 target: LOG_TARGET,
2255 "Extrinsic failed at block({:?}): {:?}",
2256 Self::block_number(),
2257 err,
2258 );
2259 Event::ExtrinsicFailed {
2260 dispatch_error: err.error,
2261 dispatch_info: dispatch_event_info,
2262 }
2263 },
2264 });
2265
2266 log::trace!(
2267 target: LOG_TARGET,
2268 "Used block weight: {:?}",
2269 BlockWeight::<T>::get(),
2270 );
2271
2272 log::trace!(
2273 target: LOG_TARGET,
2274 "Used block length: {:?}",
2275 Pallet::<T>::all_extrinsics_len(),
2276 );
2277
2278 let next_extrinsic_index = Self::extrinsic_index().unwrap_or_default() + 1u32;
2279
2280 storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &next_extrinsic_index);
2281 ExecutionPhase::<T>::put(Phase::ApplyExtrinsic(next_extrinsic_index));
2282 ExtrinsicWeightReclaimed::<T>::kill();
2283 }
2284
2285 pub fn note_finished_extrinsics() {
2288 let extrinsic_index: u32 =
2289 storage::unhashed::take(well_known_keys::EXTRINSIC_INDEX).unwrap_or_default();
2290 ExtrinsicCount::<T>::put(extrinsic_index);
2291 ExecutionPhase::<T>::put(Phase::Finalization);
2292 }
2293
2294 pub fn note_finished_initialize() {
2297 ExecutionPhase::<T>::put(Phase::ApplyExtrinsic(0))
2298 }
2299
2300 pub fn on_created_account(who: T::AccountId, _a: &mut AccountInfo<T::Nonce, T::AccountData>) {
2302 T::OnNewAccount::on_new_account(&who);
2303 Self::deposit_event(Event::NewAccount { account: who });
2304 }
2305
2306 fn on_killed_account(who: T::AccountId) {
2308 T::OnKilledAccount::on_killed_account(&who);
2309 Self::deposit_event(Event::KilledAccount { account: who });
2310 }
2311
2312 pub fn can_set_code(code: &[u8], check_version: bool) -> CanSetCodeResult<T> {
2316 if T::MultiBlockMigrator::ongoing() {
2317 return CanSetCodeResult::MultiBlockMigrationsOngoing
2318 }
2319
2320 if check_version {
2321 let current_version = T::Version::get();
2322 let Some(new_version) = sp_io::misc::runtime_version(code)
2323 .and_then(|v| RuntimeVersion::decode(&mut &v[..]).ok())
2324 else {
2325 return CanSetCodeResult::InvalidVersion(Error::<T>::FailedToExtractRuntimeVersion)
2326 };
2327
2328 cfg_if::cfg_if! {
2329 if #[cfg(all(feature = "runtime-benchmarks", not(test)))] {
2330 core::hint::black_box((new_version, current_version));
2332 } else {
2333 if new_version.spec_name != current_version.spec_name {
2334 return CanSetCodeResult::InvalidVersion( Error::<T>::InvalidSpecName)
2335 }
2336
2337 if new_version.spec_version <= current_version.spec_version {
2338 return CanSetCodeResult::InvalidVersion(Error::<T>::SpecVersionNeedsToIncrease)
2339 }
2340 }
2341 }
2342 }
2343
2344 CanSetCodeResult::Ok
2345 }
2346
2347 pub fn do_authorize_upgrade(code_hash: T::Hash, check_version: bool) {
2349 AuthorizedUpgrade::<T>::put(CodeUpgradeAuthorization { code_hash, check_version });
2350 Self::deposit_event(Event::UpgradeAuthorized { code_hash, check_version });
2351 }
2352
2353 fn validate_code_is_authorized(
2357 code: &[u8],
2358 ) -> Result<CodeUpgradeAuthorization<T>, DispatchError> {
2359 let authorization = AuthorizedUpgrade::<T>::get().ok_or(Error::<T>::NothingAuthorized)?;
2360 let actual_hash = T::Hashing::hash(code);
2361 ensure!(actual_hash == authorization.code_hash, Error::<T>::Unauthorized);
2362 Ok(authorization)
2363 }
2364
2365 pub fn reclaim_weight(
2370 info: &DispatchInfoOf<T::RuntimeCall>,
2371 post_info: &PostDispatchInfoOf<T::RuntimeCall>,
2372 ) -> Result<(), TransactionValidityError>
2373 where
2374 T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
2375 {
2376 let already_reclaimed = crate::ExtrinsicWeightReclaimed::<T>::get();
2377 let unspent = post_info.calc_unspent(info);
2378 let accurate_reclaim = already_reclaimed.max(unspent);
2379 let to_reclaim_more = accurate_reclaim.saturating_sub(already_reclaimed);
2381 if to_reclaim_more != Weight::zero() {
2382 crate::BlockWeight::<T>::mutate(|current_weight| {
2383 current_weight.reduce(to_reclaim_more, info.class);
2384 });
2385 crate::ExtrinsicWeightReclaimed::<T>::put(accurate_reclaim);
2386 }
2387
2388 Ok(())
2389 }
2390}
2391
2392pub fn unique(entropy: impl Encode) -> [u8; 32] {
2395 let mut last = [0u8; 32];
2396 sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut last[..], 0);
2397 let next = (b"frame_system::unique", entropy, last).using_encoded(blake2_256);
2398 sp_io::storage::set(well_known_keys::INTRABLOCK_ENTROPY, &next);
2399 next
2400}
2401
2402pub struct Provider<T>(PhantomData<T>);
2404impl<T: Config> HandleLifetime<T::AccountId> for Provider<T> {
2405 fn created(t: &T::AccountId) -> Result<(), DispatchError> {
2406 Pallet::<T>::inc_providers(t);
2407 Ok(())
2408 }
2409 fn killed(t: &T::AccountId) -> Result<(), DispatchError> {
2410 Pallet::<T>::dec_providers(t).map(|_| ())
2411 }
2412}
2413
2414pub struct SelfSufficient<T>(PhantomData<T>);
2416impl<T: Config> HandleLifetime<T::AccountId> for SelfSufficient<T> {
2417 fn created(t: &T::AccountId) -> Result<(), DispatchError> {
2418 Pallet::<T>::inc_sufficients(t);
2419 Ok(())
2420 }
2421 fn killed(t: &T::AccountId) -> Result<(), DispatchError> {
2422 Pallet::<T>::dec_sufficients(t);
2423 Ok(())
2424 }
2425}
2426
2427pub struct Consumer<T>(PhantomData<T>);
2429impl<T: Config> HandleLifetime<T::AccountId> for Consumer<T> {
2430 fn created(t: &T::AccountId) -> Result<(), DispatchError> {
2431 Pallet::<T>::inc_consumers(t)
2432 }
2433 fn killed(t: &T::AccountId) -> Result<(), DispatchError> {
2434 Pallet::<T>::dec_consumers(t);
2435 Ok(())
2436 }
2437}
2438
2439impl<T: Config> BlockNumberProvider for Pallet<T> {
2440 type BlockNumber = BlockNumberFor<T>;
2441
2442 fn current_block_number() -> Self::BlockNumber {
2443 Pallet::<T>::block_number()
2444 }
2445
2446 #[cfg(feature = "runtime-benchmarks")]
2447 fn set_block_number(n: BlockNumberFor<T>) {
2448 Self::set_block_number(n)
2449 }
2450}
2451
2452impl<T: Config> StoredMap<T::AccountId, T::AccountData> for Pallet<T> {
2458 fn get(k: &T::AccountId) -> T::AccountData {
2459 Account::<T>::get(k).data
2460 }
2461
2462 fn try_mutate_exists<R, E: From<DispatchError>>(
2463 k: &T::AccountId,
2464 f: impl FnOnce(&mut Option<T::AccountData>) -> Result<R, E>,
2465 ) -> Result<R, E> {
2466 let account = Account::<T>::get(k);
2467 let is_default = account.data == T::AccountData::default();
2468 let mut some_data = if is_default { None } else { Some(account.data) };
2469 let result = f(&mut some_data)?;
2470 if Self::providers(k) > 0 || Self::sufficients(k) > 0 {
2471 Account::<T>::mutate(k, |a| a.data = some_data.unwrap_or_default());
2472 } else {
2473 Account::<T>::remove(k)
2474 }
2475 Ok(result)
2476 }
2477}
2478
2479pub fn split_inner<T, R, S>(
2481 option: Option<T>,
2482 splitter: impl FnOnce(T) -> (R, S),
2483) -> (Option<R>, Option<S>) {
2484 match option {
2485 Some(inner) => {
2486 let (r, s) = splitter(inner);
2487 (Some(r), Some(s))
2488 },
2489 None => (None, None),
2490 }
2491}
2492
2493pub struct ChainContext<T>(PhantomData<T>);
2494impl<T> Default for ChainContext<T> {
2495 fn default() -> Self {
2496 ChainContext(PhantomData)
2497 }
2498}
2499
2500impl<T: Config> Lookup for ChainContext<T> {
2501 type Source = <T::Lookup as StaticLookup>::Source;
2502 type Target = <T::Lookup as StaticLookup>::Target;
2503
2504 fn lookup(&self, s: Self::Source) -> Result<Self::Target, LookupError> {
2505 <T::Lookup as StaticLookup>::lookup(s)
2506 }
2507}
2508
2509#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2511pub struct RunToBlockHooks<'a, T>
2512where
2513 T: 'a + Config,
2514{
2515 before_initialize: Box<dyn 'a + FnMut(BlockNumberFor<T>)>,
2516 after_initialize: Box<dyn 'a + FnMut(BlockNumberFor<T>)>,
2517 before_finalize: Box<dyn 'a + FnMut(BlockNumberFor<T>)>,
2518 after_finalize: Box<dyn 'a + FnMut(BlockNumberFor<T>)>,
2519}
2520
2521#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2522impl<'a, T> RunToBlockHooks<'a, T>
2523where
2524 T: 'a + Config,
2525{
2526 pub fn before_initialize<F>(mut self, f: F) -> Self
2528 where
2529 F: 'a + FnMut(BlockNumberFor<T>),
2530 {
2531 self.before_initialize = Box::new(f);
2532 self
2533 }
2534 pub fn after_initialize<F>(mut self, f: F) -> Self
2536 where
2537 F: 'a + FnMut(BlockNumberFor<T>),
2538 {
2539 self.after_initialize = Box::new(f);
2540 self
2541 }
2542 pub fn before_finalize<F>(mut self, f: F) -> Self
2544 where
2545 F: 'a + FnMut(BlockNumberFor<T>),
2546 {
2547 self.before_finalize = Box::new(f);
2548 self
2549 }
2550 pub fn after_finalize<F>(mut self, f: F) -> Self
2552 where
2553 F: 'a + FnMut(BlockNumberFor<T>),
2554 {
2555 self.after_finalize = Box::new(f);
2556 self
2557 }
2558}
2559
2560#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
2561impl<'a, T> Default for RunToBlockHooks<'a, T>
2562where
2563 T: Config,
2564{
2565 fn default() -> Self {
2566 Self {
2567 before_initialize: Box::new(|_| {}),
2568 after_initialize: Box::new(|_| {}),
2569 before_finalize: Box::new(|_| {}),
2570 after_finalize: Box::new(|_| {}),
2571 }
2572 }
2573}
2574
2575pub mod pallet_prelude {
2577 pub use crate::{
2578 ensure_authorized, ensure_none, ensure_root, ensure_signed, ensure_signed_or_root,
2579 };
2580
2581 pub type OriginFor<T> = <T as crate::Config>::RuntimeOrigin;
2583
2584 pub type HeaderFor<T> =
2586 <<T as crate::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;
2587
2588 pub type BlockNumberFor<T> = <HeaderFor<T> as sp_runtime::traits::Header>::Number;
2590
2591 pub type ExtrinsicFor<T> =
2593 <<T as crate::Config>::Block as sp_runtime::traits::Block>::Extrinsic;
2594
2595 pub type RuntimeCallFor<T> = <T as crate::Config>::RuntimeCall;
2597
2598 pub type AccountIdFor<T> = <T as crate::Config>::AccountId;
2600}