// 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.

//!

//! - [`Config`]

//!

//! ## Overview

//!

//! 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.

//!

//! ## Interface

//!

//! ### Dispatchable Functions

//!

//! 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.

//!

//! ### Public Functions

//!

//! 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

//!     `T::Nonce`.

//!   - [`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.

#![cfg_attr(not(feature = "std"), no_std)]

extern crate alloc;

use alloc::{boxed::Box, vec, vec::Vec};

use core::{fmt::Debug, marker::PhantomData};

use pallet_prelude::{BlockNumberFor, HeaderFor};

#[cfg(feature = "std")]

use serde::Serialize;

use sp_io::hashing::blake2_256;

#[cfg(feature = "runtime-benchmarks")]

use sp_runtime::traits::TrailingZeroInput;

use sp_runtime::{

	generic,

	traits::{

		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,

	},

	DispatchError, RuntimeDebug,

};

#[cfg(any(feature = "std", test))]

use sp_std::map;

use sp_version::RuntimeVersion;

use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};

#[cfg(feature = "std")]

use frame_support::traits::BuildGenesisConfig;

use frame_support::{

	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},

	traits::{

		ConstU32, Contains, EnsureOrigin, EnsureOriginWithArg, Get, HandleLifetime,

		OnKilledAccount, OnNewAccount, OnRuntimeUpgrade, OriginTrait, PalletInfo, SortedMembers,

		StoredMap, TypedGet,

	},

	Parameter,

};

use scale_info::TypeInfo;

use sp_core::storage::well_known_keys;

use sp_weights::{RuntimeDbWeight, Weight};

#[cfg(any(feature = "std", test))]

use sp_io::TestExternalities;

pub mod limits;

#[cfg(test)]

pub(crate) mod mock;

pub mod offchain;

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,

	check_weight::CheckWeight,

};

// 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};

pub use weights::WeightInfo;

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.

/// Compute the trie root of a list of extrinsics.

///

/// The merkle proof is using the same trie as runtime state with

/// `state_version` 0.

/// 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 () {

}

/// 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> {

}

impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal, MaxOverflow) {

}

/// Information needed when a new runtime binary is submitted and needs to be authorized before

/// replacing the current runtime.

#[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,

}

pub mod pallet {

	use crate::{self as frame_system, pallet_prelude::*, *};

