Struct node_runtime::Runtime

pub struct Runtime;

Implementations

impl Runtime

pub fn metadata() -> RuntimeMetadataPrefixed

Trait Implementations

impl AccountNonceApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for Runtime

fn account_nonce(account: AccountId) -> Index

Get current account nonce of given AccountId.

impl AuthorityDiscoveryApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn authorities() -> Vec<AuthorityDiscoveryId>

Retrieve authority identifiers of the current and next authority set.

impl BabeApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> 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 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.

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.

impl Benchmark<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn benchmark_metadata(extra: bool) -> (Vec<BenchmarkList>, Vec<StorageInfo>)

Get the benchmark metadata available for this runtime.

fn dispatch_benchmark(
    config: BenchmarkConfig
) -> Result<Vec<BenchmarkBatch>, RuntimeString>

Dispatch the given benchmark.

impl BlockBuilder<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> 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 DbWeight = RocksDbWeight

The weight of runtime database operations the runtime can invoke.

type Origin = Origin

The Origin type used by dispatchable calls.

type Call = Call

The aggregated Call type.

type Index = Index

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

type BlockNumber = BlockNumber

The block number type used by the runtime.

type Hash = Hash

The output of the Hashing function.

type Hashing = BlakeTwo256

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

type AccountId = AccountId

The user account identifier type for the runtime.

type Lookup = Indices

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

type Header = Header<BlockNumber, BlakeTwo256>

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

Get the chain’s current version.

type PalletInfo = PalletInfo

Provides information about the pallet setup in the runtime.

type AccountData = AccountData<Balance>

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 = SubstrateWeight<Runtime>

type SS58Prefix = 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 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 named reserves.

type Balance = Balance

The balance of an account.

type DustRemoval = ()

Handler for the unbalanced reduction when removing a dust account.

type Event = Event

The overarching event type.

type ExistentialDeposit = ExistentialDeposit

The minimum amount required to keep an account open.

type AccountStore = Pallet<Runtime>

The means of storing the balances of an account.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config<()> for Runtime

const INDEXING_PREFIX: &'static [u8]

Prefix for elements stored in the Off-chain DB via Indexing API.

type Hashing = <Runtime as Config>::Hashing

A hasher type for MMR.

type Hash = <Runtime as Config>::Hash

The hashing output type.

type LeafData = Pallet<Self>

Data stored in the leaf nodes.

type OnNewRoot = ()

A hook to act on the new MMR root.

type WeightInfo = ()

Weights for this pallet.

impl Config<()> for Runtime

type PalletId = TreasuryPalletId

The treasury’s pallet id, used for deriving its sovereign account ID.

type Currency = Balances

The staking balance.

type ApproveOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionAtLeast<_3, _5, AccountId, Instance1>>

Origin from which approvals must come.

type RejectOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Origin from which rejections must come.

type Event = Event

The overarching event type.

type OnSlash = ()

Handler for the unbalanced decrease when slashing for a rejected proposal or bounty.

type ProposalBond = ProposalBond

Fraction of a proposal’s value that should be bonded in order to place the proposal. An accepted proposal gets these back. A rejected proposal does not.

type ProposalBondMinimum = ProposalBondMinimum

Minimum amount of funds that should be placed in a deposit for making a proposal.

type SpendPeriod = SpendPeriod

Period between successive spends.

type Burn = Burn

Percentage of spare funds (if any) that are burnt per spend period.

type BurnDestination = ()

Handler for the unbalanced decrease when treasury funds are burned.

type SpendFunds = Bounties

Runtime hooks to external pallet using treasury to compute spend funds.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxApprovals = MaxApprovals

The maximum number of approvals that can wait in the spending queue.

impl Config<()> for Runtime

type Event = Event

The overarching event type.

type Balance = u64

The units in which we record balances.

type AssetId = u32

Identifier for the class of asset.

type Currency = Balances

The currency mechanism.

type ForceOrigin = EnsureRoot<AccountId>

The origin which may forcibly create or destroy an asset or otherwise alter privileged attributes.

type AssetDeposit = AssetDeposit

The basic amount of funds that must be reserved for an asset.

type MetadataDepositBase = MetadataDepositBase

The basic amount of funds that must be reserved when adding metadata to your asset.

type MetadataDepositPerByte = MetadataDepositPerByte

The additional funds that must be reserved for the number of bytes you store in your metadata.

type ApprovalDeposit = ApprovalDeposit

The amount of funds that must be reserved when creating a new approval.

type StringLimit = StringLimit

The maximum length of a name or symbol stored on-chain.

type Freezer = ()

A hook to allow a per-asset, per-account minimum balance to be enforced. This must be respected in all permissionless operations.

type Extra = ()

Additional data to be stored with an account’s asset balance.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config<()> for Runtime

type Event = Event

The overarching event type.

type ClassId = u32

Identifier for the class of asset.

type InstanceId = u32

