Struct substrate_test_runtime::Runtime

pub struct Runtime;

Implementations

impl Runtime

pub fn metadata() -> RuntimeMetadataPrefixed

pub fn metadata_at_version(version: u32) -> Option<OpaqueMetadata>

pub fn metadata_versions() -> Vec<u32>

Trait Implementations

impl AccountNonceApiV1<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>, <Signature as Verify>::Signer, u64> for Runtime

fn account_nonce(account: AccountId) -> Nonce

Get current account nonce of given AccountId.

impl AuraApiV1<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>, Public> for Runtime

fn slot_duration() -> SlotDuration

Returns the slot duration for Aura.

fn authorities() -> Vec<AuraId>

Return the current set of authorities.

impl BabeApiV2<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn configuration() -> BabeConfiguration

Return the configuration for BABE.

fn current_epoch_start() -> Slot

Returns the slot that started the current epoch.

fn current_epoch() -> Epoch

Returns information regarding the current epoch.

fn next_epoch() -> Epoch

Returns information regarding the next epoch (which was already previously announced).

fn submit_report_equivocation_unsigned_extrinsic( _equivocation_proof: EquivocationProof<<Block as BlockT>::Header>, _key_owner_proof: OpaqueKeyOwnershipProof ) -> Option<()>

Submits an unsigned extrinsic to report an equivocation. The caller must provide the equivocation proof and a key ownership proof (should be obtained using generate_key_ownership_proof). The extrinsic will be unsigned and should only be accepted for local authorship (not to be broadcast to the network). This method returns None when creation of the extrinsic fails, e.g. if equivocation reporting is disabled for the given runtime (i.e. this method is hardcoded to return None). Only useful in an offchain context.

fn generate_key_ownership_proof( _slot: Slot, _authority_id: AuthorityId ) -> Option<OpaqueKeyOwnershipProof>

Generates a proof of key ownership for the given authority in the current epoch. An example usage of this module is coupled with the session historical module to prove that a given authority key is tied to a given staking identity during a specific session. Proofs of key ownership are necessary for submitting equivocation reports. NOTE: even though the API takes a slot as parameter the current implementations ignores this parameter and instead relies on this method being called at the correct block height, i.e. any point at which the epoch for the given slot is live on-chain. Future implementations will instead use indexed data through an offchain worker, not requiring older states to be available.

impl BlockBuilderV6<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn apply_extrinsic( extrinsic: <Block as BlockT>::Extrinsic ) -> ApplyExtrinsicResult

Apply the given extrinsic.

fn finalize_block() -> <Block as BlockT>::Header

Finish the current block.

fn inherent_extrinsics(_data: InherentData) -> Vec<<Block as BlockT>::Extrinsic>

Generate inherent extrinsics. The inherent data will vary from chain to chain.

fn check_inherents(_block: Block, _data: InherentData) -> CheckInherentsResult

Check that the inherents are valid. The inherent data will vary from chain to chain.

impl CallerTrait<<Runtime as Config>::AccountId> for OriginCaller

fn into_system(self) -> Option<RawOrigin<<Runtime as Config>::AccountId>>

Extract the signer from the message if it is a Signed origin.

fn as_system_ref(&self) -> Option<&RawOrigin<<Runtime as Config>::AccountId>>

Extract a reference to the system-level RawOrigin if it is that.

fn as_signed(&self) -> Option<&AccountId>

Extract the signer from it if a system Signed origin, None otherwise.

fn is_root(&self) -> bool

Returns true if self is a system Root origin, None otherwise.

fn is_none(&self) -> bool

Returns true if self is a system None origin, None otherwise.

impl Clone for Runtime

fn clone(&self) -> Runtime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Config<()> for Runtime

type MaxLocks = MaxLocks

The maximum number of locks that should exist on an account. Not strictly enforced, but used for weight estimation.

type MaxReserves = MaxReserves

The maximum number of named reserves that can exist on an account.

type ReserveIdentifier = [u8; 8]

The ID type for reserves.

type Balance = u64

The balance of an account.

type DustRemoval = ()