	use frame_support::pallet_prelude::*;

	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].

	pub mod config_preludes {

		use super::{inject_runtime_type, DefaultConfig};

		use frame_support::{derive_impl, traits::Get};

		/// A predefined adapter that covers `BlockNumberFor<T>` for `Config::Block::BlockNumber` of

		/// the types `u32`, `u64`, and `u128`.

		///

		/// NOTE: Avoids overriding `BlockHashCount` when using `mocking::{MockBlock, MockBlockU32,

		/// MockBlockU128}`.

		pub struct TestBlockHashCount<C: Get<u32>>(core::marker::PhantomData<C>);

		impl<I: From<u32>, C: Get<u32>> Get<I> for TestBlockHashCount<C> {

		}

		/// 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 Nonce = u32;

			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 = ();

			type SS58Prefix = ();

			type Version = ();

			type BlockWeights = ();

			type BlockLength = ();

			type DbWeight = ();

			#[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 = ();

			type BaseCallFilter = frame_support::traits::Everything;

			type BlockHashCount = TestBlockHashCount<frame_support::traits::ConstU32<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.

			type Nonce = u32;

			/// The default type for hashing blocks and tries.

			type Hash = sp_core::hash::H256;

			/// 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.

			type OnNewAccount = ();

			/// What to do if an account is fully reaped from the system.

			type OnKilledAccount = ();

			/// Weight information for the extrinsics of this pallet.

			type SystemWeightInfo = ();

			/// This is used as an identifier of the chain.

			type SS58Prefix = ();

			/// Version of the runtime.

			type Version = ();

			/// Block & extrinsics weights: base values and limits.

			type BlockWeights = ();

			/// The maximum length of a block (in bytes).

			type BlockLength = ();

			/// The weight of database operations that the runtime can invoke.

			type DbWeight = ();

			/// 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!`.

			#[inject_runtime_type]

			type RuntimeTask = ();

			/// Converts a module to the index of the module, injected by `construct_runtime!`.

			#[inject_runtime_type]

			type PalletInfo = ();

			/// 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 = TestBlockHashCount<frame_support::traits::ConstU32<256>>;

			/// The set code logic, just the default since we're not a parachain.

			type OnSetCode = ();

			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.

		#[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`].

		#[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.

		#[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.

		#[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

			+ core::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]

		#[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.

		///

		/// 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>;

		type SystemWeightInfo: 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]

		type SS58Prefix: Get<u16>;

		/// 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.

		#[pallet::no_default_bounds]

		type OnSetCode: SetCode<Self>;

		/// The maximum number of consumers allowed on a single account.

		type MaxConsumers: ConsumerLimits;

		/// 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;

	}

	pub struct Pallet<T>(_);

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

		#[cfg(feature = "std")]

	}

	impl<T: Config> Pallet<T> {

		/// Make some on-chain remark.

		///

		/// Can be executed by every `origin`.

		#[pallet::call_index(0)]

		#[pallet::weight(T::SystemWeightInfo::remark(remark.len() as u32))]

		}

		/// Set the number of pages in the WebAssembly environment's heap.

		#[pallet::call_index(1)]

		#[pallet::weight((T::SystemWeightInfo::set_heap_pages(), DispatchClass::Operational))]

		}

		/// Set the new runtime code.

		#[pallet::call_index(2)]

		#[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]

			// consume the rest of the block to prevent further transactions

		}

		/// 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::call_index(3)]

		#[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]

		pub fn set_code_without_checks(

			origin: OriginFor<T>,

			code: Vec<u8>,

		}

		/// Set some items of storage.

		#[pallet::call_index(4)]

		#[pallet::weight((

			T::SystemWeightInfo::set_storage(items.len() as u32),

			DispatchClass::Operational,

		))]

		pub fn set_storage(

			origin: OriginFor<T>,

			items: Vec<KeyValue>,

		}

		/// Kill some items from storage.

		#[pallet::call_index(5)]

		#[pallet::weight((

			T::SystemWeightInfo::kill_storage(keys.len() as u32),

			DispatchClass::Operational,

		))]

		}

		/// 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::call_index(6)]

		#[pallet::weight((

			T::SystemWeightInfo::kill_prefix(subkeys.saturating_add(1)),

			DispatchClass::Operational,

		))]

		pub fn kill_prefix(

			origin: OriginFor<T>,

			prefix: Key,

			subkeys: u32,

		}

		/// Make some on-chain remark and emit event.

		#[pallet::call_index(7)]

		#[pallet::weight(T::SystemWeightInfo::remark_with_event(remark.len() as u32))]

		pub fn remark_with_event(

			origin: OriginFor<T>,

			remark: Vec<u8>,

		}

		#[cfg(feature = "experimental")]

		#[pallet::call_index(8)]

		#[pallet::weight(task.weight())]

		pub fn do_task(_origin: OriginFor<T>, task: T::RuntimeTask) -> DispatchResultWithPostInfo {

			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())

		}

		/// 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))]

		}

		/// 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,

		}

		/// 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>,

		}

	}

	/// Event for the System pallet.

	pub enum Event<T: Config> {

		#[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 },

	}

	/// Error for the System pallet

	pub enum Error<T> {

		#[cfg(feature = "experimental")]

		/// The specified [`Task`] is not valid.

		InvalidTask,

		#[cfg(feature = "experimental")]

		/// The specified [`Task`] failed during execution.

		FailedTask,

	}

	/// 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::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.

	pub(super) type ExtrinsicCount<T: Config> = StorageValue<_, u32>;

	/// Whether all inherents have been applied.

	pub type InherentsApplied<T: Config> = StorageValue<_, bool, ValueQuery>;

	/// The current weight for the block.

	#[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.

	pub(super) type AllExtrinsicsLen<T: Config> = StorageValue<_, u32>;

	/// Map of block numbers to block hashes.

	#[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::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::whitelist_storage]

	#[pallet::getter(fn block_number)]

	pub(super) type Number<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;

	/// Hash of the previous block.

	#[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::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::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::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::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::unbounded]

	pub type LastRuntimeUpgrade<T: Config> = StorageValue<_, LastRuntimeUpgradeInfo>;

	/// True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.

	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.

	pub(super) type UpgradedToTripleRefCount<T: Config> = StorageValue<_, bool, ValueQuery>;

	/// The execution phase of the block.

	#[pallet::whitelist_storage]

	pub(super) type ExecutionPhase<T: Config> = StorageValue<_, Phase>;

	/// `Some` if a code upgrade has been authorized.

	#[pallet::getter(fn authorized_upgrade)]

	pub(super) type AuthorizedUpgrade<T: Config> =

		StorageValue<_, CodeUpgradeAuthorization<T>, OptionQuery>;

	#[derive(frame_support::DefaultNoBound)]

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		#[serde(skip)]

		pub _config: core::marker::PhantomData<T>,

	}

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

	}

	#[pallet::validate_unsigned]

	impl<T: Config> sp_runtime::traits::ValidateUnsigned for Pallet<T> {

		type Call = Call<T>;

			#[cfg(feature = "experimental")]

			if let Call::do_task { ref task } = call {

				if task.is_valid() {

					return Ok(ValidTransaction {

						priority: u64::max_value(),

						requires: Vec::new(),

						provides: vec![T::Hashing::hash_of(&task.encode()).as_ref().to_vec()],

						longevity: TransactionLongevity::max_value(),

						propagate: true,

					})

				}

			}

	}

}