The type used to identify a unique asset within an asset class.

type Currency = Balances

The currency mechanism, used for paying for reserves.

type ForceOrigin = EnsureRoot<AccountId>

The origin which may forcibly create or destroy an asset or otherwise alter privileged attributes.

type ClassDeposit = ClassDeposit

The basic amount of funds that must be reserved for an asset class.

type InstanceDeposit = InstanceDeposit

The basic amount of funds that must be reserved for an asset instance.

type MetadataDepositBase = MetadataDepositBase

The basic amount of funds that must be reserved when adding metadata to your asset.

type AttributeDepositBase = MetadataDepositBase

The basic amount of funds that must be reserved when adding an attribute to an asset.

type DepositPerByte = MetadataDepositPerByte

The additional funds that must be reserved for the number of bytes store in metadata, either “normal” metadata or attribute metadata.

type StringLimit = StringLimit

The maximum length of data stored on-chain.

type KeyLimit = KeyLimit

The maximum length of an attribute key.

type ValueLimit = ValueLimit

The maximum length of an attribute value.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config<DefaultInstance> for Runtime

type Event = Event

The overarching event type.

type PalletId = SocietyPalletId

The societies’s module id

type Currency = Balances

The currency type used for bidding.

type Randomness = RandomnessCollectiveFlip

Something that provides randomness in the runtime.

type CandidateDeposit = CandidateDeposit

The minimum amount of a deposit required for a bid to be made.

type WrongSideDeduction = WrongSideDeduction

The amount of the unpaid reward that gets deducted in the case that either a skeptic doesn’t vote or someone votes in the wrong way.

type MaxStrikes = MaxStrikes

The number of times a member may vote the wrong way (or not at all, when they are a skeptic) before they become suspended.

type PeriodSpend = PeriodSpend

The amount of incentive paid within each period. Doesn’t include VoterTip.

type MembershipChanged = ()

The receiver of the signal for when the members have changed.

type RotationPeriod = RotationPeriod

The number of blocks between candidate/membership rotation periods.

type MaxLockDuration = MaxLockDuration

The maximum duration of the payout lock.

type FounderSetOrigin = EnsureProportionMoreThan<_1, _2, AccountId, Instance1>

The origin that is allowed to call found.

type SuspensionJudgementOrigin = EnsureFounder<Runtime>

The origin that is allowed to make suspension judgements.

type MaxCandidateIntake = MaxCandidateIntake

The maximum number of candidates that we accept per round.

type ChallengePeriod = ChallengePeriod

The number of blocks between membership challenges.

impl Config<Instance1> for Runtime

type Origin = Origin

The outer origin type.

type Proposal = Call

The outer call dispatch type.

type Event = Event

The outer event type.

type MotionDuration = CouncilMotionDuration

The time-out for council motions.

type MaxProposals = CouncilMaxProposals

Maximum number of proposals allowed to be active in parallel.

type MaxMembers = CouncilMaxMembers

The maximum number of members supported by the pallet. Used for weight estimation.

type DefaultVote = PrimeDefaultVote

Default vote strategy of this collective.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config<Instance1> for Runtime

type Event = Event

The overarching event type.

type AddOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Required origin for adding a member (though can always be Root).

type RemoveOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Required origin for removing a member (though can always be Root).

type SwapOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Required origin for adding and removing a member in a single action.

type ResetOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Required origin for resetting membership.

type PrimeOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Required origin for setting or resetting the prime member.

type MembershipInitialized = TechnicalCommittee

The receiver of the signal for when the membership has been initialized. This happens pre- genesis and will usually be the same as MembershipChanged. If you need to do something different on initialization, then you can change this accordingly.

type MembershipChanged = TechnicalCommittee

The receiver of the signal for when the membership has changed.

type MaxMembers = TechnicalMaxMembers

The maximum number of members that this membership can have.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config<Instance2> for Runtime

type Origin = Origin

The outer origin type.

type Proposal = Call

The outer call dispatch type.

type Event = Event

The outer event type.

type MotionDuration = TechnicalMotionDuration

The time-out for council motions.

type MaxProposals = TechnicalMaxProposals

Maximum number of proposals allowed to be active in parallel.

type MaxMembers = TechnicalMaxMembers

The maximum number of members supported by the pallet. Used for weight estimation.

type DefaultVote = PrimeDefaultVote

Default vote strategy of this collective.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type CallFilter = Nothing

The safest default is to allow no calls at all.

Runtimes should whitelist dispatchables that are allowed to be called from contracts and make sure they are stable. Dispatchables exposed to contracts are not allowed to change because that would break already deployed contracts. The Call structure itself is not allowed to change the indices of existing pallets, too.

type Time = Timestamp

The time implementation used to supply timestamps to conntracts through seal_now.

type Randomness = RandomnessCollectiveFlip

The generator used to supply randomness to contracts through seal_random.

type Currency = Balances

