Type Alias System

pub type System = Pallet<Runtime>;

Mandatory system pallet that should always be included in a FRAME runtime.

Aliased Type

struct System(/* private fields */);

Implementations

impl<T> Pallet<T>

where T: Config,

pub fn extrinsic_data<KArg>(k: KArg) -> Vec<u8>

where KArg: EncodeLike<u32>,

An auto-generated getter for ExtrinsicData.

impl<T> Pallet<T>

where T: Config,

pub fn block_number() -> <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number

An auto-generated getter for Number.

impl<T> Pallet<T>

where T: Config,

pub fn parent_hash() -> <T as Config>::Hash

An auto-generated getter for ParentHash.

impl<T> Pallet<T>

where T: Config,

pub fn digest() -> Digest

An auto-generated getter for Digest.

impl<T> Pallet<T>

where T: Config,

pub fn event_count() -> u32

An auto-generated getter for EventCount.

impl<T> Pallet<T>

where T: Config,

pub fn event_topics<KArg>( k: KArg, ) -> Vec<(<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, u32)>

where KArg: EncodeLike<<T as Config>::Hash>,

An auto-generated getter for EventTopics.

impl<T> Pallet<T>

where T: Config,

pub fn authorized_upgrade() -> Option<CodeUpgradeAuthorization<T>>

An auto-generated getter for AuthorizedUpgrade.

impl<T> Pallet<T>

where T: Config,

pub fn last_runtime_upgrade_spec_version() -> u32

Returns the spec_version of the last runtime upgrade.

This function is useful for writing guarded runtime migrations in the runtime. A runtime migration can use the spec_version to ensure that it isn’t applied twice. This works similar as the storage version for pallets.

This functions returns the spec_version of the last runtime upgrade while executing the runtime migrations on_runtime_upgrade function. After all migrations are executed, this will return the spec_version of the current runtime until there is another runtime upgrade.

Example:

#[test]
fn last_runtime_upgrade_spec_version_usage() {
	#[allow(dead_code)]
	struct Migration;

	impl OnRuntimeUpgrade for Migration {
		fn on_runtime_upgrade() -> Weight {
			// Ensure to compare the spec version against some static version to prevent applying
			// the same migration multiple times.
			//
			// `1337` here is the spec version of the runtime running on chain. If there is maybe
			// a runtime upgrade in the pipeline of being applied, you should use the spec version
			// of this upgrade.
			if System::last_runtime_upgrade_spec_version() > 1337 {
				return Weight::zero()
			}

			// Do the migration.
			Weight::zero()
		}
	}
}

pub fn account_exists(who: &<T as Config>::AccountId) -> bool

Returns true if the given account exists.

pub fn update_code_in_storage(code: &[u8])

Write code to the storage and emit related events and digest items.

Note this function almost never should be used directly. It is exposed for OnSetCode implementations that defer actual code being written to the storage (for instance in case of parachains).

pub fn inherents_applied() -> bool

Whether all inherents have been applied.

pub fn note_inherents_applied()

Note that all inherents have been applied.

Should be called immediately after all inherents have been applied. Must be called at least once per block.

pub fn inc_ref(who: &<T as Config>::AccountId)

👎Deprecated: Use inc_consumers instead

Increment the reference counter on an account.

pub fn dec_ref(who: &<T as Config>::AccountId)

👎Deprecated: Use dec_consumers instead

Decrement the reference counter on an account. This MUST only be done once for every time you called inc_consumers on who.

pub fn refs(who: &<T as Config>::AccountId) -> u32

👎Deprecated: Use consumers instead

The number of outstanding references for the account who.

pub fn allow_death(who: &<T as Config>::AccountId) -> bool

👎Deprecated: Use !is_provider_required instead

True if the account has no outstanding references.

pub fn inc_providers(who: &<T as Config>::AccountId) -> IncRefStatus

Increment the provider reference counter on an account.

pub fn dec_providers( who: &<T as Config>::AccountId, ) -> Result<DecRefStatus, DispatchError>

Decrement the provider reference counter on an account.

This MUST only be done once for every time you called inc_providers on who.

pub fn inc_sufficients(who: &<T as Config>::AccountId) -> IncRefStatus

Increment the self-sufficient reference counter on an account.

pub fn dec_sufficients(who: &<T as Config>::AccountId) -> DecRefStatus

Decrement the sufficients reference counter on an account.

This MUST only be done once for every time you called inc_sufficients on who.

pub fn providers(who: &<T as Config>::AccountId) -> u32

The number of outstanding provider references for the account who.