pub type Key = Vec<u8>;

pub type KeyValue = (Vec<u8>, Vec<u8>);

/// A phase of a block's execution.

#[cfg_attr(feature = "std", derive(Serialize, PartialEq, Eq, Clone))]

pub enum Phase {

}

impl Default for Phase {

}

/// Record of an event happening.

#[cfg_attr(feature = "std", derive(Serialize, PartialEq, Eq, Clone))]

pub struct EventRecord<E: Parameter + Member, T> {

	/// The phase of the block it happened in.

	pub phase: Phase,

	/// The event itself.

	pub event: E,

	/// The list of the topics this event has.

	pub topics: Vec<T>,

}

// Create a Hash with 69 for each byte,

// only used to build genesis config.

/// This type alias represents an index of an event.

///

/// We use `u32` here because this index is used as index for `Events<T>`

/// which can't contain more than `u32::MAX` items.

type EventIndex = u32;

/// Type used to encode the number of references an account has.

pub type RefCount = u32;

/// Information of an account.

pub struct AccountInfo<Nonce, AccountData> {

	/// The number of transactions this account has sent.

	pub nonce: Nonce,

	/// The number of other modules that currently depend on this account's existence. The account

	/// cannot be reaped until this is zero.

	pub consumers: RefCount,

	/// The number of other modules that allow this account to exist. The account may not be reaped

	/// until this and `sufficients` are both zero.

	pub providers: RefCount,

	/// The number of modules that allow this account to exist for their own purposes only. The

	/// account may not be reaped until this and `providers` are both zero.

	pub sufficients: RefCount,

	/// The additional data that belongs to this account. Used to store the balance(s) in a lot of

	/// chains.

	pub data: AccountData,

}

/// Stores the `spec_version` and `spec_name` of when the last runtime upgrade

/// happened.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct LastRuntimeUpgradeInfo {

	pub spec_version: codec::Compact<u32>,

	pub spec_name: sp_runtime::RuntimeString,

}

impl LastRuntimeUpgradeInfo {

	/// Returns if the runtime was upgraded in comparison of `self` and `current`.

	///

	/// Checks if either the `spec_version` increased or the `spec_name` changed.

}

impl From<sp_version::RuntimeVersion> for LastRuntimeUpgradeInfo {

}

/// Ensure the origin is Root.

pub struct EnsureRoot<AccountId>(core::marker::PhantomData<AccountId>);

impl<O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>, AccountId>

	EnsureOrigin<O> for EnsureRoot<AccountId>