Handler for the unbalanced reduction when removing a dust account.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type ExistentialDeposit = ExistentialDeposit

The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!

type AccountStore = Pallet<Runtime>

The means of storing the balances of an account.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type FreezeIdentifier = ()

The ID type for freezes.

type MaxFreezes = ()

The maximum number of individual freeze locks that can exist on an account at any time.

type RuntimeHoldReason = RuntimeHoldReason

The overarching hold reason.

type MaxHolds = ConstU32<1>

The maximum number of holds that can exist on an account at any time.

impl Config for Runtime

type EpochDuration = EpochDuration

The amount of time, in slots, that each epoch should last. NOTE: Currently it is not possible to change the epoch duration after the chain has started. Attempting to do so will brick block production.

type ExpectedBlockTime = ConstU64<10000>

The expected average block time at which BABE should be creating blocks. Since BABE is probabilistic it is not trivial to figure out what the expected average block time should be based on the slot duration and the security parameter c (where 1 - c represents the probability of a slot being empty).

type EpochChangeTrigger = SameAuthoritiesForever

BABE requires some logic to be triggered on every block to query for whether an epoch has ended and to perform the transition to the next epoch.

type DisabledValidators = ()

A way to check whether a given validator is disabled and should not be authoring blocks. Blocks authored by a disabled validator will lead to a panic as part of this module’s initialization.

type KeyOwnerProof = Void

The proof of key ownership, used for validating equivocation reports. The proof must include the session index and validator count of the session at which the equivocation occurred.

type EquivocationReportSystem = ()

The equivocation handling subsystem, defines methods to check/report an offence and for submitting a transaction to report an equivocation (from an offchain context).

type WeightInfo = ()

Helper for weights computations

type MaxAuthorities = ConstU32<10>

Max number of authorities allowed

type MaxNominators = ConstU32<100>

The maximum number of nominators for each validator.

impl Config for Runtime

type BaseCallFilter = Everything

The basic call filter to use in Origin. All origins are built with this filter as base, except Root.

type BlockWeights = RuntimeBlockWeights

Block & extrinsics weights: base values and limits.

type BlockLength = ()

The maximum length of a block (in bytes).

type RuntimeOrigin = RuntimeOrigin

The RuntimeOrigin type used by dispatchable calls.

type RuntimeCall = RuntimeCall

The aggregated RuntimeCall type.

type Nonce = u64

This stores the number of previous transactions associated with a sender account.

type Hash = H256

The output of the Hashing function.

type Hashing = BlakeTwo256

The hashing system (algorithm) being used in the runtime (e.g. Blake2).

type AccountId = <Signature as Verify>::Signer

The user account identifier type for the runtime.

type Lookup = IdentityLookup<<Runtime as Config>::AccountId>

Converting trait to take a source type and convert to AccountId.

type Block = Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>

The Block type used by the runtime. This is used by construct_runtime to retrieve the extrinsics or other block specific data as needed.

type RuntimeEvent = RuntimeEvent

The aggregated event type of the runtime.

type BlockHashCount = ConstU64<2400>

Maximum number of block number to block hash mappings to keep (oldest pruned first).

type DbWeight = ()

The weight of runtime database operations the runtime can invoke.

type Version = ()

Get the chain’s current version.

type PalletInfo = PalletInfo

Provides information about the pallet setup in the runtime.

type AccountData = AccountData<u64>

Data to be associated with an account (other than nonce/transaction counter, which this pallet does regardless).

type OnNewAccount = ()

Handler for when a new account has just been created.

type OnKilledAccount = ()

A function that is invoked when an account has been determined to be dead.

type SystemWeightInfo = ()

type SS58Prefix = ()

The designated SS58 prefix of this chain.

type OnSetCode = ()

What to do if the runtime wants to change the code to something new.

type MaxConsumers = ConstU32<16>

The maximum number of consumers allowed on a single account.

impl Config for Runtime

type Moment = u64

Type used for expressing timestamp.

type OnTimestampSet = Pallet<Runtime>

Something which can be notified when the timestamp is set. Set this to () if not needed.

type MinimumPeriod = ConstU64<500>

