Struct frame_system::Module

pub struct Module<T: Trait>(_);

Implementations

impl<T: Trait + 'static> Module<T>

pub fn account<K: EncodeLike<T::AccountId>>(
    key: K
) -> AccountInfo<T::Index, T::AccountData>

The full account information for a particular account ID.

pub fn block_weight() -> ExtrinsicsWeight

The current weight for the block.

pub fn block_hash<K: EncodeLike<T::BlockNumber>>(key: K) -> T::Hash

Map of block numbers to block hashes.

pub fn extrinsic_data<K: EncodeLike<u32>>(key: K) -> Vec<u8>

Extrinsics data for the current block (maps an extrinsic’s index to its data).

pub fn block_number() -> T::BlockNumber

The current block number being processed. Set by execute_block.

pub fn parent_hash() -> T::Hash

Hash of the previous block.

pub fn extrinsics_root() -> T::Hash

Extrinsics root of the current block, also part of the block header.

pub fn digest() -> DigestOf<T>

Digest of the current block, also part of the block header.

pub fn events() -> Vec<EventRecord<T::Event, T::Hash>>

Events deposited for the current block.

pub fn event_count() -> u32

The number of events in the Events<T> list.

pub fn event_topics<K: EncodeLike<T::Hash>>(
    key: K
) -> Vec<(T::BlockNumber, u32)>

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 (T::BlockNumber, 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.

impl<T: Trait> Module<T>

Can also be called using Call.

pub fn set_code(origin: T::Origin, code: Vec<u8>) -> DispatchResult

Set the new runtime code.

• O(C + S) where C length of code and S complexity of can_set_code
• 1 storage write (codec O(C)).
• 1 call to can_set_code: O(S) (calls sp_io::misc::runtime_version which is expensive).
• 1 event. The weight of this function is dependent on the runtime, but generally this is very expensive. We will treat this as a full block.

NOTE: Calling this function will bypass origin filters.

pub fn set_code_without_checks(
    origin: T::Origin,
    code: Vec<u8>
) -> DispatchResult

Set the new runtime code without doing any checks of the given code.

• O(C) where C length of code
• 1 storage write (codec O(C)).
• 1 event. The weight of this function is dependent on the runtime. We will treat this as a full block.

NOTE: Calling this function will bypass origin filters.

pub fn set_changes_trie_config(
    origin: T::Origin,
    changes_trie_config: Option<ChangesTrieConfiguration>
) -> DispatchResult

Set the new changes trie configuration.

• O(1)
• 1 storage write or delete (codec O(1)).
• 1 call to deposit_log: Uses append API, so O(1)
• Base Weight: 7.218 µs
• DB Weight:
  • Writes: Changes Trie, System Digest

NOTE: Calling this function will bypass origin filters.

pub fn suicide(origin: T::Origin) -> DispatchResult

Kill the sending account, assuming there are no references outstanding and the composite data is equal to its default value.

• O(1)
• 1 storage read and deletion.

---

Base Weight: 8.626 µs No DB Read or Write operations because caller is already in overlay

NOTE: Calling this function will bypass origin filters.

impl<T: Trait> Module<T>

pub fn deposit_event(event: impl Into<T::Event>)

Deposits an event into this block’s event record.

pub fn inc_ref(who: &T::AccountId)

Increment the reference counter on an account.

pub fn dec_ref(who: &T::AccountId)

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

pub fn refs(who: &T::AccountId) -> RefCount

The number of outstanding references for the account who.

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

True if the account has no outstanding references.

pub fn deposit_event_indexed(topics: &[T::Hash], event: T::Event)

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.

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 module 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 modules 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::BlockNumber,
    parent_hash: &T::Hash,
    txs_root: &T::Hash,
    digest: &DigestOf<T>,
    kind: InitKind
)

Start the execution of a particular block.

pub fn finalize() -> T::Header

Remove temporary “environment” entries in storage.

pub fn deposit_log(item: DigestItemOf<T>)

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

• O(1)
• 1 storage write (codec O(1))

pub fn externalities() -> TestExternalities

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

pub fn set_block_number(n: T::BlockNumber)

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::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_limits(weight: Weight, len: usize)

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

pub fn reset_events()

Reset events. Can be used as an alternative to initialize for tests that don’t need to bother with the other environment entries.

pub fn runtime_version() -> RuntimeVersion

Return the chain’s current runtime version.

pub fn account_nonce(who: impl EncodeLike<T::AccountId>) -> T::Index

Retrieve the account transaction counter from storage.

pub fn inc_account_nonce(who: impl EncodeLike<T::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. If this is called, then ensure derive_extrinsics is also called before block-building is completed.

NOTE: This function is called only when the block is being constructed locally. execute_block doesn’t note any extrinsics.

pub fn note_applied_extrinsic(
    r: &DispatchResultWithPostInfo,
    info: DispatchInfo
)

To be called immediately after an extrinsic has been applied.

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 modules).

pub fn derive_extrinsics()

Remove all extrinsic data and save the extrinsics trie root.

pub fn on_created_account(who: T::AccountId)

An account is being created.

pub fn can_set_code(code: &[u8]) -> Result<(), DispatchError>

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

Checks the given code if it is a valid runtime wasm blob by instantianting it and extracting the runtime version of it. It checks that the runtime version of the old and new runtime has the same spec name and that the spec version is increasing.

Trait Implementations

impl<T: Trait> BlockNumberProvider for Module<T>

type BlockNumber = <T as Trait>::BlockNumber

Type of BlockNumber to provide.

fn current_block_number() -> Self::BlockNumber

Returns the current block number.

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> IntegrityTest for Module<T>

pub fn integrity_test()

Run integrity test.

impl<T: Trait> IsDeadAccount<<T as Trait>::AccountId> for Module<T>

fn is_dead_account(who: &T::AccountId) -> bool

Is the given account dead?

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

pub fn offchain_worker(_n: BlockNumber)

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

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

pub fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

pub fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Trait> OnRuntimeUpgrade for Module<T>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StoredMap<<T as Trait>::AccountId, <T as Trait>::AccountData> for Module<T>

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

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

fn is_explicit(k: &T::AccountId) -> bool

Get whether the item takes up any storage. If this is false, then get will certainly return the T::default(). If true, then there is no implication for get (i.e. it may return any value, including the default).

fn insert(k: &T::AccountId, data: T::AccountData)

Set the item to something new.

fn remove(k: &T::AccountId)

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

fn mutate<R>(k: &T::AccountId, f: impl FnOnce(&mut T::AccountData) -> R) -> R

Mutate the item.

fn mutate_exists<R>(
    k: &T::AccountId,
    f: impl FnOnce(&mut Option<T::AccountData>) -> R
) -> R

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

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

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

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>