pub fn sufficients(who: &<T as Config>::AccountId) -> u32

The number of outstanding sufficient references for the account who.

pub fn reference_count(who: &<T as Config>::AccountId) -> u32

The number of outstanding provider and sufficient references for the account who.

pub fn inc_consumers( who: &<T as Config>::AccountId, ) -> Result<(), DispatchError>

Increment the reference counter on an account.

The account who’s providers must be non-zero and the current number of consumers must be less than MaxConsumers::max_consumers() or this will return an error.

pub fn inc_consumers_without_limit( who: &<T as Config>::AccountId, ) -> Result<(), DispatchError>

Increment the reference counter on an account, ignoring the MaxConsumers limits.

The account who’s providers must be non-zero or this will return an error.

pub fn dec_consumers(who: &<T as Config>::AccountId)

Decrement the reference counter on an account. This MUST only be done once for every time you called inc_consumers on who.

pub fn consumers(who: &<T as Config>::AccountId) -> u32

The number of outstanding references for the account who.

pub fn is_provider_required(who: &<T as Config>::AccountId) -> bool

True if the account has some outstanding consumer references.

pub fn can_dec_provider(who: &<T as Config>::AccountId) -> bool

True if the account has no outstanding consumer references or more than one provider.

pub fn can_accrue_consumers(who: &<T as Config>::AccountId, amount: u32) -> bool

True if the account has at least one provider reference and adding amount consumer references would not take it above the the maximum.

pub fn can_inc_consumer(who: &<T as Config>::AccountId) -> bool

True if the account has at least one provider reference and fewer consumer references than the maximum.

pub fn deposit_event(event: impl Into<<T as Config>::RuntimeEvent>)

Deposits an event into this block’s event record.

NOTE: Events not registered at the genesis block and quietly omitted.

pub fn deposit_event_indexed( topics: &[<T as Config>::Hash], event: <T as Config>::RuntimeEvent, )

Deposits an event into this block’s event record adding this event to the corresponding topic indexes.

This will update storage entries that correspond to the specified topics. It is expected that light-clients could subscribe to this topics.

NOTE: Events not registered at the genesis block and quietly omitted.

pub fn extrinsic_index() -> Option<u32>

Gets the index of extrinsic that is currently executing.

pub fn extrinsic_count() -> u32

Gets extrinsics count.

pub fn all_extrinsics_len() -> u32

pub fn register_extra_weight_unchecked(weight: Weight, class: DispatchClass)

Inform the system pallet of some additional weight that should be accounted for, in the current block.

NOTE: use with extra care; this function is made public only be used for certain pallets that need it. A runtime that does not have dynamic calls should never need this and should stick to static weights. A typical use case for this is inner calls or smart contract calls. Furthermore, it only makes sense to use this when it is presumably cheap to provide the argument weight; In other words, if this function is to be used to account for some unknown, user provided call’s weight, it would only make sense to use it if you are sure you can rapidly compute the weight of the inner call.

Even more dangerous is to note that this function does NOT take any action, if the new sum of block weight is more than the block weight limit. This is what the unchecked.

Another potential use-case could be for the on_initialize and on_finalize hooks.

pub fn initialize( number: &<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, parent_hash: &<T as Config>::Hash, digest: &Digest, )

Start the execution of a particular block.

pub fn finalize() -> <<T as Config>::Block as HeaderProvider>::HeaderT

Remove temporary “environment” entries in storage, compute the storage root and return the resulting header for this block.

pub fn deposit_log(item: DigestItem)

Deposits a log and ensures it matches the block’s log data.

pub fn externalities() -> TestExternalities<Blake2Hasher>

Get the basic externalities for this pallet, useful for tests.

pub fn events() -> Vec<EventRecord<<T as Config>::RuntimeEvent, <T as Config>::Hash>>

Get the current events deposited by the runtime.

NOTE: This should only be used in tests. Reading events from the runtime can have a large impact on the PoV size of a block. Users should use alternative and well bounded storage items for any behavior like this.

NOTE: Events not registered at the genesis block and quietly omitted.

pub fn event_no_consensus(index: usize) -> Option<<T as Config>::RuntimeEvent>

Get a single event at specified index.

Should only be called if you know what you are doing and outside of the runtime block execution else it can have a large impact on the PoV size of a block.

pub fn read_events_no_consensus() -> impl Iterator<Item = Box<EventRecord<<T as Config>::RuntimeEvent, <T as Config>::Hash>>>

Get the current events deposited by the runtime.

Should only be called if you know what you are doing and outside of the runtime block execution else it can have a large impact on the PoV size of a block.

