Struct substrate_test_runtime::Runtime

pub struct Runtime;

Trait Implementations

impl AccountNonceApi<Block<Header<u64, BlakeTwo256>, Extrinsic>, <Signature as Verify>::Signer, u64> for Runtime

fn account_nonce(_account: AccountId) -> Index

Get current account nonce of given AccountId.

impl AuraApi<Block<Header<u64, BlakeTwo256>, Extrinsic>, Public> for Runtime

fn slot_duration() -> SlotDuration

Returns the slot duration for Aura.

fn authorities() -> Vec<AuraId>

impl BabeApi<Block<Header<u64, BlakeTwo256>, Extrinsic>> for Runtime

fn configuration() -> BabeGenesisConfiguration

Return the genesis configuration for BABE. The configuration is only read on genesis.

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 BlockBuilder<Block<Header<u64, BlakeTwo256>, Extrinsic>> 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 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 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 = RuntimeBlockLength

The maximum length of a block (in bytes).

type Origin = Origin

The Origin type used by dispatchable calls.

type Call = Extrinsic

The aggregated Call type.

type Index = u64

Account index (aka nonce) type. This stores the number of previous transactions associated with a sender account.

type BlockNumber = u64

The block number type used by the runtime.

type Hash = H256

The output of the Hashing function.

type Hashing = Hashing

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

type AccountId = u64

The user account identifier type for the runtime.

type Lookup = IdentityLookup<Self::AccountId>

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

type Header = Header

The block header.

type Event = Event

The aggregated event type of the runtime.

type BlockHashCount = BlockHashCount

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 = Self

Provides information about the pallet setup in the runtime.

type AccountData = ()

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 SS85 prefix of this chain.

type OnSetCode = ()

What to do if the user wants the code set to something. Just use () unless you are in cumulus.

impl Config for Runtime

type Moment = u64

A timestamp: milliseconds since the unix epoch.

type OnTimestampSet = ()

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

type MinimumPeriod = MinimumPeriod

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

Weight information for extrinsics in this pallet.

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 = ExpectedBlockTime

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 = ExternalTrigger

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

A system for proving ownership of keys, i.e. that a given key was part of a validator set, needed for validating equivocation reports.

type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, AuthorityId)>>::Proof

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 KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, AuthorityId)>>::IdentificationTuple

The identification of a key owner, used when reporting equivocations.

type HandleEquivocation = ()

The equivocation handling subsystem, defines methods to report an offence (after the equivocation has been validated) and for submitting a transaction to report an equivocation (from an offchain context). NOTE: when enabling equivocation handling (i.e. this type isn’t set to ()) you must use this pallet’s ValidateUnsigned in the runtime definition.

type WeightInfo = ()

impl Core<Block<Header<u64, BlakeTwo256>, Extrinsic>> 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 GetNodeBlockType for Runtime

type NodeBlock = Block

The NodeBlock type.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = Block

The RuntimeBlock type.

impl GrandpaApi<Block<Header<u64, BlakeTwo256>, Extrinsic>> 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 Metadata<Block<Header<u64, BlakeTwo256>, Extrinsic>> for Runtime

fn metadata() -> OpaqueMetadata

Returns the metadata of a runtime.

impl OffchainWorkerApi<Block<Header<u64, BlakeTwo256>, Extrinsic>> for Runtime

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

Starts the off-chain task for given block header.

impl PalletInfo for Runtime

fn index<P: 'static>() -> Option<usize>

Convert the given pallet P into its index as configured in the runtime.

fn name<P: 'static>() -> Option<&'static str>

Convert the given pallet P into its name as configured in the runtime.

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

impl SessionKeys<Block<Header<u64, BlakeTwo256>, Extrinsic>> 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 TaggedTransactionQueue<Block<Header<u64, BlakeTwo256>, Extrinsic>> for Runtime

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

Validate the transaction.

impl Eq for Runtime

impl StructuralEq for Runtime

impl StructuralPartialEq for Runtime