The currency in which fees are paid and contract balances are held.

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type RentPayment = ()

Handler for rent payments.

type SignedClaimHandicap = SignedClaimHandicap

Number of block delay an extrinsic claim surcharge has.

type TombstoneDeposit = TombstoneDeposit

The minimum amount required to generate a tombstone.

type DepositPerContract = DepositPerContract

The balance every contract needs to deposit to stay alive indefinitely.

type DepositPerStorageByte = DepositPerStorageByte

The balance a contract needs to deposit per storage byte to stay alive indefinitely.

type DepositPerStorageItem = DepositPerStorageItem

The balance a contract needs to deposit per storage item to stay alive indefinitely.

type RentFraction = RentFraction

The fraction of the deposit that should be used as rent per block.

type SurchargeReward = SurchargeReward

Reward that is received by the party whose touch has led to removal of a contract.

type CallStack = [Frame<Self>; 31]

The type of the call stack determines the maximum nesting depth of contract calls.

type WeightPrice = Pallet<Self>

Used to answer contracts’ queries regarding the current weight price. This is not used to calculate the actual fee and is only for informational purposes.

type WeightInfo = SubstrateWeight<Self>

Describes the weights of the dispatchables of this module and is also used to construct a default cost schedule.

type ChainExtension = ()

Type that allows the runtime authors to add new host functions for a contract to call.

type DeletionQueueDepth = DeletionQueueDepth

The maximum number of tries that can be queued for deletion.

type DeletionWeightLimit = DeletionWeightLimit

The maximum amount of weight that can be consumed per block for lazy trie removal.

type Schedule = Schedule

Cost schedule and limits.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type AccountIndex = AccountIndex

Type used for storing an account’s index; implies the maximum number of accounts the system can hold.

type Currency = Balances

The currency trait.

type Deposit = IndexDeposit

The deposit needed for reserving an index.

type Event = Event

The overarching event type.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type ExternalOrigin = EnsureProportionAtLeast<_1, _2, AccountId, Instance1>

A straight majority of the council can decide what their next motion is.

type ExternalMajorityOrigin = EnsureProportionAtLeast<_3, _4, AccountId, Instance1>

A super-majority can have the next scheduled referendum be a straight majority-carries vote.

type ExternalDefaultOrigin = EnsureProportionAtLeast<_1, _1, AccountId, Instance1>

A unanimous council can have the next scheduled referendum be a straight default-carries (NTB) vote.

type FastTrackOrigin = EnsureProportionAtLeast<_2, _3, AccountId, Instance2>

Two thirds of the technical committee can have an ExternalMajority/ExternalDefault vote be tabled immediately and with a shorter voting/enactment period.

type Proposal = Call

type Event = Event

type Currency = Balances

Currency type for this pallet.

type EnactmentPeriod = EnactmentPeriod

The minimum period of locking and the period between a proposal being approved and enacted.

type LaunchPeriod = LaunchPeriod

How often (in blocks) new public referenda are launched.

type VotingPeriod = VotingPeriod

How often (in blocks) to check for new votes.

type MinimumDeposit = MinimumDeposit

The minimum amount to be used as a deposit for a public referendum proposal.

type InstantOrigin = EnsureProportionAtLeast<_1, _1, AccountId, Instance2>

Origin from which the next majority-carries (or more permissive) referendum may be tabled to vote immediately and asynchronously in a similar manner to the emergency origin. It retains its threshold method.

type InstantAllowed = InstantAllowed

Indicator for whether an emergency origin is even allowed to happen. Some chains may want to set this permanently to false, others may want to condition it on things such as an upgrade having happened recently.

type FastTrackVotingPeriod = FastTrackVotingPeriod

Minimum voting period allowed for a fast-track referendum.

type CancellationOrigin = EnsureProportionAtLeast<_2, _3, AccountId, Instance1>

Origin from which any referendum may be cancelled in an emergency.

type CancelProposalOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionAtLeast<_1, _1, AccountId, Instance2>>

Origin from which a proposal may be cancelled and its backers slashed.

type BlacklistOrigin = EnsureRoot<AccountId>

Origin from which proposals may be blacklisted.

type VetoOrigin = EnsureMember<AccountId, Instance2>

Origin for anyone able to veto proposals.

type CooloffPeriod = CooloffPeriod

Period in blocks where an external proposal may not be re-submitted after being vetoed.

type PreimageByteDeposit = PreimageByteDeposit

The amount of balance that must be deposited per byte of preimage stored.

type OperationalPreimageOrigin = EnsureMember<AccountId, Instance1>

An origin that can provide a preimage using operational extrinsics.

type Slash = Treasury

Handler for the unbalanced reduction when slashing a preimage deposit.

type Scheduler = Scheduler

The Scheduler.

type PalletsOrigin = OriginCaller

Overarching type of all pallets origins.

type MaxVotes = MaxVotes

The maximum number of votes for an account.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxProposals = MaxProposals

