Newer
Older
// This file is part of Substrate.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! # System Pallet
//! The System pallet provides low-level access to core types and cross-cutting utilities. It acts
//! as the base layer for other pallets to interact with the Substrate framework components.
//! The System pallet defines the core data types used in a Substrate runtime. It also provides
//! several utility functions (see [`Pallet`]) for other FRAME pallets.
//! In addition, it manages the storage items for extrinsic data, indices, event records, and digest
//! items, among other things that support the execution of the current block.
//! It also handles low-level tasks like depositing logs, basic set up and take down of temporary
//! storage entries, and access to previous block hashes.
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
//! The System pallet provides dispatchable functions that, with the exception of `remark`, manage
//! low-level or privileged functionality of a Substrate-based runtime.
//!
//! - `remark`: Make some on-chain remark.
//! - `set_heap_pages`: Set the number of pages in the WebAssembly environment's heap.
//! - `set_code`: Set the new runtime code.
//! - `set_code_without_checks`: Set the new runtime code without any checks.
//! - `set_storage`: Set some items of storage.
//! - `kill_storage`: Kill some items from storage.
//! - `kill_prefix`: Kill all storage items with a key that starts with the given prefix.
//! - `remark_with_event`: Make some on-chain remark and emit an event.
//! - `do_task`: Do some specified task.
//! - `authorize_upgrade`: Authorize new runtime code.
//! - `authorize_upgrade_without_checks`: Authorize new runtime code and an upgrade sans
//! verification.
//! - `apply_authorized_upgrade`: Provide new, already-authorized runtime code.
//!
//! #### A Note on Upgrades
//!
//! The pallet provides two primary means of upgrading the runtime, a single-phase means using
//! `set_code` and a two-phase means using `authorize_upgrade` followed by
//! `apply_authorized_upgrade`. The first will directly attempt to apply the provided `code`
//! (application may have to be scheduled, depending on the context and implementation of the
//! `OnSetCode` trait).
//!
//! The `authorize_upgrade` route allows the authorization of a runtime's code hash. Once
//! authorized, anyone may upload the correct runtime to apply the code. This pattern is useful when
//! providing the runtime ahead of time may be unwieldy, for example when a large preimage (the
//! code) would need to be stored on-chain or sent over a message transport protocol such as a
//! bridge.
//!
//! The `*_without_checks` variants do not perform any version checks, so using them runs the risk
//! of applying a downgrade or entirely other chain specification. They will still validate that the
//! `code` meets the authorized hash.
//! See the [`Pallet`] struct for details of publicly available functions.
//! ### Signed Extensions
//!
//! The System pallet defines the following extensions:
//!
//! - [`CheckWeight`]: Checks the weight and length of the block and ensure that it does not
//! exceed the limits.
//! - [`CheckNonce`]: Checks the nonce of the transaction. Contains a single payload of type
//! - [`CheckEra`]: Checks the era of the transaction. Contains a single payload of type `Era`.
//! - [`CheckGenesis`]: Checks the provided genesis hash of the transaction. Must be a part of the
//! signed payload of the transaction.
//! - [`CheckSpecVersion`]: Checks that the runtime version is the same as the one used to sign
//! the transaction.
//! - [`CheckTxVersion`]: Checks that the transaction version is the same as the one used to sign
//! the transaction.
//!
//! Look up the runtime aggregator file (e.g. `node/runtime`) to see the full list of signed
//! extensions included in a chain.
use pallet_prelude::{BlockNumberFor, HeaderFor};
#[cfg(feature = "std")]
use sp_io::hashing::blake2_256;
#[cfg(feature = "runtime-benchmarks")]
use sp_runtime::traits::TrailingZeroInput;
self, AtLeast32Bit, BadOrigin, BlockNumberProvider, Bounded, CheckEqual, Dispatchable,
Hash, Header, Lookup, LookupError, MaybeDisplay, MaybeSerializeDeserialize, Member, One,
Saturating, SimpleBitOps, StaticLookup, Zero,
transaction_validity::{
InvalidTransaction, TransactionLongevity, TransactionSource, TransactionValidity,
ValidTransaction,
},
#[cfg(any(feature = "std", test))]
use sp_std::map;
use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
use sp_version::RuntimeVersion;
use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
#[cfg(feature = "std")]
use frame_support::traits::BuildGenesisConfig;
dispatch::{
extract_actual_pays_fee, extract_actual_weight, DispatchClass, DispatchInfo,
DispatchResult, DispatchResultWithPostInfo, PerDispatchClass, PostDispatchInfo,
ensure, impl_ensure_origin_with_arg_ignoring_arg,
migrations::MultiStepMigrator,
pallet_prelude::Pays,
storage::{self, StorageStreamIter},
ConstU32, Contains, EnsureOrigin, EnsureOriginWithArg, Get, HandleLifetime,
OnKilledAccount, OnNewAccount, OnRuntimeUpgrade, OriginTrait, PalletInfo, SortedMembers,
StoredMap, TypedGet,
use sp_core::storage::well_known_keys;
use sp_weights::{RuntimeDbWeight, Weight};
use sp_io::TestExternalities;
Svyatoslav Nikolsky
committed
#[cfg(test)]
pub(crate) mod mock;
mod extensions;
#[cfg(feature = "std")]
pub mod mocking;
#[cfg(test)]
mod tests;
pub mod weights;
pub mod migrations;
pub use extensions::{
check_genesis::CheckGenesis, check_mortality::CheckMortality,
check_non_zero_sender::CheckNonZeroSender, check_nonce::CheckNonce,
check_spec_version::CheckSpecVersion, check_tx_version::CheckTxVersion,
Gavin Wood
committed
check_weight::CheckWeight, WeightInfo as ExtensionsWeightInfo,
};
// Backward compatible re-export.
pub use extensions::check_mortality::CheckMortality as CheckEra;
pub use frame_support::dispatch::RawOrigin;
use frame_support::traits::{PostInherents, PostTransactions, PreInherents};
const LOG_TARGET: &str = "runtime::system";
/// Compute the trie root of a list of extrinsics.
///
/// The merkle proof is using the same trie as runtime state with
/// `state_version` 0.
pub fn extrinsics_root<H: Hash, E: codec::Encode>(extrinsics: &[E]) -> H::Output {
extrinsics_data_root::<H>(extrinsics.iter().map(codec::Encode::encode).collect())
/// Compute the trie root of a list of extrinsics.
///
/// The merkle proof is using the same trie as runtime state with
/// `state_version` 0.
pub fn extrinsics_data_root<H: Hash>(xts: Vec<Vec<u8>>) -> H::Output {
H::ordered_trie_root(xts, sp_core::storage::StateVersion::V0)
/// An object to track the currently used extrinsic weight in a block.
pub type ConsumedWeight = PerDispatchClass<Weight>;
pub use pallet::*;
/// Do something when we should be setting the code.
pub trait SetCode<T: Config> {
/// Set the code to the given blob.
fn set_code(code: Vec<u8>) -> DispatchResult;
impl<T: Config> SetCode<T> for () {
fn set_code(code: Vec<u8>) -> DispatchResult {
<Pallet<T>>::update_code_in_storage(&code);
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
/// Numeric limits over the ability to add a consumer ref using `inc_consumers`.
pub trait ConsumerLimits {
/// The number of consumers over which `inc_consumers` will cease to work.
fn max_consumers() -> RefCount;
/// The maximum number of additional consumers expected to be over be added at once using
/// `inc_consumers_without_limit`.
///
/// Note: This is not enforced and it's up to the chain's author to ensure this reflects the
/// actual situation.
fn max_overflow() -> RefCount;
}
impl<const Z: u32> ConsumerLimits for ConstU32<Z> {
fn max_consumers() -> RefCount {
Z
}
fn max_overflow() -> RefCount {
Z
}
}
impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal, MaxOverflow) {
fn max_consumers() -> RefCount {
MaxNormal::get()
}
fn max_overflow() -> RefCount {
MaxOverflow::get()
}
}
/// Information needed when a new runtime binary is submitted and needs to be authorized before
/// replacing the current runtime.
#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
#[scale_info(skip_type_params(T))]
pub struct CodeUpgradeAuthorization<T>
where
T: Config,
{
/// Hash of the new runtime binary.
code_hash: T::Hash,
/// Whether or not to carry out version checks.
check_version: bool,
}
#[frame_support::pallet]
pub mod pallet {
use crate::{self as frame_system, pallet_prelude::*, *};
use frame_support::pallet_prelude::*;
Kian Paimani
committed
/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].
pub mod config_preludes {
gupnik
committed
use super::{inject_runtime_type, DefaultConfig};
use frame_support::derive_impl;
/// Provides a viable default config that can be used with
/// [`derive_impl`](`frame_support::derive_impl`) to derive a testing pallet config
/// based on this one.
///
/// See `Test` in the `default-config` example pallet's `test.rs` for an example of
/// a downstream user of this particular `TestDefaultConfig`
pub struct TestDefaultConfig;
#[frame_support::register_default_impl(TestDefaultConfig)]
impl DefaultConfig for TestDefaultConfig {
type Hash = sp_core::hash::H256;
type Hashing = sp_runtime::traits::BlakeTwo256;
type AccountId = u64;
type Lookup = sp_runtime::traits::IdentityLookup<u64>;
type MaxConsumers = frame_support::traits::ConstU32<16>;
type AccountData = ();
type OnNewAccount = ();
type OnKilledAccount = ();
type SystemWeightInfo = ();
Gavin Wood
committed
type ExtensionsWeightInfo = ();
type SS58Prefix = ();
type Version = ();
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
gupnik
committed
#[inject_runtime_type]
type RuntimeEvent = ();
#[inject_runtime_type]
type RuntimeOrigin = ();
#[inject_runtime_type]
type RuntimeCall = ();
#[inject_runtime_type]
type PalletInfo = ();
#[inject_runtime_type]
type RuntimeTask = ();
gupnik
committed
type BaseCallFilter = frame_support::traits::Everything;
type BlockHashCount = frame_support::traits::ConstU64<10>;
type OnSetCode = ();
type SingleBlockMigrations = ();
type MultiBlockMigrator = ();
type PreInherents = ();
type PostInherents = ();
type PostTransactions = ();
/// Default configurations of this pallet in a solochain environment.
///
/// ## Considerations:
///
/// By default, this type makes the following choices:
///
/// * Use a normal 32 byte account id, with a [`DefaultConfig::Lookup`] that implies no
/// 'account-indexing' pallet is being used.
/// * Given that we don't know anything about the existence of a currency system in scope,
/// an [`DefaultConfig::AccountData`] is chosen that has no addition data. Overwrite this
/// if you use `pallet-balances` or similar.
/// * Make sure to overwrite [`DefaultConfig::Version`].
/// * 2s block time, and a default 5mb block size is used.
pub struct SolochainDefaultConfig;
#[frame_support::register_default_impl(SolochainDefaultConfig)]
impl DefaultConfig for SolochainDefaultConfig {
/// The default type for storing how many extrinsics an account has signed.
/// The default type for hashing blocks and tries.
/// The default hashing algorithm used.
type Hashing = sp_runtime::traits::BlakeTwo256;
/// The default identifier used to distinguish between accounts.
type AccountId = sp_runtime::AccountId32;
/// The lookup mechanism to get account ID from whatever is passed in dispatchers.
type Lookup = sp_runtime::traits::AccountIdLookup<Self::AccountId, ()>;
/// The maximum number of consumers allowed on a single account. Using 128 as default.
type MaxConsumers = frame_support::traits::ConstU32<128>;
/// The default data to be stored in an account.
type AccountData = crate::AccountInfo<Self::Nonce, ()>;
/// What to do if a new account is created.
/// What to do if an account is fully reaped from the system.
/// Weight information for the extrinsics of this pallet.
Gavin Wood
committed
/// Weight information for the extensions of this pallet.
type ExtensionsWeightInfo = ();
/// This is used as an identifier of the chain.
/// Version of the runtime.
/// Block & extrinsics weights: base values and limits.
/// The maximum length of a block (in bytes).
/// The weight of database operations that the runtime can invoke.
/// The ubiquitous event type injected by `construct_runtime!`.
#[inject_runtime_type]
type RuntimeEvent = ();
/// The ubiquitous origin type injected by `construct_runtime!`.
#[inject_runtime_type]
type RuntimeOrigin = ();
/// The aggregated dispatch type available for extrinsics, injected by
/// `construct_runtime!`.
#[inject_runtime_type]
type RuntimeCall = ();
/// The aggregated Task type, injected by `construct_runtime!`.
type RuntimeTask = ();
/// Converts a module to the index of the module, injected by `construct_runtime!`.
#[inject_runtime_type]
/// The basic call filter to use in dispatchable. Supports everything as the default.
type BaseCallFilter = frame_support::traits::Everything;
/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
/// Using 256 as default.
type BlockHashCount = frame_support::traits::ConstU32<256>;
/// The set code logic, just the default since we're not a parachain.
type SingleBlockMigrations = ();
type MultiBlockMigrator = ();
type PreInherents = ();
type PostInherents = ();
type PostTransactions = ();
/// Default configurations of this pallet in a relay-chain environment.
pub struct RelayChainDefaultConfig;
/// It currently uses the same configuration as `SolochainDefaultConfig`.
#[derive_impl(SolochainDefaultConfig as DefaultConfig, no_aggregated_types)]
#[frame_support::register_default_impl(RelayChainDefaultConfig)]
impl DefaultConfig for RelayChainDefaultConfig {}
/// Default configurations of this pallet in a parachain environment.
pub struct ParaChainDefaultConfig;
/// It currently uses the same configuration as `SolochainDefaultConfig`.
#[derive_impl(SolochainDefaultConfig as DefaultConfig, no_aggregated_types)]
#[frame_support::register_default_impl(ParaChainDefaultConfig)]
impl DefaultConfig for ParaChainDefaultConfig {}
/// System configuration trait. Implemented by runtime.
#[pallet::config(with_default)]
#[pallet::disable_frame_system_supertrait_check]
pub trait Config: 'static + Eq + Clone {
/// The aggregated event type of the runtime.
gupnik
committed
#[pallet::no_default_bounds]
type RuntimeEvent: Parameter
+ Member
+ From<Event<Self>>
+ Debug
+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
/// The basic call filter to use in Origin. All origins are built with this filter as base,
/// except Root.
///
/// This works as a filter for each incoming call. The call needs to pass this filter in
/// order to dispatch. Otherwise it will be rejected with `CallFiltered`. This can be
/// bypassed via `dispatch_bypass_filter` which should only be accessible by root. The
/// filter can be composed of sub-filters by nesting for example
/// [`frame_support::traits::InsideBoth`], [`frame_support::traits::TheseExcept`] or
/// [`frame_support::traits::EverythingBut`] et al. The default would be
/// [`frame_support::traits::Everything`].
gupnik
committed
#[pallet::no_default_bounds]
type BaseCallFilter: Contains<Self::RuntimeCall>;
/// Block & extrinsics weights: base values and limits.
#[pallet::constant]
type BlockWeights: Get<limits::BlockWeights>;
/// The maximum length of a block (in bytes).
#[pallet::constant]
type BlockLength: Get<limits::BlockLength>;
/// The `RuntimeOrigin` type used by dispatchable calls.
gupnik
committed
#[pallet::no_default_bounds]
type RuntimeOrigin: Into<Result<RawOrigin<Self::AccountId>, Self::RuntimeOrigin>>
+ From<RawOrigin<Self::AccountId>>
+ Clone
+ OriginTrait<Call = Self::RuntimeCall, AccountId = Self::AccountId>;
#[docify::export(system_runtime_call)]
/// The aggregated `RuntimeCall` type.
gupnik
committed
#[pallet::no_default_bounds]
type RuntimeCall: Parameter
+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+ Debug
+ From<Call<Self>>;
/// The aggregated `RuntimeTask` type.
#[pallet::no_default_bounds]
type RuntimeTask: Task;
/// This stores the number of previous transactions associated with a sender account.
type Nonce: Parameter
+ Member
+ MaybeSerializeDeserialize
+ Debug
+ Default
+ MaybeDisplay
+ AtLeast32Bit
+ Copy
+ MaxEncodedLen;
/// The output of the `Hashing` function.
type Hash: Parameter
+ Member
+ MaybeSerializeDeserialize
+ Debug
+ MaybeDisplay
+ SimpleBitOps
+ Ord
+ Default
+ Copy
+ CheckEqual
+ sp_std::hash::Hash
+ AsRef<[u8]>
+ AsMut<[u8]>
+ MaxEncodedLen;
/// The hashing system (algorithm) being used in the runtime (e.g. Blake2).
type Hashing: Hash<Output = Self::Hash> + TypeInfo;
/// The user account identifier type for the runtime.
type AccountId: Parameter
+ Member
+ MaybeSerializeDeserialize
+ Debug
+ MaybeDisplay
+ Ord
+ MaxEncodedLen;
/// Converting trait to take a source type and convert to `AccountId`.
///
/// Used to define the type and conversion mechanism for referencing accounts in
/// transactions. It's perfectly reasonable for this to be an identity conversion (with the
/// source type being `AccountId`), but other pallets (e.g. Indices pallet) may provide more
/// functional/efficient alternatives.
type Lookup: StaticLookup<Target = Self::AccountId>;
/// The Block type used by the runtime. This is used by `construct_runtime` to retrieve the
/// extrinsics or other block specific data as needed.
#[pallet::no_default]
type Block: Parameter + Member + traits::Block<Hash = Self::Hash>;
/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
#[pallet::constant]
gupnik
committed
#[pallet::no_default_bounds]
type BlockHashCount: Get<BlockNumberFor<Self>>;
/// The weight of runtime database operations the runtime can invoke.
#[pallet::constant]
type DbWeight: Get<RuntimeDbWeight>;
/// Get the chain's in-code version.
#[pallet::constant]
type Version: Get<RuntimeVersion>;
/// Provides information about the pallet setup in the runtime.
/// Expects the `PalletInfo` type that is being generated by `construct_runtime!` in the
/// runtime.
gupnik
committed
///
/// For tests it is okay to use `()` as type, however it will provide "useless" data.
#[pallet::no_default_bounds]
type PalletInfo: PalletInfo;
/// Data to be associated with an account (other than nonce/transaction counter, which this
/// pallet does regardless).
type AccountData: Member + FullCodec + Clone + Default + TypeInfo + MaxEncodedLen;
/// Handler for when a new account has just been created.
type OnNewAccount: OnNewAccount<Self::AccountId>;
/// A function that is invoked when an account has been determined to be dead.
/// All resources should be cleaned up associated with the given account.
type OnKilledAccount: OnKilledAccount<Self::AccountId>;
Gavin Wood
committed
/// Weight information for the extrinsics of this pallet.
type SystemWeightInfo: WeightInfo;
Gavin Wood
committed
/// Weight information for the transaction extensions of this pallet.
type ExtensionsWeightInfo: extensions::WeightInfo;
/// The designated SS58 prefix of this chain.
///
/// This replaces the "ss58Format" property declared in the chain spec. Reason is
/// that the runtime should know about the prefix in order to make use of it as
/// an identifier of the chain.
#[pallet::constant]
/// What to do if the runtime wants to change the code to something new.
///
/// The default (`()`) implementation is responsible for setting the correct storage
/// entry and emitting corresponding event and log item. (see
/// [`Pallet::update_code_in_storage`]).
/// It's unlikely that this needs to be customized, unless you are writing a parachain using
/// `Cumulus`, where the actual code change is deferred.
gupnik
committed
#[pallet::no_default_bounds]
type OnSetCode: SetCode<Self>;
/// The maximum number of consumers allowed on a single account.
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
/// All migrations that should run in the next runtime upgrade.
///
/// These used to be formerly configured in `Executive`. Parachains need to ensure that
/// running all these migrations in one block will not overflow the weight limit of a block.
/// The migrations are run *before* the pallet `on_runtime_upgrade` hooks, just like the
/// `OnRuntimeUpgrade` migrations.
type SingleBlockMigrations: OnRuntimeUpgrade;
/// The migrator that is used to run Multi-Block-Migrations.
///
/// Can be set to [`pallet-migrations`] or an alternative implementation of the interface.
/// The diagram in `frame_executive::block_flowchart` explains when it runs.
type MultiBlockMigrator: MultiStepMigrator;
/// A callback that executes in *every block* directly before all inherents were applied.
///
/// See `frame_executive::block_flowchart` for a in-depth explanation when it runs.
type PreInherents: PreInherents;
/// A callback that executes in *every block* directly after all inherents were applied.
///
/// See `frame_executive::block_flowchart` for a in-depth explanation when it runs.
type PostInherents: PostInherents;
/// A callback that executes in *every block* directly after all transactions were applied.
///
/// See `frame_executive::block_flowchart` for a in-depth explanation when it runs.
type PostTransactions: PostTransactions;
thiolliere
committed
pub struct Pallet<T>(_);
#[pallet::hooks]
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
#[cfg(feature = "std")]
fn integrity_test() {
T::BlockWeights::get().validate().expect("The weights are invalid.");
#[pallet::call]
impl<T: Config> Pallet<T> {
/// Can be executed by every `origin`.
#[pallet::weight(T::SystemWeightInfo::remark(remark.len() as u32))]
pub fn remark(_origin: OriginFor<T>, remark: Vec<u8>) -> DispatchResultWithPostInfo {
let _ = remark; // No need to check the weight witness.
}
/// Set the number of pages in the WebAssembly environment's heap.
#[pallet::weight((T::SystemWeightInfo::set_heap_pages(), DispatchClass::Operational))]
pub fn set_heap_pages(origin: OriginFor<T>, pages: u64) -> DispatchResultWithPostInfo {
ensure_root(origin)?;
storage::unhashed::put_raw(well_known_keys::HEAP_PAGES, &pages.encode());
Self::deposit_log(generic::DigestItem::RuntimeEnvironmentUpdated);
#[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]
pub fn set_code(origin: OriginFor<T>, code: Vec<u8>) -> DispatchResultWithPostInfo {
ensure_root(origin)?;
Self::can_set_code(&code)?;
T::OnSetCode::set_code(code)?;
// consume the rest of the block to prevent further transactions
Ok(Some(T::BlockWeights::get().max_block).into())
}
/// Set the new runtime code without doing any checks of the given `code`.
///
/// Note that runtime upgrades will not run if this is called with a not-increasing spec
/// version!
#[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]
pub fn set_code_without_checks(
origin: OriginFor<T>,
code: Vec<u8>,
) -> DispatchResultWithPostInfo {
T::OnSetCode::set_code(code)?;
Ok(Some(T::BlockWeights::get().max_block).into())
#[pallet::weight((
T::SystemWeightInfo::set_storage(items.len() as u32),
pub fn set_storage(
origin: OriginFor<T>,
items: Vec<KeyValue>,
) -> DispatchResultWithPostInfo {
ensure_root(origin)?;
for i in &items {
storage::unhashed::put_raw(&i.0, &i.1);
}
#[pallet::weight((
T::SystemWeightInfo::kill_storage(keys.len() as u32),
pub fn kill_storage(origin: OriginFor<T>, keys: Vec<Key>) -> DispatchResultWithPostInfo {
}
/// Kill all storage items with a key that starts with the given prefix.
/// **NOTE:** We rely on the Root origin to provide us the number of subkeys under
/// the prefix we are removing to accurately calculate the weight of this function.
#[pallet::weight((
T::SystemWeightInfo::kill_prefix(subkeys.saturating_add(1)),
pub fn kill_prefix(
origin: OriginFor<T>,
prefix: Key,
) -> DispatchResultWithPostInfo {
let _ = storage::unhashed::clear_prefix(&prefix, Some(subkeys), None);
Ok(().into())
}
/// Make some on-chain remark and emit event.
#[pallet::weight(T::SystemWeightInfo::remark_with_event(remark.len() as u32))]
pub fn remark_with_event(
origin: OriginFor<T>,
remark: Vec<u8>,
) -> DispatchResultWithPostInfo {
let who = ensure_signed(origin)?;
let hash = T::Hashing::hash(&remark[..]);
Self::deposit_event(Event::Remarked { sender: who, hash });
#[cfg(feature = "experimental")]
#[pallet::call_index(8)]
#[pallet::weight(task.weight())]
pub fn do_task(origin: OriginFor<T>, task: T::RuntimeTask) -> DispatchResultWithPostInfo {
ensure_signed(origin)?;
if !task.is_valid() {
return Err(Error::<T>::InvalidTask.into())
}
Self::deposit_event(Event::TaskStarted { task: task.clone() });
if let Err(err) = task.run() {
Self::deposit_event(Event::TaskFailed { task, err });
return Err(Error::<T>::FailedTask.into())
}
// Emit a success event, if your design includes events for this pallet.
Self::deposit_event(Event::TaskCompleted { task });
// Return success.
Ok(().into())
}
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
/// Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
/// later.
///
/// This call requires Root origin.
#[pallet::call_index(9)]
#[pallet::weight((T::SystemWeightInfo::authorize_upgrade(), DispatchClass::Operational))]
pub fn authorize_upgrade(origin: OriginFor<T>, code_hash: T::Hash) -> DispatchResult {
ensure_root(origin)?;
Self::do_authorize_upgrade(code_hash, true);
Ok(())
}
/// Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
/// later.
///
/// WARNING: This authorizes an upgrade that will take place without any safety checks, for
/// example that the spec name remains the same and that the version number increases. Not
/// recommended for normal use. Use `authorize_upgrade` instead.
///
/// This call requires Root origin.
#[pallet::call_index(10)]
#[pallet::weight((T::SystemWeightInfo::authorize_upgrade(), DispatchClass::Operational))]
pub fn authorize_upgrade_without_checks(
origin: OriginFor<T>,
code_hash: T::Hash,
) -> DispatchResult {
ensure_root(origin)?;
Self::do_authorize_upgrade(code_hash, false);
Ok(())
}
/// Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.
///
/// If the authorization required a version check, this call will ensure the spec name
/// remains unchanged and that the spec version has increased.
///
/// Depending on the runtime's `OnSetCode` configuration, this function may directly apply
/// the new `code` in the same block or attempt to schedule the upgrade.
///
/// All origins are allowed.
#[pallet::call_index(11)]
#[pallet::weight((T::SystemWeightInfo::apply_authorized_upgrade(), DispatchClass::Operational))]
pub fn apply_authorized_upgrade(
_: OriginFor<T>,
code: Vec<u8>,
) -> DispatchResultWithPostInfo {
let post = Self::do_apply_authorize_upgrade(code)?;
Ok(post)
}
}
/// Event for the System pallet.
#[pallet::event]
pub enum Event<T: Config> {
/// An extrinsic completed successfully.
ExtrinsicSuccess { dispatch_info: DispatchInfo },
/// An extrinsic failed.
ExtrinsicFailed { dispatch_error: DispatchError, dispatch_info: DispatchInfo },
/// `:code` was updated.
CodeUpdated,
/// A new account was created.
NewAccount { account: T::AccountId },
/// An account was reaped.
KilledAccount { account: T::AccountId },
/// On on-chain remark happened.
Remarked { sender: T::AccountId, hash: T::Hash },
#[cfg(feature = "experimental")]
/// A [`Task`] has started executing
TaskStarted { task: T::RuntimeTask },
#[cfg(feature = "experimental")]
/// A [`Task`] has finished executing.
TaskCompleted { task: T::RuntimeTask },
#[cfg(feature = "experimental")]
/// A [`Task`] failed during execution.
TaskFailed { task: T::RuntimeTask, err: DispatchError },
/// An upgrade was authorized.
UpgradeAuthorized { code_hash: T::Hash, check_version: bool },
}
/// Error for the System pallet
#[pallet::error]
pub enum Error<T> {
/// The name of specification does not match between the current runtime
/// and the new runtime.
InvalidSpecName,
/// The specification version is not allowed to decrease between the current runtime
/// and the new runtime.
SpecVersionNeedsToIncrease,
/// Failed to extract the runtime version from the new runtime.
///
/// Either calling `Core_version` or decoding `RuntimeVersion` failed.
FailedToExtractRuntimeVersion,
/// Suicide called when the account has non-default composite data.
NonDefaultComposite,
/// There is a non-zero reference count preventing the account from being purged.
NonZeroRefCount,
/// The origin filter prevent the call to be dispatched.
CallFiltered,
/// A multi-block migration is ongoing and prevents the current code from being replaced.
MultiBlockMigrationsOngoing,
#[cfg(feature = "experimental")]
/// The specified [`Task`] is not valid.
InvalidTask,
#[cfg(feature = "experimental")]
/// The specified [`Task`] failed during execution.
FailedTask,
/// No upgrade authorized.
NothingAuthorized,
/// The submitted code is not authorized.
Unauthorized,
}
/// Exposed trait-generic origin type.
#[pallet::origin]
pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
/// The full account information for a particular account ID.
#[pallet::storage]
#[pallet::getter(fn account)]
pub type Account<T: Config> = StorageMap<
_,
Blake2_128Concat,
T::AccountId,
AccountInfo<T::Nonce, T::AccountData>,
ValueQuery,
>;
/// Total extrinsics count for the current block.
#[pallet::storage]
pub(super) type ExtrinsicCount<T: Config> = StorageValue<_, u32>;
/// Whether all inherents have been applied.
#[pallet::storage]
pub type InherentsApplied<T: Config> = StorageValue<_, bool, ValueQuery>;
/// The current weight for the block.
#[pallet::storage]
#[pallet::whitelist_storage]
#[pallet::getter(fn block_weight)]
pub type BlockWeight<T: Config> = StorageValue<_, ConsumedWeight, ValueQuery>;
/// Total length (in bytes) for all extrinsics put together, for the current block.
#[pallet::storage]
pub(super) type AllExtrinsicsLen<T: Config> = StorageValue<_, u32>;
/// Map of block numbers to block hashes.
#[pallet::storage]
#[pallet::getter(fn block_hash)]
pub type BlockHash<T: Config> =
StorageMap<_, Twox64Concat, BlockNumberFor<T>, T::Hash, ValueQuery>;
/// Extrinsics data for the current block (maps an extrinsic's index to its data).
#[pallet::storage]
#[pallet::getter(fn extrinsic_data)]
#[pallet::unbounded]
pub(super) type ExtrinsicData<T: Config> =
StorageMap<_, Twox64Concat, u32, Vec<u8>, ValueQuery>;
/// The current block number being processed. Set by `execute_block`.
#[pallet::storage]
#[pallet::whitelist_storage]
#[pallet::getter(fn block_number)]
pub(super) type Number<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
/// Hash of the previous block.
#[pallet::storage]
#[pallet::getter(fn parent_hash)]
pub(super) type ParentHash<T: Config> = StorageValue<_, T::Hash, ValueQuery>;
/// Digest of the current block, also part of the block header.
#[pallet::storage]
#[pallet::unbounded]
#[pallet::getter(fn digest)]
pub(super) type Digest<T: Config> = StorageValue<_, generic::Digest, ValueQuery>;
/// Events deposited for the current block.
/// NOTE: The item is unbound and should therefore never be read on chain.
/// It could otherwise inflate the PoV size of a block.
///
/// Events have a large in-memory size. Box the events to not go out-of-memory
/// just in case someone still reads them from within the runtime.
#[pallet::storage]
#[pallet::whitelist_storage]
#[pallet::disable_try_decode_storage]
#[pallet::unbounded]
pub(super) type Events<T: Config> =
StorageValue<_, Vec<Box<EventRecord<T::RuntimeEvent, T::Hash>>>, ValueQuery>;
/// The number of events in the `Events<T>` list.
#[pallet::storage]
#[pallet::whitelist_storage]
#[pallet::getter(fn event_count)]
pub(super) type EventCount<T: Config> = StorageValue<_, EventIndex, ValueQuery>;
/// Mapping between a topic (represented by T::Hash) and a vector of indexes
/// of events in the `<Events<T>>` list.
///
/// All topic vectors have deterministic storage locations depending on the topic. This
/// allows light-clients to leverage the changes trie storage tracking mechanism and
/// in case of changes fetch the list of events of interest.
///
/// The value has the type `(BlockNumberFor<T>, EventIndex)` because if we used only just
/// the `EventIndex` then in case if the topic has the same contents on the next block
/// no notification will be triggered thus the event might be lost.
#[pallet::storage]
#[pallet::unbounded]
#[pallet::getter(fn event_topics)]
pub(super) type EventTopics<T: Config> =
StorageMap<_, Blake2_128Concat, T::Hash, Vec<(BlockNumberFor<T>, EventIndex)>, ValueQuery>;
/// Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
#[pallet::storage]
#[pallet::unbounded]
pub type LastRuntimeUpgrade<T: Config> = StorageValue<_, LastRuntimeUpgradeInfo>;
/// True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
#[pallet::storage]
pub(super) type UpgradedToU32RefCount<T: Config> = StorageValue<_, bool, ValueQuery>;
/// True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
/// (default) if not.
#[pallet::storage]
pub(super) type UpgradedToTripleRefCount<T: Config> = StorageValue<_, bool, ValueQuery>;
/// The execution phase of the block.
#[pallet::storage]
#[pallet::whitelist_storage]
pub(super) type ExecutionPhase<T: Config> = StorageValue<_, Phase>;