The minimum period between blocks. Beware that this is different to the expected period that the block production apparatus provides. Your chosen consensus system will generally work with this to determine a sensible block time. e.g. For Aura, it will be double this period on default settings.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl CoreV4<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn version() -> RuntimeVersion

Returns the version of the runtime.

fn execute_block(block: Block)

Execute the given block.

fn initialize_block(header: &<Block as BlockT>::Header)

Initialize a block with the given header.

impl Debug for Runtime

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

Formats the value using the given formatter.

impl EnsureInherentsAreFirst<<Runtime as Config>::Block> for Runtime

fn ensure_inherents_are_first( block: &<Runtime as Config>::Block ) -> Result<(), u32>

Ensure the position of inherent is correct, i.e. they are before non-inherents.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = <Runtime as Config>::Block

The RuntimeBlock type.

impl GrandpaApiV3<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn grandpa_authorities() -> AuthorityList

Get the current GRANDPA authorities and weights. This should not change except for when changes are scheduled and the corresponding delay has passed.

fn current_set_id() -> SetId

Get current GRANDPA authority set id.

fn submit_report_equivocation_unsigned_extrinsic( _equivocation_proof: EquivocationProof<<Block as BlockT>::Hash, NumberFor<Block>>, _key_owner_proof: OpaqueKeyOwnershipProof ) -> Option<()>

Submits an unsigned extrinsic to report an equivocation. The caller must provide the equivocation proof and a key ownership proof (should be obtained using generate_key_ownership_proof). The extrinsic will be unsigned and should only be accepted for local authorship (not to be broadcast to the network). This method returns None when creation of the extrinsic fails, e.g. if equivocation reporting is disabled for the given runtime (i.e. this method is hardcoded to return None). Only useful in an offchain context.

fn generate_key_ownership_proof( _set_id: SetId, _authority_id: AuthorityId ) -> Option<OpaqueKeyOwnershipProof>

Generates a proof of key ownership for the given authority in the given set. An example usage of this module is coupled with the session historical module to prove that a given authority key is tied to a given staking identity during a specific session. Proofs of key ownership are necessary for submitting equivocation reports. NOTE: even though the API takes a set_id as parameter the current implementations ignore this parameter and instead rely on this method being called at the correct block height, i.e. any point at which the given set id is live on-chain. Future implementations will instead use indexed data through an offchain worker, not requiring older states to be available.

impl MetadataV2<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn metadata() -> OpaqueMetadata

Returns the metadata of a runtime.

fn metadata_at_version(_version: u32) -> Option<OpaqueMetadata>

Returns the metadata at a given version.

fn metadata_versions() -> Vec<u32>

Returns the supported metadata versions.

impl OffchainWorkerApiV2<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn offchain_worker(header: &<Block as BlockT>::Header)

Starts the off-chain task for given block header.

impl PartialEq<Runtime> for Runtime

fn eq(&self, other: &Runtime) -> bool

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

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

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

impl SessionKeysV1<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn generate_session_keys(_: Option<Vec<u8>>) -> Vec<u8>

Generate a set of session keys with optionally using the given seed. The keys should be stored within the keystore exposed via runtime externalities.

fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, KeyTypeId)>>

Decode the given public session keys.

impl TaggedTransactionQueueV3<Block<Header<u64, BlakeTwo256>, UncheckedExtrinsic<Public, RuntimeCall, Signature, (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall)>>> for Runtime

fn validate_transaction( source: TransactionSource, utx: <Block as BlockT>::Extrinsic, block_hash: <Block as BlockT>::Hash ) -> TransactionValidity

Validate the transaction.

impl TypeInfo for Runtime

type Identity = Runtime

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl ValidateUnsigned for Runtime

type Call = RuntimeCall

The call to validate

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

Validate the call right before dispatch.

fn validate_unsigned( source: TransactionSource, call: &Self::Call ) -> TransactionValidity

Return the validity of the call

impl Config for Runtime

impl Copy for Runtime

impl Eq for Runtime

impl StructuralEq for Runtime

impl StructuralPartialEq for Runtime