The maximum number of public proposals that can exist at any time.

impl Config for Runtime

type Event = Event

type PalletId = ElectionsPhragmenPalletId

Identifier for the elections-phragmen pallet’s lock

type Currency = Balances

The currency that people are electing with.

type ChangeMembers = Council

What to do when the members change.

type InitializeMembers = Council

What to do with genesis members

type CurrencyToVote = U128CurrencyToVote

Convert a balance into a number used for election calculation. This must fit into a u64 but is allowed to be sensibly lossy.

type CandidacyBond = CandidacyBond

How much should be locked up in order to submit one’s candidacy.

type VotingBondBase = VotingBondBase

Base deposit associated with voting.

type VotingBondFactor = VotingBondFactor

The amount of bond that need to be locked for each vote (32 bytes).

type LoserCandidate = ()

Handler for the unbalanced reduction when a candidate has lost (and is not a runner-up)

type KickedMember = ()

Handler for the unbalanced reduction when a member has been kicked.

type DesiredMembers = DesiredMembers

Number of members to elect.

type DesiredRunnersUp = DesiredRunnersUp

Number of runners_up to keep.

type TermDuration = TermDuration

How long each seat is kept. This defines the next block number at which an election round will happen. If set to zero, no elections are ever triggered and the module will be in passive mode.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

A sudo-able call.

impl Config for Runtime

type Event = Event

The overarching event type.

type IdentificationTuple = IdentificationTuple<Self>

Full identification of the validator.

type OnOffenceHandler = Staking

A handler called for every offence report.

impl Config for Runtime

type Event = Event

The overarching event type.

type Currency = Balances

The currency trait.

type BasicDeposit = BasicDeposit

The amount held on deposit for a registered identity

type FieldDeposit = FieldDeposit

The amount held on deposit per additional field for a registered identity.

type SubAccountDeposit = SubAccountDeposit

The amount held on deposit for a registered subaccount. This should account for the fact that one storage item’s value will increase by the size of an account ID, and there will be another trie item whose value is the size of an account ID plus 32 bytes.

type MaxSubAccounts = MaxSubAccounts

The maximum number of sub-accounts allowed per identified account.

type MaxAdditionalFields = MaxAdditionalFields

Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O required to access an identity, but can be pretty high.

type MaxRegistrars = MaxRegistrars

Maxmimum number of registrars allowed in the system. Needed to bound the complexity of, e.g., updating judgements.

type Slashed = Treasury

What to do with slashed funds.

type ForceOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

The origin which may forcibly set or remove a name. Root can always do this.

type RegistrarOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

The origin which may add or remove registrars. Root can always do this.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type Currency = Balances

The currency mechanism.

type ConfigDepositBase = ConfigDepositBase

The base amount of currency needed to reserve for creating a recovery configuration.

type FriendDepositFactor = FriendDepositFactor

The amount of currency needed per additional user when creating a recovery configuration.

type MaxFriends = MaxFriends

The maximum amount of friends allowed in a recovery configuration.

type RecoveryDeposit = RecoveryDeposit

The base amount of currency needed to reserve for starting a recovery.

impl Config for Runtime

type Event = Event

The overarching event type.

type Currency = Balances

The currency trait.

type BlockNumberToBalance = ConvertInto

Convert the block number into a balance.

type MinVestedTransfer = MinVestedTransfer

The minimum amount transferred to call vested_transfer.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type Origin = Origin

The aggregated origin which the dispatch will take.

type PalletsOrigin = OriginCaller

The caller origin, overarching type of all pallets origins.

type Call = Call

The aggregated call type.

type MaximumWeight = MaximumSchedulerWeight

The maximum weight that may be scheduled per block for any dispatchables of less priority than schedule::HARD_DEADLINE.

type ScheduleOrigin = EnsureRoot<AccountId>

Required origin to schedule or cancel calls.

type MaxScheduledPerBlock = MaxScheduledPerBlock

The maximum number of scheduled calls in the queue for a single block. Not strictly enforced, but used for weight estimation.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

type Currency = Balances

Currency type.

type EstimateCallFee = TransactionPayment

Something that can predict the fee of a call. Used to sensibly distribute rewards.

type SignedPhase = SignedPhase

Duration of the signed phase.

type UnsignedPhase = UnsignedPhase

Duration of the unsigned phase.

type SolutionImprovementThreshold = SolutionImprovementThreshold

The minimum amount of improvement to the solution score that defines a solution as “better” (in any phase).

type OffchainRepeat = OffchainRepeat

The repeat threshold of the offchain worker.

type MinerMaxIterations = MinerMaxIterations

Maximum number of iteration of balancing that will be executed in the embedded miner of the pallet.

type MinerMaxWeight = MinerMaxWeight

Maximum weight that the miner should consume.

type MinerMaxLength = MinerMaxLength

Maximum length (bytes) that the mined solution should consume.

type MinerTxPriority = MultiPhaseUnsignedPriority