pub fn read_events_for_pallet<E>() -> Vec<E>

where <T as Config>::RuntimeEvent: TryInto<E>,

Read and return the events of a specific pallet, as denoted by E.

This is useful for a pallet that wishes to read only the events it has deposited into frame_system using the standard fn deposit_event.

pub fn run_to_block_with<AllPalletsWithSystem>( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, hooks: RunToBlockHooks<'_, T>, )

where AllPalletsWithSystem: OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> + OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>,

Simulate the execution of a block sequence up to a specified height, injecting the provided hooks at each block.

on_finalize is always called before on_initialize with the current block number. on_initalize is always called with the next block number.

These hooks allows custom logic to be executed at each block at specific location. For example, you might use one of them to set a timestamp for each block.

pub fn run_to_block<AllPalletsWithSystem>( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, )

where AllPalletsWithSystem: OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> + OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>,

Simulate the execution of a block sequence up to a specified height.

pub fn set_block_number( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, )

Set the block number to something in particular. Can be used as an alternative to initialize for tests that don’t need to bother with the other environment entries.

pub fn set_extrinsic_index(extrinsic_index: u32)

Sets the index of extrinsic that is currently executing.

pub fn set_parent_hash(n: <T as Config>::Hash)

Set the parent hash number to something in particular. Can be used as an alternative to initialize for tests that don’t need to bother with the other environment entries.

pub fn set_block_consumed_resources(weight: Weight, len: usize)

Set the current block weight. This should only be used in some integration tests.

pub fn reset_events()

Reset events.

This needs to be used in prior calling initialize for each new block to clear events from previous block.

pub fn assert_has_event(event: <T as Config>::RuntimeEvent)

Assert the given event exists.

NOTE: Events not registered at the genesis block and quietly omitted.

pub fn assert_last_event(event: <T as Config>::RuntimeEvent)

Assert the last event equal to the given event.

NOTE: Events not registered at the genesis block and quietly omitted.

pub fn runtime_version() -> RuntimeVersion

Return the chain’s current runtime version.

pub fn account_nonce( who: impl EncodeLike<<T as Config>::AccountId>, ) -> <T as Config>::Nonce

Retrieve the account transaction counter from storage.

pub fn inc_account_nonce(who: impl EncodeLike<<T as Config>::AccountId>)

Increment a particular account’s nonce by 1.

pub fn note_extrinsic(encoded_xt: Vec<u8>)

Note what the extrinsic data of the current extrinsic index is.

This is required to be called before applying an extrinsic. The data will used in Self::finalize to calculate the correct extrinsics root.

pub fn note_applied_extrinsic( r: &Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>, info: DispatchInfo, )

To be called immediately after an extrinsic has been applied.

Emits an ExtrinsicSuccess or ExtrinsicFailed event depending on the outcome. The emitted event contains the post-dispatch corrected weight including the base-weight for its dispatch class.

pub fn note_finished_extrinsics()

To be called immediately after note_applied_extrinsic of the last extrinsic of the block has been called.

pub fn note_finished_initialize()

To be called immediately after finishing the initialization of the block (e.g., called on_initialize for all pallets).

pub fn on_created_account( who: <T as Config>::AccountId, _a: &mut AccountInfo<<T as Config>::Nonce, <T as Config>::AccountData>, )

An account is being created.

pub fn can_set_code(code: &[u8], check_version: bool) -> CanSetCodeResult<T>

Determine whether or not it is possible to update the code.

• check_version: Should the runtime version be checked?

pub fn do_authorize_upgrade(code_hash: <T as Config>::Hash, check_version: bool)

Authorize the given code_hash as upgrade.

pub fn reclaim_weight( info: &<<T as Config>::RuntimeCall as Dispatchable>::Info, post_info: &<<T as Config>::RuntimeCall as Dispatchable>::PostInfo, ) -> Result<(), TransactionValidityError>

where <T as Config>::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

Reclaim the weight for the extrinsic given info and post info.

This function will check the already reclaimed weight, and reclaim more if the difference between pre dispatch and post dispatch weight is higher.

impl<T> Pallet<T>

where T: Config,

pub fn remark( _origin: <T as Config>::RuntimeOrigin, remark: Vec<u8>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Make some on-chain remark.

Can be executed by every origin.

pub fn set_heap_pages( origin: <T as Config>::RuntimeOrigin, pages: u64, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Set the number of pages in the WebAssembly environment’s heap.

pub fn set_code( origin: <T as Config>::RuntimeOrigin, code: Vec<u8>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Set the new runtime code.

pub fn set_code_without_checks( origin: <T as Config>::RuntimeOrigin, code: Vec<u8>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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!

pub fn set_storage( origin: <T as Config>::RuntimeOrigin, items: Vec<(Vec<u8>, Vec<u8>)>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Set some items of storage.

pub fn kill_storage( origin: <T as Config>::RuntimeOrigin, keys: Vec<Vec<u8>>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Kill some items from storage.

pub fn kill_prefix( origin: <T as Config>::RuntimeOrigin, prefix: Vec<u8>, subkeys: u32, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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.

pub fn remark_with_event( origin: <T as Config>::RuntimeOrigin, remark: Vec<u8>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Make some on-chain remark and emit event.

pub fn do_task( _origin: <T as Config>::RuntimeOrigin, task: <T as Config>::RuntimeTask, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

pub fn authorize_upgrade( origin: <T as Config>::RuntimeOrigin, code_hash: <T as Config>::Hash, ) -> Result<(), DispatchError>

Authorize an upgrade to a given code_hash for the runtime. The runtime can be supplied later.

This call requires Root origin.

pub fn authorize_upgrade_without_checks( origin: <T as Config>::RuntimeOrigin, code_hash: <T as Config>::Hash, ) -> Result<(), DispatchError>

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.

pub fn apply_authorized_upgrade( _: <T as Config>::RuntimeOrigin, code: Vec<u8>, ) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

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.

impl<T> Pallet<T>

where T: Config,

pub fn account<KArg>( k: KArg, ) -> AccountInfo<<T as Config>::Nonce, <T as Config>::AccountData>

where KArg: EncodeLike<<T as Config>::AccountId>,

An auto-generated getter for Account.

impl<T> Pallet<T>

where T: Config,

pub fn block_weight() -> PerDispatchClass<Weight>

An auto-generated getter for BlockWeight.

impl<T> Pallet<T>

where T: Config,

pub fn block_hash<KArg>(k: KArg) -> <T as Config>::Hash

where KArg: EncodeLike<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>,

An auto-generated getter for BlockHash.

Trait Implementations

impl<T> BeforeAllRuntimeMigrations for Pallet<T>

where T: Config,

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.

impl<T> BlockNumberProvider for Pallet<T>

where T: Config,

type BlockNumber = <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number

Type of BlockNumber to provide.

fn current_block_number() -> <Pallet<T> as BlockNumberProvider>::BlockNumber

Returns the current block number.

fn set_block_number( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, )

Utility function only to be used in benchmarking scenarios or tests, to be implemented optionally, else a noop.

impl<T> Callable<T> for Pallet<T>

where T: Config,

type RuntimeCall = Call<T>

impl<T> Clone for Pallet<T>

fn clone(&self) -> Pallet<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Pallet<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> DispatchViewFunction for Pallet<T>

where T: Config,

fn dispatch_view_function<O>( id: &ViewFunctionId, input: &mut &[u8], output: &mut O, ) -> Result<(), ViewFunctionDispatchError>

where O: Output,

impl<T> GetStorageVersion for Pallet<T>

where T: Config,

type InCodeStorageVersion = NoStorageVersionSet

This type is generated by the pallet macro.

fn in_code_storage_version() -> <Pallet<T> as GetStorageVersion>::InCodeStorageVersion

Returns the in-code storage version as specified in the storage_version attribute, or NoStorageVersionSet if the attribute is missing.

fn on_chain_storage_version() -> StorageVersion

Returns the storage version of the pallet as last set in the actual on-chain storage.

fn current_storage_version() -> Self::InCodeStorageVersion

👎Deprecated: This method has been renamed to in_code_storage_version and will be removed after March 2024.

DEPRECATED: Use Self::current_storage_version instead.

impl<T> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn integrity_test()

Check the integrity of this pallet’s configuration.

fn on_initialize(_n: BlockNumber) -> Weight

Block initialization hook. This is called at the very beginning of block execution.

fn on_finalize(_n: BlockNumber)

Block finalization hook. This is called at the very end of block execution.

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before Hooks::on_finalize).

fn on_poll(_n: BlockNumber, _weight: &mut WeightMeter)

A hook to run logic after inherent application.

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by the FRAME Executive pallet.

fn try_state(_n: BlockNumber) -> Result<(), DispatchError>

Execute the sanity checks of this pallet, per block.

fn pre_upgrade() -> Result<Vec<u8>, DispatchError>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade(_state: Vec<u8>) -> Result<(), DispatchError>

Execute some post-checks after a runtime upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are dispatched as separate threads, and entirely independent of the main blockchain execution.

impl<T> IntegrityTest for Pallet<T>

where T: Config,

fn integrity_test()

See Hooks::integrity_test.

impl<T> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn offchain_worker( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, )

This function is being called after every block import (when fully synced).

impl<T> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn on_finalize( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, )

See Hooks::on_finalize.

impl<T> OnGenesis for Pallet<T>

where T: Config,

fn on_genesis()

Something that should happen at genesis.

impl<T> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn on_idle( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, remaining_weight: Weight, ) -> Weight

See Hooks::on_idle.

impl<T> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn on_initialize( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, ) -> Weight

See Hooks::on_initialize.

impl<T> OnPoll<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn on_poll( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, weight: &mut WeightMeter, )

Code to execute every now and then at the beginning of the block after inherent application.

impl<T> OnRuntimeUpgrade for Pallet<T>

where T: Config,

fn on_runtime_upgrade() -> Weight

See Hooks::on_runtime_upgrade.

fn pre_upgrade() -> Result<Vec<u8>, DispatchError>

See Hooks::pre_upgrade.

fn post_upgrade(state: Vec<u8>) -> Result<(), DispatchError>

See Hooks::post_upgrade.

fn try_on_runtime_upgrade(checks: bool) -> Result<Weight, DispatchError>

The expected and default behavior of this method is to handle executing pre_upgrade -> on_runtime_upgrade -> post_upgrade hooks for a migration.

impl<T> PalletInfoAccess for Pallet<T>

where T: Config,

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

fn name_hash() -> [u8; 16]

Two128 hash of name.

fn module_name() -> &'static str

Name of the Rust module containing the pallet.

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.

impl<T> PalletsInfoAccess for Pallet<T>

where T: Config,

fn count() -> usize

The number of pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.

impl<T> PartialEq for Pallet<T>

fn eq(&self, other: &Pallet<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StorageInfoTrait for Pallet<T>

where T: Config,

fn storage_info() -> Vec<StorageInfo>

impl<T> StoredMap<<T as Config>::AccountId, <T as Config>::AccountData> for Pallet<T>

where T: Config,

Implement StoredMap for a simple single-item, provide-when-not-default system. This works fine for storing a single item which allows the account to continue existing as long as it’s not empty/default.

Anything more complex will need more sophisticated logic.

fn get(k: &<T as Config>::AccountId) -> <T as Config>::AccountData

Get the item, or its default if it doesn’t yet exist; we make no distinction between the two.

fn try_mutate_exists<R, E>( k: &<T as Config>::AccountId, f: impl FnOnce(&mut Option<<T as Config>::AccountData>) -> Result<R, E>, ) -> Result<R, E>

where E: From<DispatchError>,

Maybe mutate the item only if an Ok value is returned from f. Do nothing if an Err is returned. It is removed or reset to default value if it has been mutated to None. f will always be called with an option representing if the storage item exists (Some<V>) or if the storage item does not exist (None), independent of the QueryType.

fn mutate<R>(k: &K, f: impl FnOnce(&mut T) -> R) -> Result<R, DispatchError>

Mutate the item.

fn mutate_exists<R>( k: &K, f: impl FnOnce(&mut Option<T>) -> R, ) -> Result<R, DispatchError>

Mutate the item, removing or resetting to default value if it has been mutated to None.

fn insert(k: &K, t: T) -> Result<(), DispatchError>

Set the item to something new.

fn remove(k: &K) -> Result<(), DispatchError>

Remove the item or otherwise replace it with its default value; we don’t care which.

impl<T> TryDecodeEntireStorage for Pallet<T>

where T: Config,

fn try_decode_entire_state() -> Result<usize, Vec<TryDecodeEntireStorageError>>

Decode the entire data under the given storage, returning Ok(bytes_decoded) if success.

impl<T> TryState<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

where T: Config,

fn try_state( n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, _s: Select, ) -> Result<(), DispatchError>

Execute the state checks.

impl<T> ValidateUnsigned for Pallet<T>

where T: Config,

type Call = Call<T>

The call to validate

fn validate_unsigned( _source: TransactionSource, call: &<Pallet<T> as ValidateUnsigned>::Call, ) -> Result<ValidTransaction, TransactionValidityError>

Return the validity of the call

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch.

impl<T> ViewFunctionIdPrefix for Pallet<T>

where T: Config,

fn prefix() -> [u8; 16]

impl<T> WhitelistedStorageKeys for Pallet<T>

where T: Config,

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that should be whitelisted during benchmarking. This means that those keys will be excluded from the benchmarking performance calculation.

impl<T> Eq for Pallet<T>