{

	type Success = ();

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		Ok(O::from(RawOrigin::Root))

	}

}

impl_ensure_origin_with_arg_ignoring_arg! {

	impl< { O: .., AccountId: Decode, T } >

		EnsureOriginWithArg<O, T> for EnsureRoot<AccountId>

	{}

}

/// Ensure the origin is Root and return the provided `Success` value.

pub struct EnsureRootWithSuccess<AccountId, Success>(

	core::marker::PhantomData<(AccountId, Success)>,

);

impl<

		O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,

		AccountId,

		Success: TypedGet,

	> EnsureOrigin<O> for EnsureRootWithSuccess<AccountId, Success>

{

	type Success = Success::Type;

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		Ok(O::from(RawOrigin::Root))

	}

}

impl_ensure_origin_with_arg_ignoring_arg! {

	impl< { O: .., AccountId: Decode, Success: TypedGet, T } >

		EnsureOriginWithArg<O, T> for EnsureRootWithSuccess<AccountId, Success>

	{}

}

/// Ensure the origin is provided `Ensure` origin and return the provided `Success` value.

pub struct EnsureWithSuccess<Ensure, AccountId, Success>(

	core::marker::PhantomData<(Ensure, AccountId, Success)>,

);

impl<

		O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,

		Ensure: EnsureOrigin<O>,

		AccountId,

		Success: TypedGet,

	> EnsureOrigin<O> for EnsureWithSuccess<Ensure, AccountId, Success>

{

	type Success = Success::Type;

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		Ensure::try_successful_origin()

	}

}

/// Ensure the origin is any `Signed` origin.

pub struct EnsureSigned<AccountId>(core::marker::PhantomData<AccountId>);

impl<O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>, AccountId: Decode>

	EnsureOrigin<O> for EnsureSigned<AccountId>

{

	type Success = AccountId;

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		let zero_account_id =

			AccountId::decode(&mut TrailingZeroInput::zeroes()).map_err(|_| ())?;

		Ok(O::from(RawOrigin::Signed(zero_account_id)))

	}

}

impl_ensure_origin_with_arg_ignoring_arg! {

	impl< { O: .., AccountId: Decode, T } >

		EnsureOriginWithArg<O, T> for EnsureSigned<AccountId>

	{}

}

/// Ensure the origin is `Signed` origin from the given `AccountId`.

pub struct EnsureSignedBy<Who, AccountId>(core::marker::PhantomData<(Who, AccountId)>);

impl<

		O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,

		Who: SortedMembers<AccountId>,

		AccountId: PartialEq + Clone + Ord + Decode,

	> EnsureOrigin<O> for EnsureSignedBy<Who, AccountId>

{

	type Success = AccountId;

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		let first_member = match Who::sorted_members().first() {

			Some(account) => account.clone(),

			None => AccountId::decode(&mut TrailingZeroInput::zeroes()).map_err(|_| ())?,

		};

		Ok(O::from(RawOrigin::Signed(first_member)))

	}

}

impl_ensure_origin_with_arg_ignoring_arg! {

	impl< { O: .., Who: SortedMembers<AccountId>, AccountId: PartialEq + Clone + Ord + Decode, T } >

		EnsureOriginWithArg<O, T> for EnsureSignedBy<Who, AccountId>

	{}

}

/// Ensure the origin is `None`. i.e. unsigned transaction.

pub struct EnsureNone<AccountId>(core::marker::PhantomData<AccountId>);

impl<O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>, AccountId>

	EnsureOrigin<O> for EnsureNone<AccountId>

{

	type Success = ();

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		Ok(O::from(RawOrigin::None))

	}

}

impl_ensure_origin_with_arg_ignoring_arg! {

	impl< { O: .., AccountId, T } >

		EnsureOriginWithArg<O, T> for EnsureNone<AccountId>

	{}

}

/// Always fail.

pub struct EnsureNever<Success>(core::marker::PhantomData<Success>);

impl<O, Success> EnsureOrigin<O> for EnsureNever<Success> {

	type Success = Success;

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<O, ()> {

		Err(())

	}