The priority of the unsigned transaction submitted in the unsigned-phase

type SignedMaxSubmissions = SignedMaxSubmissions

Maximum number of signed submissions that can be queued.

type SignedRewardBase = SignedRewardBase

Base reward for a signed solution

type SignedDepositBase = SignedDepositBase

Base deposit for a signed solution.

type SignedDepositByte = SignedDepositByte

Per-byte deposit for a signed solution.

type SignedDepositWeight = ()

Per-weight deposit for a signed solution.

type SignedMaxWeight = MinerMaxWeight

Maximum weight of a signed solution.

type SlashHandler = ()

Handler for the slashed deposits.

type RewardHandler = ()

Handler for the rewards.

type DataProvider = Staking

Something that will provide the election data.

type OnChainAccuracy = Perbill

Accuracy used for fallback on-chain election.

type Solution = NposSolution16

The solution type.

type Fallback = Fallback

Configuration for the fallback

type WeightInfo = SubstrateWeight<Runtime>

The weight of the pallet.

type ForceOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionMoreThan<_1, _2, AccountId, Instance1>>

Origin that can control this pallet. Note that any action taken by this origin (such) as providing an emergency solution is not checked. Thus, it must be a trusted origin.

type BenchmarkingConfig = BenchmarkConfig

The configuration of benchmarking.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type Currency = Balances

The currency mechanism.

type ProxyType = ProxyType

A kind of proxy; specified with the proxy and passed in to the IsProxyable fitler. The instance filter determines whether a given call may be proxied under this type.

type ProxyDepositBase = ProxyDepositBase

The base amount of currency needed to reserve for creating a proxy.

type ProxyDepositFactor = ProxyDepositFactor

The amount of currency needed per proxy added.

type MaxProxies = MaxProxies

The maximum amount of proxies allowed for a single account.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxPending = MaxPending

The maximum amount of time-delayed announcements that are allowed to be pending.

type CallHasher = BlakeTwo256

The type of hash used for hashing the call.

type AnnouncementDepositBase = AnnouncementDepositBase

The base amount of currency needed to reserve for creating an announcement.

type AnnouncementDepositFactor = AnnouncementDepositFactor

The amount of currency needed per announcement made.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type Currency = Balances

The currency mechanism.

type DepositBase = DepositBase

The base amount of currency needed to reserve for creating a multisig execution or to store a dispatch call for later.

type DepositFactor = DepositFactor

The amount of currency needed per unit threshold when creating a multisig execution.

type MaxSignatories = MaxSignatories

The maximum amount of signatories allowed in the multisig.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type BountyDepositBase = BountyDepositBase

The amount held on deposit for placing a bounty proposal.

type BountyDepositPayoutDelay = BountyDepositPayoutDelay

The delay period for which a bounty beneficiary need to wait before claim the payout.

type BountyUpdatePeriod = BountyUpdatePeriod

Bounty duration in blocks.

type BountyCuratorDeposit = BountyCuratorDeposit

Percentage of the curator fee that will be reserved upfront as deposit for bounty curator.

type BountyValueMinimum = BountyValueMinimum

Minimum value for a bounty.

type DataDepositPerByte = DataDepositPerByte

The amount held on deposit per byte within the tip report reason or bounty description.

type MaximumReasonLength = MaximumReasonLength

Maximum acceptable reason length.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type DataDepositPerByte = DataDepositPerByte

The amount held on deposit per byte within the tip report reason or bounty description.

type MaximumReasonLength = MaximumReasonLength

Maximum acceptable reason length.

type Tippers = Elections

Origin from which tippers must come.

type TipCountdown = TipCountdown

The period for which a tip remains open after is has achieved threshold tippers.

type TipFindersFee = TipFindersFee

The percent of the final tip which goes to the original reporter of the tip.

type TipReportDepositBase = TipReportDepositBase

The amount held on deposit for placing a tip report.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type PalletId = LotteryPalletId

The Lottery’s pallet id

type Call = Call

A dispatchable call.

type Currency = Balances

The currency trait.

type Randomness = RandomnessCollectiveFlip

Something that provides randomness in the runtime.

type Event = Event

The overarching event type.

type ManagerOrigin = EnsureRoot<AccountId>

The manager origin.

type MaxCalls = MaxCalls

The max number of calls available in a single lottery.

type ValidateCall = Lottery

Used to determine if a call would be valid for purchasing a ticket.

type MaxGenerateRandom = MaxGenerateRandom

Number of time we should try to generate a random number that has no modulo bias. The larger this number, the more potential computation is used for picking the winner, but also the more likely that the chosen winner is done fairly.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

Overarching event type.

type Currency = Balances

Currency type that this works on.

type CurrencyBalance = Balance

Just the Currency::Balance type; we have this item to allow us to constrain it to From<u64>.

type AdminOrigin = EnsureRoot<AccountId>

Origin required for setting the target proportion to be under gilt.

type Deficit = ()

Unbalanced handler to account for funds created (in case of a higher total issuance over freezing period).

type Surplus = ()

Unbalanced handler to account for funds destroyed (in case of a lower total issuance over freezing period).

type IgnoredIssuance = IgnoredIssuance

The issuance to ignore. This is subtracted from the Currency’s total_issuance to get the issuance by which we inflate or deflate the gilt.

type QueueCount = QueueCount

Number of duration queues in total. This sets the maximum duration supported, which is this value multiplied by Period.

type MaxQueueLen = MaxQueueLen

Maximum number of items that may be in each duration queue.

type FifoQueueLen = FifoQueueLen

Portion of the queue which is free from ordering and just a FIFO.

type Period = Period

The base period for the duration queues. This is the common multiple across all supported freezing durations that can be bid upon.

type MinFreeze = MinFreeze

The minimum amount of funds that may be offered to freeze for a gilt. Note that this does not actually limit the amount which may be frozen in a gilt since gilts may be split up in order to satisfy the desired amount of funds under gilts.

type IntakePeriod = IntakePeriod

The number of blocks between consecutive attempts to issue more gilts in an effort to get to the target amount to be frozen.

type MaxIntakeBids = MaxIntakeBids

The maximum amount of bids that can be turned into issued gilts each block. A larger value here means less of the block available for transactions should there be a glut of bids to make into gilts to reach the target.

type WeightInfo = SubstrateWeight<Runtime>

Information on runtime weights.

impl Config for Runtime

type Event = Event

The overarching event type.

type Currency = Balances

The currency trait.

type Call = Call

A dispatchable call.

type FeeDestination = ()

Handler for the unbalanced decrease when fees are burned.

type WeightInfo = SubstrateWeight<Runtime>

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

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

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 = EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>

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 Config for Runtime

type Moment = Moment

Type used for expressing timestamp.

type OnTimestampSet = Babe

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 = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The event type of this module.

type Call = Call

The function call.

type KeyOwnerProofSystem = Historical

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, GrandpaId)>>::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, GrandpaId)>>::IdentificationTuple

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

type HandleEquivocation = EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>

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

Weights for this pallet.

impl Config for Runtime

type FindAuthor = FindAccountFromAuthorIndex<Self, Babe>

Find the author of a block.

type UncleGenerations = UncleGenerations

The number of blocks back we should accept uncles. This means that we will deal with uncle-parents that are UncleGenerations + 1 before now.

type FilterUncle = ()

A filter for uncles within a block. This is for implementing further constraints on what uncles can be included, other than their ancestry.

type EventHandler = (Staking, ImOnline)

An event handler for authored blocks.

impl Config for Runtime

type FullIdentification = Exposure<AccountId, Balance>

Full identification of the validator.

type FullIdentificationOf = ExposureOf<Runtime>

A conversion from validator ID to full identification.

impl Config for Runtime

type Event = Event

The overarching event type.

type ValidatorId = <Self as Config>::AccountId

A stable ID for a validator.

type ValidatorIdOf = StashOf<Self>

A conversion from account ID to validator ID.

type ShouldEndSession = Babe

Indicator for when to end the session.

type NextSessionRotation = Babe

Something that can predict the next session rotation. This should typically come from the same logical unit that provides ShouldEndSession, yet, it gives a best effort estimate. It is helpful to implement EstimateNextNewSession.

type SessionManager = NoteHistoricalRoot<Self, Staking>

Handler for managing new session.

type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders

Handler when a session has changed.

type Keys = SessionKeys

The keys.

type DisabledValidatorsThreshold = DisabledValidatorsThreshold

The fraction of validators set that is safe to be disabled.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type AuthorityId = ImOnlineId

The identifier type for an authority.

type Event = Event

The overarching event type.

type NextSessionRotation = Babe

A trait that allows us to estimate the current session progress and also the average session length.

type ValidatorSet = Historical

A type for retrieving the validators supposed to be online in a session.

type ReportUnresponsiveness = Offences

A type that gives us the ability to submit unresponsiveness offence reports.

type UnsignedPriority = ImOnlineUnsignedPriority

A configuration for base priority of unsigned transactions.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type OnChargeTransaction = CurrencyAdapter<Balances, DealWithFees>

Handler for withdrawing, refunding and depositing the transaction fee. Transaction fees are withdrawn before the transaction is executed. After the transaction was executed the transaction weight can be adjusted, depending on the used resources by the transaction. If the transaction weight is lower than expected, parts of the transaction fee might be refunded. In the end the fees can be deposited.

type TransactionByteFee = TransactionByteFee

The fee to be paid for making a transaction; the per-byte portion.

type WeightToFee = IdentityFee<Balance>

Convert a weight value into a deductible fee based on the currency type.

type FeeMultiplierUpdate = TargetedFeeAdjustment<Self, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier>

Update the multiplier of the next block, based on the previous block’s weight.

impl Config for Runtime

type SlashCancelOrigin = EnsureOneOf<AccountId, EnsureRoot<AccountId>, EnsureProportionAtLeast<_3, _4, AccountId, Instance1>>

A super-majority of the council can cancel the slash.

const MAX_NOMINATIONS: u32

Maximum number of nominations per nominator.

type Currency = Balances

The staking balance.

type UnixTime = Timestamp

Time used for computing era duration.

type CurrencyToVote = U128CurrencyToVote

Convert a balance into a number used for election calculation. This must fit into a u64 but is allowed to be sensibly lossy. The u64 is used to communicate with the sp_npos_elections crate which accepts u64 numbers and does operations in 128. Consequently, the backward convert is used convert the u128s from sp-elections back to a BalanceOf.

type RewardRemainder = Treasury

Tokens have been minted and are unused for validator-reward. See Era payout.

type Event = Event

The overarching event type.

type Slash = Treasury

Handler for the unbalanced reduction when slashing a staker.

type Reward = ()

Handler for the unbalanced increment when rewarding a staker.

type SessionsPerEra = SessionsPerEra

Number of sessions per era.

type BondingDuration = BondingDuration

Number of eras that staked funds must remain bonded for.

type SlashDeferDuration = SlashDeferDuration

Number of eras that slashes are deferred by, after computation.

type SessionInterface = Self

Interface for interacting with a session pallet.

type EraPayout = ConvertCurve<RewardCurve>

The payout for validators and the system for the current era. See Era payout.

type NextNewSession = Session

Something that can estimate the next session change, accurately or as a best effort guess.

type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator

The maximum number of nominators rewarded for each validator.

type ElectionProvider = ElectionProviderMultiPhase

Something that provides the election functionality.

type GenesisElectionProvider = OnChainSequentialPhragmen<OnChainConfig<Self>>

Something that provides the election functionality at genesis.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl ContractsApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128, u32, H256> for Runtime

fn call(
    origin: AccountId,
    dest: AccountId,
    value: Balance,
    gas_limit: u64,
    input_data: Vec<u8>
) -> ContractExecResult

Perform a call from a specified account to a given contract.

fn instantiate(
    origin: AccountId,
    endowment: Balance,
    gas_limit: u64,
    code: Code<Hash>,
    data: Vec<u8>,
    salt: Vec<u8>
) -> ContractInstantiateResult<AccountId, BlockNumber>

Instantiate a new contract.

fn get_storage(address: AccountId, key: [u8; 32]) -> GetStorageResult

Query a given storage key in a given contract.

fn rent_projection(address: AccountId) -> RentProjectionResult<BlockNumber>

Returns the projected time a given contract will be able to sustain paying its rent.

impl Core<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> 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<LocalCall> CreateSignedTransaction<LocalCall> for Runtime where
    Call: From<LocalCall>, 

fn create_transaction<C: AppCrypto<Self::Public, Self::Signature>>(
    call: Call,
    public: <Signature as Verify>::Signer,
    account: AccountId,
    nonce: Index
) -> Option<(Call, <UncheckedExtrinsic as Extrinsic>::SignaturePayload)>

Attempt to create signed extrinsic data that encodes call from given account.

impl Debug for Runtime

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

Formats the value using the given formatter.

impl EnsureInherentsAreFirst<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

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

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

impl GetNodeBlockType for Runtime

type NodeBlock = Block

The NodeBlock type.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = Block

The RuntimeBlock type.

impl GrandpaApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn grandpa_authorities() -> GrandpaAuthorityList

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: GrandpaId
) -> 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<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn metadata() -> OpaqueMetadata

Returns the metadata of a runtime.

impl MmrApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <Runtime as Config<()>>::Hash> for Runtime

fn generate_proof(
    leaf_index: u64
) -> Result<(EncodableOpaqueLeaf, Proof<<Runtime as Config>::Hash>), Error>

Generate MMR proof for a leaf under given index.

fn verify_proof(
    leaf: EncodableOpaqueLeaf,
    proof: Proof<<Runtime as Config>::Hash>
) -> Result<(), Error>

Verify MMR proof against on-chain MMR.

fn verify_proof_stateless(
    root: <Runtime as Config>::Hash,
    leaf: EncodableOpaqueLeaf,
    proof: Proof<<Runtime as Config>::Hash>
) -> Result<(), Error>

Verify MMR proof against given root hash.

impl<__SR_API_BLOCK__: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<__SR_API_BLOCK__> + 'static> MmrApi<__SR_API_BLOCK__, <Runtime as Config<()>>::Hash> for RuntimeApiImpl<__SR_API_BLOCK__, RuntimeApiImplCall> where
    RuntimeApiImplCall::StateBackend: StateBackend<HashFor<__SR_API_BLOCK__>>,
    u64: UnwindSafe + RefUnwindSafe,
    Result<(EncodableOpaqueLeaf, Proof<<Runtime as Config>::Hash>), Error>: UnwindSafe + RefUnwindSafe,
    EncodableOpaqueLeaf: UnwindSafe + RefUnwindSafe,
    Proof<<Runtime as Config>::Hash>: UnwindSafe + RefUnwindSafe,
    Result<(), Error>: UnwindSafe + RefUnwindSafe,
    <Runtime as Config>::Hash: UnwindSafe + RefUnwindSafe,
    EncodableOpaqueLeaf: UnwindSafe + RefUnwindSafe,
    Proof<<Runtime as Config>::Hash>: UnwindSafe + RefUnwindSafe,
    Result<(), Error>: UnwindSafe + RefUnwindSafe,
    __SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, 

fn MmrApi_generate_proof_runtime_api_impl(
    &self,
    at: &BlockId<__SR_API_BLOCK__>,
    context: ExecutionContext,
    params: Option<u64>,
    params_encoded: Vec<u8>
) -> Result<NativeOrEncoded<Result<(EncodableOpaqueLeaf, Proof<<Runtime as Config>::Hash>), Error>>, ApiError>

fn MmrApi_verify_proof_runtime_api_impl(
    &self,
    at: &BlockId<__SR_API_BLOCK__>,
    context: ExecutionContext,
    params: Option<(EncodableOpaqueLeaf, Proof<<Runtime as Config>::Hash>)>,
    params_encoded: Vec<u8>
) -> Result<NativeOrEncoded<Result<(), Error>>, ApiError>

fn MmrApi_verify_proof_stateless_runtime_api_impl(
    &self,
    at: &BlockId<__SR_API_BLOCK__>,
    context: ExecutionContext,
    params: Option<(<Runtime as Config>::Hash, EncodableOpaqueLeaf, Proof<<Runtime as Config>::Hash>)>,
    params_encoded: Vec<u8>
) -> Result<NativeOrEncoded<Result<(), Error>>, ApiError>

fn generate_proof(
    &self,
    __runtime_api_at_param__: &BlockId<Block>,
    leaf_index: u64
) -> Result<Result<(EncodableOpaqueLeaf, Proof<Hash>), Error>, ApiError>

Generate MMR proof for a leaf under given index.

fn generate_proof_with_context(
    &self,
    __runtime_api_at_param__: &BlockId<Block>,
    context: ExecutionContext,
    leaf_index: u64
) -> Result<Result<(EncodableOpaqueLeaf, Proof<Hash>), Error>, ApiError>

Generate MMR proof for a leaf under given index.

fn verify_proof(
    &self,
    __runtime_api_at_param__: &BlockId<Block>,
    leaf: EncodableOpaqueLeaf,
    proof: Proof<Hash>
) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against on-chain MMR.

fn verify_proof_with_context(
    &self,
    __runtime_api_at_param__: &BlockId<Block>,
    context: ExecutionContext,
    leaf: EncodableOpaqueLeaf,
    proof: Proof<Hash>
) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against on-chain MMR.

fn verify_proof_stateless(
    &self,
    __runtime_api_at_param__: &BlockId<Block>,
    root: Hash,
    leaf: EncodableOpaqueLeaf,
    proof: Proof<Hash>
) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against given root hash.

fn verify_proof_stateless_with_context(
    &self,
    __runtime_api_at_param__: &BlockId<Block>,
    context: ExecutionContext,
    root: Hash,
    leaf: EncodableOpaqueLeaf,
    proof: Proof<Hash>
) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against given root hash.

impl OffchainWorkerApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> 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 !=.

impl<C> SendTransactionTypes<C> for Runtime where
    Call: From<C>, 

type Extrinsic = UncheckedExtrinsic

The extrinsic type expected by the runtime.

type OverarchingCall = Call

The runtime’s call type.

impl SessionKeys<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn generate_session_keys(seed: 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 SigningTypes for Runtime

type Public = <Signature as Verify>::Signer

A public key that is capable of identifying AccountIds.

type Signature = Signature

A matching Signature type.

impl TaggedTransactionQueue<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

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

Validate the transaction.

impl TransactionPaymentApi<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, u128> for Runtime

fn query_info(
    uxt: <Block as BlockT>::Extrinsic,
    len: u32
) -> RuntimeDispatchInfo<Balance>

fn query_fee_details(
    uxt: <Block as BlockT>::Extrinsic,
    len: u32
) -> FeeDetails<Balance>

impl TryRuntime<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn on_runtime_upgrade() -> Result<(Weight, Weight), RuntimeString>

dry-run runtime upgrades, returning the total weight consumed.

impl ValidateUnsigned for Runtime

type Call = Call

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 Config for Runtime

impl Config for Runtime

impl Config for Runtime

impl Config for Runtime

impl Copy for Runtime

impl Eq for Runtime

impl StructuralEq for Runtime

impl StructuralPartialEq for Runtime