Struct kitchensink_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<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for Runtime

fn account_nonce(account: AccountId) -> Nonce

Get current account nonce of given AccountId.

impl AsSystemOriginSigner<<Runtime as Config>::AccountId> for RuntimeOrigin

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

Extract a reference of the inner value of the System Origin::Signed variant, if self has that variant.

impl AssetConversionApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, u128, NativeOrWithId<u32>> for Runtime

fn quote_price_exact_tokens_for_tokens( asset1: NativeOrWithId<u32>, asset2: NativeOrWithId<u32>, amount: Balance, include_fee: bool, ) -> Option<Balance>

Provides a quote for Pallet::swap_exact_tokens_for_tokens.

fn quote_price_tokens_for_exact_tokens( asset1: NativeOrWithId<u32>, asset2: NativeOrWithId<u32>, amount: Balance, include_fee: bool, ) -> Option<Balance>

Provides a quote for Pallet::swap_tokens_for_exact_tokens.

fn get_reserves( asset1: NativeOrWithId<u32>, asset2: NativeOrWithId<u32>, ) -> Option<(Balance, Balance)>

Returns the size of the liquidity pool for the given asset pair.

impl AuthorityDiscoveryApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

fn authorities() -> Vec<AuthorityDiscoveryId>

Retrieve authority identifiers of the current and next authority set.

impl BabeApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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 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 BeefyApiV5<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, Public> for Runtime

fn beefy_genesis() -> Option<BlockNumber>

Return the block number where BEEFY consensus is enabled/started

fn validator_set() -> Option<ValidatorSet<BeefyId>>

Return the current active BEEFY validator set

fn submit_report_double_voting_unsigned_extrinsic( equivocation_proof: DoubleVotingProof<BlockNumber, BeefyId, BeefySignature>, key_owner_proof: OpaqueKeyOwnershipProof, ) -> Option<()>

Submits an unsigned extrinsic to report a double voting equivocation. The caller must provide the double voting 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 submit_report_fork_voting_unsigned_extrinsic( equivocation_proof: ForkVotingProof<<Block as BlockT>::Header, BeefyId, OpaqueValue>, key_owner_proof: OpaqueKeyOwnershipProof, ) -> Option<()>

Submits an unsigned extrinsic to report a fork voting equivocation. The caller must provide the fork voting proof (the ancestry proof should be obtained using generate_ancestry_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 submit_report_future_block_voting_unsigned_extrinsic( equivocation_proof: FutureBlockVotingProof<BlockNumber, BeefyId>, key_owner_proof: OpaqueKeyOwnershipProof, ) -> Option<()>

Submits an unsigned extrinsic to report a future block voting equivocation. The caller must provide the future block voting 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: ValidatorSetId, authority_id: BeefyId, ) -> 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 ignores this parameter and instead relies 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.

fn generate_ancestry_proof( prev_block_number: BlockNumber, best_known_block_number: Option<BlockNumber>, ) -> Option<OpaqueValue>

Generates a proof that the prev_block_number is part of the canonical chain at best_known_block_number.

impl BenchmarkV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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 BlockBuilderV6<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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<Instance1> for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Balance = u128

The units in which we record balances.

type AssetId = u32

Identifier for the class of asset.

type AssetIdParameter = Compact<u32>

Wrapper around Self::AssetId to use in dispatchable call signatures. Allows the use of compact encoding in instances of the pallet, which will prevent breaking changes resulting from the removal of HasCompact from Self::AssetId.

type Currency = Pallet<Runtime>

The currency mechanism.

type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Standard asset class creation is only allowed if the origin attempting it and the asset class are in this set.

type ForceOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::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 AssetAccountDeposit = ConstU128<DOLLARS>

The amount of funds that must be reserved for a non-provider asset account to be maintained.

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

Callback methods for asset state change (e.g. asset created or destroyed)

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RemoveItemsLimit = ConstU32<1000>

Max number of items to destroy per destroy_accounts and destroy_approvals call.

type BenchmarkHelper = ()

Helper trait for benchmarks.

impl Config<Instance1> for Runtime

type ScoreProvider = Pallet<Runtime>

The voter bags-list is loosely kept up to date, and the real source of truth for the score of each node is the staking pallet.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type BagThresholds = BagThresholds

The list of thresholds separating the various bags.

type Score = u64

The type used to dictate a node position relative to other nodes.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config<Instance1> for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type AddOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

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

type RemoveOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

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

type SwapOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

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

type ResetOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

Required origin for resetting membership.

type PrimeOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

Required origin for setting or resetting the prime member.

type MembershipInitialized = Pallet<Runtime, Instance2>

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 = Pallet<Runtime, Instance2>

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

type RuntimeOrigin = RuntimeOrigin

The runtime origin type.

type Proposal = RuntimeCall

The runtime call dispatch type.

type RuntimeEvent = RuntimeEvent

The runtime 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.

type SetMembersOrigin = EnsureRoot<<Runtime as Config>::AccountId>

Origin allowed to set collective members

type MaxProposalWeight = MaxCollectivesProposalWeight

The maximum weight of a dispatch call that can be proposed and executed.

type DisapproveOrigin = EnsureRoot<<Runtime as Config>::AccountId>

Origin from which a proposal in any status may be disapproved without associated cost for a proposer.

type KillOrigin = EnsureRoot<<Runtime as Config>::AccountId>

Origin from which any malicious proposal may be killed with associated cost for a proposer.

type Consideration = HoldConsideration<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Pallet<Runtime>, ProposalHoldReason, Delayed<ConstU32<2>, Linear<ConstU32<2>, ProposalDepositOffset>>, u32>

Mechanism to assess the necessity of some cost for publishing and storing a proposal.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type Currency = Pallet<Runtime>

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 = ConstU32<100>

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

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type Currency = Pallet<Runtime>

Currency type.

type EstimateCallFee = Pallet<Runtime>

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

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

type OffchainRepeat = OffchainRepeat

The repeat threshold of the offchain worker.

type MinerTxPriority = MultiPhaseUnsignedPriority

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

type MinerConfig = Runtime

Configurations of the embedded miner.

type SignedMaxSubmissions = ConstU32<10>

Maximum number of signed submissions that can be queued.

type SignedRewardBase = SignedRewardBase

Base reward for a signed solution

type SignedDepositBase = GeometricDepositBase<u128, SignedFixedDeposit, SignedDepositIncreaseFactor>

Something that calculates the signed deposit base based on the signed submissions queue size.

type SignedDepositByte = SignedDepositByte

Per-byte deposit for a signed solution.

type SignedMaxRefunds = ConstU32<3>

The maximum amount of unchecked solutions to refund the call fee for.

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

Something that will provide the election data.

type Fallback = OnChainExecution<OnChainSeqPhragmen>

Configuration for the fallback.

type GovernanceFallback = OnChainExecution<OnChainSeqPhragmen>

Configuration of the governance-only fallback.

type Solver = SequentialPhragmen<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, <<<Runtime as Config>::MinerConfig as MinerConfig>::Solution as NposSolution>::Accuracy, OffchainRandomBalancing>

OCW election solution miner algorithm implementation.

type ForceOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

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 MaxWinners = MaxActiveValidators

The maximum number of winners that can be elected by this ElectionProvider implementation.

type ElectionBounds = ElectionBoundsMultiPhase

The maximum number of electing voters and electable targets to put in the snapshot. At the moment, snapshots are only over a single block, but once multi-block elections are introduced they will take place over multiple blocks.

type BenchmarkingConfig = ElectionProviderBenchmarkConfig

The configuration of benchmarking.

type WeightInfo = SubstrateWeight<Runtime>

The weight of the pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type ValidatorId = <Runtime as Config>::AccountId

A stable ID for a validator.

type ValidatorIdOf = StashOf<Runtime>

A conversion from account ID to validator ID.

type ShouldEndSession = Pallet<Runtime>

Indicator for when to end the session.

type NextSessionRotation = Pallet<Runtime>

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<Runtime, Pallet<Runtime>>

Handler for managing new session.

type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders

Handler when a session has changed.

type Keys = SessionKeys

The keys.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type AdminOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 3, 4>>

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

type Currency = Pallet<Runtime>

The staking balance.

type CurrencyBalance = u128

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

type UnixTime = Pallet<Runtime>

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 frame_election_provider_support 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 = Pallet<Runtime>

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

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Slash = Pallet<Runtime>

Handler for the unbalanced reduction when slashing a staker.

type Reward = ()

Handler for the unbalanced increment when rewarding a staker. NOTE: in most cases, the implementation of OnUnbalanced should modify the total issuance.

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

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

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

type MaxExposurePageSize = ConstU32<256>

The maximum size of each T::ExposurePage.

type ElectionProvider = Pallet<Runtime>

Something that provides the election functionality.

type GenesisElectionProvider = OnChainExecution<OnChainSeqPhragmen>

Something that provides the election functionality at genesis.

type VoterList = Pallet<Runtime, Instance1>

Something that provides a best-effort sorted list of voters aka electing nominators, used for NPoS election.

type NominationsQuota = FixedNominationsQuota<MAX_QUOTA_NOMINATIONS>

Something that defines the maximum number of nominations per nominator.

type TargetList = UseValidatorsMap<Runtime>

WIP: This is a noop as of now, the actual business logic that’s described below is going to be introduced in a follow-up PR.

type MaxUnlockingChunks = ConstU32<32>

The maximum number of unlocking chunks a StakingLedger can have. Effectively determines how many unique eras a staker may be unbonding in.

type MaxControllersInDeprecationBatch = MaxControllersInDeprecationBatch

The maximum amount of controller accounts that can be deprecated in one call.

type HistoryDepth = HistoryDepth

Number of eras to keep in history.

type EventListeners = Pallet<Runtime>

Something that listens to staking updates and performs actions based on the data it receives.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type BenchmarkingConfig = StakingBenchmarkingConfig

Some parameters of the benchmarking.

type DisablingStrategy = UpToLimitDisablingStrategy

DisablingStragegy controls how validators are disabled

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

impl Config for Runtime

type RuntimeParameters = RuntimeParameters

The overarching KV type of the parameters.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type AdminOrigin = DynamicParametersManagerOrigin

The origin which may update a parameter.

type WeightInfo = ()

Weight information for extrinsics in this module.

impl Config for Runtime

type AccountIndex = u32

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

type Currency = Pallet<Runtime>

The currency trait.

type Deposit = IndexDeposit

The deposit needed for reserving an index.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type WhitelistOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Required origin for whitelisting a call.

type DispatchWhitelistedOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Required origin for dispatching whitelisted call with root origin.

type Preimages = Pallet<Runtime>

The handler of pre-images.

type WeightInfo = SubstrateWeight<Runtime>

The weight information for this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type OnChargeTransaction = CurrencyAdapter<Pallet<Runtime>, 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 OperationalFeeMultiplier = OperationalFeeMultiplier

A fee multiplier for Operational extrinsics to compute “virtual tip” to boost their priority

type WeightToFee = IdentityFee<u128>

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

type LengthToFee = ConstantMultiplier<u128, TransactionByteFee>

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

type FeeMultiplierUpdate = TargetedFeeAdjustment<Runtime, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier, MaximumMultiplier>

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

type WeightInfo = SubstrateWeight<Runtime>

The weight information of this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Proposal = RuntimeCall

The runtime call dispatch type.

type AdminOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance3, 2, 3>>

Origin for admin-level operations, like setting the Alliance’s rules.

type MembershipManager = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance3, 2, 3>>

Origin that manages entry and forcible discharge from the Alliance.

type AnnouncementOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance3, 2, 3>>

Origin for making announcements and adding/removing unscrupulous items.

type Currency = Pallet<Runtime>

The currency used for deposits.

type Slashed = Pallet<Runtime>

What to do with slashed funds.

type InitializeMembers = Pallet<Runtime, Instance3>

What to do with initial voting members of the Alliance.

type MembershipChanged = Pallet<Runtime, Instance3>

What to do when a member has been added or removed.

type IdentityVerifier = ()

The identity verifier of an Alliance member.

type ProposalProvider = AllianceProposalProvider

The provider of the proposal operation.

type MaxProposals = AllianceMaxProposals

Maximum number of proposals allowed to be active in parallel.

type MaxFellows = MaxFellows

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

type MaxAllies = MaxAllies

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

type MaxUnscrupulousItems = ConstU32<100>

The maximum number of the unscrupulous items supported by the pallet.

type MaxWebsiteUrlLength = ConstU32<255>

The maximum length of a website URL.

type MaxAnnouncementsCount = ConstU32<100>

The maximum number of announcements.

type MaxMembersCount = AllianceMaxMembers

The maximum number of members per member role.

type AllyDeposit = AllyDeposit

The deposit required for submitting candidacy.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RetirementPeriod = RetirementPeriod

The number of blocks a member must wait between giving a retirement notice and retiring. Supposed to be greater than time required to kick_member.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

The fungible type for this pallet.

type RuntimeHoldReason = RuntimeHoldReason

The overarching runtime hold reason.

type RuntimeCall = RuntimeCall

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.

type MaxBlockTransactions = ConstU32<{ pallet_transaction_storage::DEFAULT_MAX_BLOCK_TRANSACTIONS }>

Maximum number of indexed transactions in the block.

type MaxTransactionSize = ConstU32<{ pallet_transaction_storage::DEFAULT_MAX_TRANSACTION_SIZE }>

Maximum data set in a single transaction in bytes.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type IdentificationTuple = (<Runtime as Config>::ValidatorId, <Runtime as Config>::FullIdentification)

Full identification of the validator.

type OnOffenceHandler = Pallet<Runtime>

A handler called for every offence report.

impl Config for Runtime

type BaseCallFilter = InsideBoth<Pallet<Runtime>, Pallet<Runtime>>

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 Nonce = u32

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

type Hash = H256

The output of the Hashing function.

type AccountId = <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId

The user account identifier type for the runtime.

type Lookup = Pallet<Runtime>

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

type Block = Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>

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

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

type Version = Version

Get the chain’s in-code version.

type AccountData = AccountData<u128>

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

type SystemWeightInfo = SubstrateWeight<Runtime>

Weight information for the extrinsics of this pallet.

type SS58Prefix = ConstU16<42>

The designated SS58 prefix of this chain.

type MaxConsumers = ConstU32<16>

The maximum number of consumers allowed on a single account.

type MultiBlockMigrator = Pallet<Runtime>

The migrator that is used to run Multi-Block-Migrations.

type Hashing = <SolochainDefaultConfig as DefaultConfig>::Hashing

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

type OnNewAccount = <SolochainDefaultConfig as DefaultConfig>::OnNewAccount

Handler for when a new account has just been created.

type OnKilledAccount = <SolochainDefaultConfig as DefaultConfig>::OnKilledAccount

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

type ExtensionsWeightInfo = <SolochainDefaultConfig as DefaultConfig>::ExtensionsWeightInfo

Weight information for the transaction extensions of this pallet.

type RuntimeEvent = RuntimeEvent

The aggregated event type of the runtime.

type RuntimeOrigin = RuntimeOrigin

The RuntimeOrigin type used by dispatchable calls.

type RuntimeCall = RuntimeCall

The aggregated RuntimeCall type.

type RuntimeTask = RuntimeTask

The aggregated RuntimeTask type.

type PalletInfo = PalletInfo

Provides information about the pallet setup in the runtime.

type OnSetCode = <SolochainDefaultConfig as DefaultConfig>::OnSetCode

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

type SingleBlockMigrations = <SolochainDefaultConfig as DefaultConfig>::SingleBlockMigrations

All migrations that should run in the next runtime upgrade.

type PreInherents = <SolochainDefaultConfig as DefaultConfig>::PreInherents

A callback that executes in every block directly before all inherents were applied.

type PostInherents = <SolochainDefaultConfig as DefaultConfig>::PostInherents

A callback that executes in every block directly after all inherents were applied.

type PostTransactions = <SolochainDefaultConfig as DefaultConfig>::PostTransactions

A callback that executes in every block directly after all transactions were applied.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

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

The curator deposit is calculated as a percentage of the curator fee.

type CuratorDepositMin = CuratorDepositMin

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

type CuratorDepositMax = CuratorDepositMax

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

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.

type ChildBountyManager = Pallet<Runtime>

The child bounty manager.

type OnSlash = Pallet<Runtime>

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

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RuntimeEvent = RuntimeEvent

The runtime event type.

type AddOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin required to add a member.

type RemoveOrigin = <Runtime as Config>::DemoteOrigin

The origin required to remove a member.

type PromoteOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU16<u16::MAX>>

The origin required to promote a member. The success value indicates the maximum rank to which the promotion may be.

type DemoteOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU16<u16::MAX>>

The origin required to demote a member. The success value indicates the maximum rank from which the demotion may be.

type ExchangeOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU16<u16::MAX>>

The origin that can swap the account of a member.

type Polls = Pallet<Runtime, Instance2>

The polling system used for our voting.

type MinRankOfClass = Identity

Convert the tally class into the minimum rank required to vote on the poll. If Polls::Class is the same type as Rank, then Identity can be used here to mean “a rank of at least the poll class”.

type VoteWeight = Geometric

Convert a rank_delta into a number of votes the rank gets.

type MemberSwappedHandler = (Pallet<Runtime>, Pallet<Runtime>)

An external handler that will be notified when two members are swapped.

type MaxMemberCount = ()

The maximum number of members for a given rank in the collective.

type BenchmarkSetup = (Pallet<Runtime>, Pallet<Runtime>)

Setup a member for benchmarking.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type ControlOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin that can control this pallet, in other words invoke Pallet::control.

type BatchSize = ConstU32<64>

Batch size.

type Deposit = ConstU128<{ DOLLARS }>

Deposit to take for unstaking, to make sure we’re able to slash the it in order to cover the costs of resources on unsuccessful unstake.

type Currency = Pallet<Runtime>

The currency used for deposits.

type Staking = Pallet<Runtime>

The access to staking functionality.

type MaxErasToCheckPerBlock = ConstU32<1>

Maximum value for ErasToCheckPerBlock, checked in Pallet::control.

type WeightInfo = ()

The weight information of this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type AssetId = NativeOrWithId<u32>

The asset ID type that can be used for transaction payments in addition to a native asset.

type OnChargeAssetTransaction = SwapAssetAdapter<Native, UnionOf<Pallet<Runtime>, Pallet<Runtime, Instance1>, NativeFromLeft, NativeOrWithId<u32>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, Pallet<Runtime>, ResolveAssetTo<TreasuryAccount, UnionOf<Pallet<Runtime>, Pallet<Runtime, Instance1>, NativeFromLeft, NativeOrWithId<u32>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>>

The actual transaction charging logic that charges the fees.

type WeightInfo = SubstrateWeight<Runtime>

The weight information of this pallet.

type BenchmarkHelper = AssetConversionTxHelper

Benchmark helper

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type PalletId = SocietyPalletId

The societies’s pallet id

type Currency = Pallet<Runtime>

The currency type used for bidding.

type Randomness = Pallet<Runtime>

Something that provides randomness in the runtime.

type GraceStrikes = GraceStrikes

The maximum number of strikes before a member gets funds slashed.

type PeriodSpend = PeriodSpend

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

type VotingPeriod = SocietyVotingPeriod

The number of blocks on which new candidates should be voted on. Together with ClaimPeriod, this sums to the number of blocks between candidate intake periods.

type ClaimPeriod = ClaimPeriod

The number of blocks on which new candidates can claim their membership and be the named head.

type MaxLockDuration = MaxLockDuration

The maximum duration of the payout lock.

type FounderSetOrigin = EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>

The origin that is allowed to call found.

type ChallengePeriod = ChallengePeriod

The number of blocks between membership challenges.

type MaxPayouts = MaxPayouts

The maximum number of payouts a member may have waiting unclaimed.

type MaxBids = MaxBids

The maximum number of bids at once.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type MaxAuthorities = MaxAuthorities

The maximum number of authorities per session.

type MaxExternalAddressSize = ConstU32<128>

The maximum size of one of a mixnode’s external addresses.

type MaxExternalAddressesPerMixnode = ConstU32<16>

The maximum number of external addresses for a mixnode.

type NextSessionRotation = Pallet<Runtime>

Session progress/length estimation. Used to determine when to send registration transactions and the longevity of these transactions.

type NumCoverToCurrentBlocks = MixnetNumCoverToCurrentBlocks

Length of the first phase of each session (CoverToCurrent), in blocks.

type NumRequestsToCurrentBlocks = MixnetNumRequestsToCurrentBlocks

Length of the second phase of each session (RequestsToCurrent), in blocks.

type NumCoverToPrevBlocks = MixnetNumCoverToPrevBlocks

Length of the third phase of each session (CoverToPrev), in blocks.

type NumRegisterStartSlackBlocks = MixnetNumRegisterStartSlackBlocks

The number of “slack” blocks at the start of each session, during which maybe_register will not attempt to post registration transactions.

type NumRegisterEndSlackBlocks = MixnetNumRegisterEndSlackBlocks

The number of “slack” blocks at the end of each session. maybe_register will try to register before this slack period, but may post registration transactions during the slack period as a last resort.

type RegistrationPriority = MixnetRegistrationPriority

Priority of unsigned transactions used to register mixnodes.

type MinMixnodes = ConstU32<7>

Minimum number of mixnodes. If there are fewer than this many mixnodes registered for a session, the mixnet will not be active during the session.

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

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

type Randomness = Pallet<Runtime>

The generator used to supply randomness to contracts through seal_random.

type Currency = Pallet<Runtime>

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

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type DepositPerItem = DepositPerItem

The amount of balance a caller has to pay for each storage item.

type DepositPerByte = DepositPerByte

The amount of balance a caller has to pay for each byte of storage.

type DefaultDepositLimit = DefaultDepositLimit

Fallback value to limit the storage deposit if it’s not being set by the caller.

type CallStack = [Frame<Runtime>; 5]

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

type WeightPrice = Pallet<Runtime>

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

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

Cost schedule and limits.

type AddressGenerator = DefaultAddressGenerator

The address generator used to generate the addresses of contracts.

type MaxCodeLen = ConstU32<{ 123 * 1024 }>

The maximum length of a contract code in bytes.

type MaxStorageKeyLen = ConstU32<128>

The maximum allowable length in bytes for storage keys.

type UnsafeUnstableInterface = ConstBool<false>

Make contract callable functions marked as #[unstable] available.

type UploadOrigin = EnsureSigned<<Runtime as Config>::AccountId>

Origin allowed to upload code.

type InstantiateOrigin = EnsureSigned<<Runtime as Config>::AccountId>

Origin allowed to instantiate code.

type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>

The maximum length of the debug buffer in bytes.

type MaxTransientStorageSize = ConstU32<{ 1 * 1024 * 1024 }>

The maximum size of the transient storage in bytes. This includes keys, values, and previous entries used for storage rollback.

type RuntimeHoldReason = RuntimeHoldReason

Overarching hold reason.

type Migrations = (NoopMigration<15>, NoopMigration<16>)

The sequence of migration steps that will be applied during a migration.

type MaxDelegateDependencies = ConstU32<32>

The maximum number of delegate_dependencies that a contract can lock with chain_extension::Ext::lock_delegate_dependency.

type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent

The percentage of the storage deposit that should be held for using a code hash. Instantiating a contract, or calling chain_extension::Ext::lock_delegate_dependency protects the code from being removed. In order to prevent abuse these actions are protected with a percentage of the code deposit.

type Debug = ()

Note

type Environment = ()

Type that bundles together all the runtime configurable interface types.

type ApiVersion = ()

The version of the HostFn APIs that are available in the runtime.

type Xcm = ()

A type that exposes XCM APIs, allowing contracts to interact with other parachains, and execute XCM programs.

impl Config for Runtime

type MessageProcessor = NoopMessageProcessor<u32>

NOTE: Always set this to NoopMessageProcessor for benchmarking.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

type Size = u32

Page/heap size type.

type QueueChangeHandler = ()

Code to be called when a message queue changes - either with items introduced or removed.

type QueuePausedQuery = ()

Queried by the pallet to check whether a queue can be serviced.

type HeapSize = ConstU32<{ 64 * 1024 }>

The size of the page; this implies the maximum message size which can be sent.

type MaxStale = ConstU32<128>

The maximum number of stale pages (i.e. of overweight messages) allowed before culling can happen. Once there are more stale pages than this, then historical pages may be dropped, even if they contain unprocessed overweight messages.

type ServiceWeight = MessageQueueServiceWeight

The amount of weight (if any) which should be provided to the message queue for servicing enqueued items on_initialize.

type IdleMaxServiceWeight = ()

The maximum amount of weight (if any) to be used from remaining weight on_idle which should be provided to the message queue for servicing enqueued items on_idle. Useful for parachains to process messages at the same block they are received.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type ControlOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin that can control the configurations of this pallet.

type Currency = Pallet<Runtime>

The currency provider type.

type RuntimeHoldReason = RuntimeHoldReason

The overarching runtime hold reason.

type MaxKeyLen = MigrationMaxKeyLen

Maximal number of bytes that a key can have.

type SignedDepositPerItem = MigrationSignedDepositPerItem

The amount of deposit collected per item in advance, for signed migrations.

type SignedDepositBase = MigrationSignedDepositBase

The base value of Config::SignedDepositPerItem.

type SignedFilter = EnsureSigned<<Runtime as Config>::AccountId>

Filter on which origin that trigger the manual migrations.

type WeightInfo = ()

The weight information of this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

Overarching event type.

type Balance = u128

The type in which the assets for swapping are measured.

type HigherPrecisionBalance = U256

A type used for calculations concerning the Balance type to avoid possible overflows.

type AssetKind = NativeOrWithId<u32>

Type of asset class, sourced from Config::Assets, utilized to offer liquidity to a pool.

type Assets = UnionOf<Pallet<Runtime>, Pallet<Runtime, Instance1>, NativeFromLeft, NativeOrWithId<u32>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Registry of assets utilized for providing liquidity to pools.

type PoolId = (<Runtime as Config>::AssetKind, <Runtime as Config>::AssetKind)

Liquidity pool identifier.

type PoolLocator = Chain<WithFirstAsset<Native, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, NativeOrWithId<u32>, AccountIdConverter<AssetConversionPalletId, <Runtime as Config>::PoolId>>, Ascending<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, NativeOrWithId<u32>, AccountIdConverter<AssetConversionPalletId, <Runtime as Config>::PoolId>>>

Provides means to resolve the Config::PoolId and it’s AccountId from a pair of Config::AssetKinds.

type PoolAssetId = <Runtime as Config<Instance2>>::AssetId

Asset class for the lp tokens from Self::PoolAssets.

type PoolAssets = Pallet<Runtime, Instance2>

Registry for the lp tokens. Ideally only this pallet should have create permissions on the assets.

type PoolSetupFee = PoolSetupFee

A one-time fee to setup the pool.

type PoolSetupFeeAsset = Native

Asset class from Config::Assets used to pay the Config::PoolSetupFee.

type PoolSetupFeeTarget = ResolveAssetTo<AssetConversionOrigin, <Runtime as Config>::Assets>

Handler for the Config::PoolSetupFee.

type PalletId = AssetConversionPalletId

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

type LPFee = ConstU32<3>

A % the liquidity providers will take of every swap. Represents 10ths of a percent.

type LiquidityWithdrawalFee = LiquidityWithdrawalFee

A fee to withdraw the liquidity.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxSwapPathLength = ConstU32<4>

The max number of hops in a swap.

type MintMinLiquidity = MintMinLiquidity

The minimum LP token amount that could be minted. Ameliorates rounding errors.

type BenchmarkHelper = ()

The benchmarks need a way to create asset ids from u32s.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

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.

type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons

Reasons that determine under which conditions the balance may drop below the unvested amount.

type BlockNumberProvider = Pallet<Runtime>

Provider for the block number.

const MAX_VESTING_SCHEDULES: u32 = 28u32

Maximum number of vesting schedules an account may have at a given moment.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

Overarching event type.

type PriorAccountIdConverter = AccountIdConverterNoSeed<(NativeOrWithId<u32>, NativeOrWithId<u32>)>

Type previously used to derive the account ID for a pool. Indicates that the pool’s liquidity assets are located at this account before the migration.

type AssetsRefund = <Runtime as Config>::Assets

Retrieves information about an existing deposit for a given account ID and asset from the pallet_asset_conversion::Config::Assets registry and can initiate the refund.

type PoolAssetsRefund = <Runtime as Config>::PoolAssets

Retrieves information about an existing deposit for a given account ID and asset from the pallet_asset_conversion::Config::PoolAssets registry and can initiate the refund.

type PoolAssetsTeam = <Runtime as Config>::PoolAssets

Means to reset the team for assets from the pallet_asset_conversion::Config::PoolAssets registry.

type DepositAsset = Pallet<Runtime>

Registry of an asset used as an account deposit for the pallet_asset_conversion::Config::Assets and pallet_asset_conversion::Config::PoolAssets registries.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

Currency type for this pallet, used for Deposits.

type RuntimeHoldReason = RuntimeHoldReason

The hold reason when reserving funds for entering or extending the safe-mode.

type WhitelistedCalls = SafeModeWhitelistedCalls

Contains all runtime calls in any pallet that can be dispatched even while the safe-mode is entered.

type EnterDuration = EnterDuration

For how many blocks the safe-mode will be entered by Pallet::enter.

type EnterDepositAmount = EnterDepositAmount

The amount that will be reserved upon calling Pallet::enter.

type ExtendDuration = ExtendDuration

For how many blocks the safe-mode can be extended by each Pallet::extend call.

type ExtendDepositAmount = ExtendDepositAmount

The amount that will be reserved upon calling Pallet::extend.

type ForceEnterOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU32<9>>

The origin that may call Pallet::force_enter.

type ForceExtendOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU32<11>>

The origin that may call Pallet::force_extend.

type ForceExitOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin that may call Pallet::force_enter.

type ForceDepositOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The only origin that can force to release or slash a deposit.

type ReleaseDelay = ReleaseDelay

The minimal duration a deposit will remain reserved after safe-mode is entered or extended, unless Pallet::force_release_deposit is successfully called sooner.

type Notify = ()

Notifies external logic when the safe-mode is being entered or exited.

type WeightInfo = SubstrateWeight<Runtime>

impl Config for Runtime

type MaxAuthorities = MaxAuthorities

The maximum number of authorities that can be added.

impl Config for Runtime

fn prepare_set_code_data() -> Vec<u8>

Adds ability to the Runtime to test against their sample code.

fn setup_set_code_requirements(_code: &Vec<u8>) -> Result<(), BenchmarkError>

Adds ability to the Runtime to prepare/initialize before running benchmark set_code.

fn verify_set_code()

Adds ability to the Runtime to do custom validation after benchmark.

impl Config for Runtime

type RuntimeHoldReason = RuntimeHoldReason

The overarching hold reason.

type RuntimeFreezeReason = RuntimeFreezeReason

The overarching freeze reason.

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

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

The ID type for freezes.

type MaxFreezes = VariantCountOf<RuntimeFreezeReason>

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

type DoneSlashHandler = ()

Allows callbacks to other pallets so they can update their bookkeeping when a slash occurs.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type PauseOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The only origin that can pause calls.

type UnpauseOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The only origin that can un-pause calls.

type WhitelistedCalls = TxPauseWhitelistedCalls

Contains all calls that cannot be paused.

type MaxNameLen = ConstU32<256>

Maximum length for pallet name and call name SCALE encoded string names.

type WeightInfo = SubstrateWeight<Runtime>

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type AdminOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The admin origin that can set computational limits and initialize the pallet.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for this pallet.

impl Config for Runtime

type WeightInfo = ()

Weight information for extrinsics in this pallet.

type RuntimeEvent = RuntimeEvent

The runtime event type.

type Members = Pallet<Runtime>

The current membership of the fellowship.

type Balance = u128

The type in which salaries/budgets are measured.

type ParamsOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin which has permission update the parameters.

type InductOrigin = EnsureInducted<Runtime, (), 1>

The origin which has permission to move a candidate into being tracked in this pallet. Generally a very low-permission, such as a pre-existing member of rank 1 or above.

type ApproveOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU16<9>>

The origin which has permission to issue a proof that a member may retain their rank. The Success value is the maximum rank of members it is able to prove.

type PromoteOrigin = EnsureRootWithSuccess<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ConstU16<9>>

The origin which has permission to promote a member. The Success value is the maximum rank to which it can promote.

type FastPromoteOrigin = <Runtime as Config>::PromoteOrigin

The origin that has permission to “fast” promote a member by ignoring promotion periods and skipping ranks. The Success value is the maximum rank to which it can promote.

type EvidenceSize = ConstU32<16384>

The maximum size in bytes submitted evidence is allowed to be.

type MaxRank = ConstU32<9>

Represents the highest possible rank in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type CollectionId = u32

Identifier for the collection of item.

type ItemId = u32

The type used to identify a unique item within a collection.

type Currency = Pallet<Runtime>

The currency mechanism, used for paying for reserves.

type ForceOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

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

type CollectionDeposit = CollectionDeposit

The basic amount of funds that must be reserved for collection.

type ItemDeposit = ItemDeposit

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

type MetadataDepositBase = MetadataDepositBase

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

type AttributeDepositBase = MetadataDepositBase

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

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 = ConstU32<128>

The maximum length of data stored on-chain.

type KeyLimit = ConstU32<32>

The maximum length of an attribute key.

type ValueLimit = ConstU32<64>

The maximum length of an attribute value.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type Helper = ()

A set of helper functions for benchmarking.

type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Standard collection creation is only allowed if the origin attempting it and the collection are in this set.

type Locker = ()

Locker trait to enable Locking mechanism downstream.

impl Config for Runtime

type PalletId = TreasuryPalletId

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

type Currency = Pallet<Runtime>

The staking balance.

type RejectOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

Origin from which rejections must come.

type RuntimeEvent = RuntimeEvent

The overarching event type.

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

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.

type SpendOrigin = EnsureWithSuccess<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, MaxBalance>

The origin required for approving spends from the treasury outside of the proposal process. The Success value is the maximum amount in a native asset that this origin is allowed to spend at a time.

type AssetKind = u32

Type parameter representing the asset kinds to be spent from the treasury.

type Beneficiary = <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId

Type parameter used to identify the beneficiaries eligible to receive treasury spends.

type BeneficiaryLookup = Pallet<Runtime>

Converting trait to take a source type and convert to Self::Beneficiary.

type Paymaster = PayAssetFromAccount<Pallet<Runtime, Instance1>, TreasuryAccount>

Type for processing spends of Self::AssetKind in favor of Self::Beneficiary.

type BalanceConverter = Pallet<Runtime>

Type for converting the balance of an Self::AssetKind to the balance of the native asset, solely for the purpose of asserting the result against the maximum allowed spend amount of the Self::SpendOrigin.

type PayoutPeriod = SpendPayoutPeriod

The period during which an approved treasury spend has to be claimed.

type BenchmarkHelper = ()

Helper type for benchmarks.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type Currency = Pallet<Runtime>

Currency used to pay for Coretime.

type OnRevenue = IntoAuthor

What to do with any revenues collected from the sale of Coretime.

type TimeslicePeriod = ConstU32<2>

Number of Relay-chain blocks per timeslice.

type MaxLeasedCores = ConstU32<5>

Maximum number of legacy leases.

type MaxReservedCores = ConstU32<5>

Maximum number of system cores.

type Coretime = CoretimeProvider

Relay chain’s Coretime API used to interact with and instruct the low-level scheduling system.

type ConvertBalance = Identity

Reversible conversion from local balance to Relay-chain balance. This will typically be the Identity, but provided just in case the chains use different representations.

type WeightInfo = ()

Weight information for all calls of this pallet.

type PalletId = BrokerPalletId

Identifier from which the internal Pot is generated.

type AdminOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin test needed for administrating this pallet.

type SovereignAccountOf = SovereignAccountOf

Type used for getting the associated account of a task. This account is controlled by the task itself.

type MaxAutoRenewals = ConstU32<10>

type PriceAdapter = CenterTargetPrice<u128>

The algorithm to determine the next price on the basis of market performance.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type CollectionId = u32

Identifier for the collection of item.

type ItemId = u32

The type used to identify a unique item within a collection.

type Currency = Pallet<Runtime>

The currency mechanism, used for paying for reserves.

type ForceOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

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

type CollectionDeposit = CollectionDeposit

The basic amount of funds that must be reserved for collection.

type ItemDeposit = ItemDeposit

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

type MetadataDepositBase = MetadataDepositBase

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

type AttributeDepositBase = MetadataDepositBase

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

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 = ConstU32<256>

The maximum length of data stored on-chain.

type KeyLimit = ConstU32<64>

The maximum length of an attribute key.

type ValueLimit = ConstU32<256>

The maximum length of an attribute value.

type ApprovalsLimit = ApprovalsLimit

The maximum approvals an item could have.

type ItemAttributesApprovalsLimit = ItemAttributesApprovalsLimit

The maximum attributes approvals an item could have.

type MaxTips = MaxTips

The max number of tips a user could send.

type MaxDeadlineDuration = MaxDeadlineDuration

The max duration in blocks for deadlines.

type MaxAttributesPerCall = MaxAttributesPerCall

The max number of attributes a user could set per call.

type Features = Features

Disables some of pallet’s features.

type OffchainSignature = MultiSignature

Off-Chain signature type.

type OffchainPublic = <MultiSignature as Verify>::Signer

Off-Chain public key.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type Helper = ()

A set of helper functions for benchmarking.

type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Standard collection creation is only allowed if the origin attempting it and the collection are in this set.

type Locker = ()

Locker trait to enable Locking mechanism downstream.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type Currency = Pallet<Runtime>

The currency mechanism.

type ProxyType = ProxyType

A kind of proxy; specified with the proxy and passed in to the IsProxyable filter. 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 = ConstU32<32>

The maximum amount of proxies allowed for a single account.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxPending = ConstU32<32>

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

Weight information for extrinsics in this pallet.

type RuntimeEvent = RuntimeEvent

The runtime event type.

type Paymaster = PayFromAccount<Pallet<Runtime>, TreasuryAccount>

Means by which we can make payments to accounts. This also defines the currency and the balance which we use to denote that currency.

type Members = Pallet<Runtime>

The current membership of payees.

type Salary = SalaryForRank

The maximum payout to be made for a single period to an active member of the given rank.

type RegistrationPeriod = ConstU32<200>

The number of blocks within a cycle which accounts have to register their intent to claim.

type PayoutPeriod = ConstU32<200>

The number of blocks within a cycle which accounts have to claim the payout.

type Budget = Budget

The total budget per cycle.

impl Config for Runtime

type Time = Pallet<Runtime>

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

type Currency = Pallet<Runtime>

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

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type CallFilter = Nothing

Filter that is applied to calls dispatched by contracts.

type DepositPerItem = DepositPerItem

The amount of balance a caller has to pay for each storage item.

type DepositPerByte = DepositPerByte

The amount of balance a caller has to pay for each byte of storage.

type WeightPrice = Pallet<Runtime>

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

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 AddressMapper = AccountId32Mapper<Runtime>

Use either valid type is address::AccountId32Mapper or [address::H160Mapper].

type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>

The amount of memory in bytes that parachain nodes a lot to the runtime.

type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>

The amount of memory in bytes that relay chain validators a lot to the PoV.

type UnsafeUnstableInterface = ConstBool<false>

Make contract callable functions marked as #[unstable] available.

type UploadOrigin = EnsureSigned<<Runtime as Config>::AccountId>

Origin allowed to upload code.

type InstantiateOrigin = EnsureSigned<<Runtime as Config>::AccountId>

Origin allowed to instantiate code.

type RuntimeHoldReason = RuntimeHoldReason

Overarching hold reason.

type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent

The percentage of the storage deposit that should be held for using a code hash. Instantiating a contract, or calling chain_extension::Ext::lock_delegate_dependency protects the code from being removed. In order to prevent abuse these actions are protected with a percentage of the code deposit.

type Debug = ()

For most production chains, it’s recommended to use the () implementation of this trait. This implementation offers additional logging when the log target “runtime::revive” is set to trace.

type Xcm = ()

A type that exposes XCM APIs, allowing contracts to interact with other parachains, and execute XCM programs.

type ChainId = ConstU64<420420420>

The EIP-155 chain ID.

impl Config for Runtime

type ExternalOrigin = EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>

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

type ExternalMajorityOrigin = EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 3, 4>

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

type ExternalDefaultOrigin = EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 1>

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

type FastTrackOrigin = EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 2, 3>

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

type RuntimeEvent = RuntimeEvent

type Currency = Pallet<Runtime>

Currency type for this pallet.

type EnactmentPeriod = EnactmentPeriod

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 VoteLockingPeriod = EnactmentPeriod

The minimum period of vote locking.

type MinimumDeposit = MinimumDeposit

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

type SubmitOrigin = EnsureSigned<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which the new proposal can be made.

type InstantOrigin = EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 1>

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 = ConstBool<true>

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<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 2, 3>

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

type CancelProposalOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 1>>

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

type BlacklistOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which proposals may be blacklisted.

type VetoOrigin = EnsureMember<<<MultiSignature as Verify>::Signer as IdentifyAccount>::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 Slash = Pallet<Runtime>

Handler for the unbalanced reduction when slashing a preimage deposit.

type Scheduler = Pallet<Runtime>

The Scheduler.

type PalletsOrigin = OriginCaller

Overarching type of all pallets origins.

type MaxVotes = ConstU32<100>

The maximum number of votes for an account.

type WeightInfo = SubstrateWeight<Runtime>

type MaxProposals = MaxProposals

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

type Preimages = Pallet<Runtime>

The Preimage provider.

type MaxDeposits = ConstU32<100>

The maximum number of deposits a public proposal may have at any time.

type MaxBlacklisted = ConstU32<100>

The maximum number of items which can be blacklisted.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The event type of this module.

type WeightInfo = ()

Weights for this pallet.

type MaxAuthorities = MaxAuthorities

Max Authorities in use

type MaxNominators = MaxNominators

The maximum number of nominators for each validator.

type MaxSetIdSessionEntries = MaxSetIdSessionEntries

The maximum number of entries to keep in the set id to session index mapping.

type KeyOwnerProof = MembershipProof

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

type EquivocationReportSystem = EquivocationReportSystem<Runtime, Pallet<Runtime>, Pallet<Runtime>, ReportLongevity>

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

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

Information on runtime weights.

type RuntimeEvent = RuntimeEvent

Overarching event type.

type Currency = Pallet<Runtime>

Currency type that this works on.

type CurrencyBalance = u128

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

type FundOrigin = EnsureSigned<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin required for auto-funding the deficit.

type Counterpart = ItemOf<Pallet<Runtime, Instance1>, ConstU32<9>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The accounting system for the fungible counterpart tokens.

type CounterpartAmount = WithMaximumOf<ConstU128<21000000000000000000>>

The system to convert an overall proportion of issuance into a number of fungible counterpart tokens.

type Deficit = ()

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

type IgnoredIssuance = ()

The issuance to ignore. This is subtracted from the Currency’s total_issuance to get the issuance with which we determine the thawed value of a given proportion.

type Target = Target

The target sum of all receipts’ proportions.

type PalletId = NisPalletId

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

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 BasePeriod = NisBasePeriod

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

type MinBid = MinBid

The minimum amount of funds that may be placed in a bid. Note that this does not actually limit the amount which may be represented in a receipt since bids may be split up by the system.

type MinReceipt = MinReceipt

The minimum amount of funds which may intentionally be left remaining under a single receipt.

type IntakePeriod = IntakePeriod

The number of blocks between consecutive attempts to dequeue bids and create receipts.

type MaxIntakeWeight = MaxIntakeWeight

The maximum amount of bids that can consolidated into receipts in a single intake. A larger value here means less of the block available for transactions should there be a glut of bids.

type ThawThrottle = ThawThrottle

The maximum proportion which may be thawed and the period over which it is reset.

type RuntimeHoldReason = RuntimeHoldReason

Overarching hold reason.

type BenchmarkSetup = SetupAsset

Setup the state for benchmarking.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

The currency trait.

type BasicDeposit = BasicDeposit

The amount held on deposit for a registered identity.

type ByteDeposit = ByteDeposit

The amount held on deposit per encoded byte for a registered identity.

type UsernameDeposit = UsernameDeposit

The amount held on deposit per registered username. This value should change only in runtime upgrades with proper migration of existing deposits.

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 IdentityInformation = IdentityInfo<MaxAdditionalFields>

Structure holding information about an identity.

type MaxRegistrars = MaxRegistrars

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

type Slashed = Pallet<Runtime>

What to do with slashed funds.

type ForceOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

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

type RegistrarOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionMoreThan<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>>

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

type OffchainSignature = MultiSignature

Signature type for pre-authorizing usernames off-chain.

type SigningPublicKey = <MultiSignature as Verify>::Signer

Public key that corresponds to an on-chain Self::AccountId.

type UsernameAuthorityOrigin = EnsureRoot<<Runtime as Config>::AccountId>

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

type PendingUsernameExpiration = ConstU32<{ 7 * DAYS }>

The number of blocks within which a username grant must be accepted.

type UsernameGracePeriod = ConstU32<{ 30 * DAYS }>

The number of blocks that must pass to enable the permanent deletion of a username by its respective authority.

type MaxSuffixLength = ConstU32<7>

The maximum length of a suffix.

type MaxUsernameLength = ConstU32<32>

The maximum length of a username, including its suffix and any system-added delimiters.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type FullIdentification = Exposure<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128>

Full identification of the validator.

type FullIdentificationOf = ExposureOf<Runtime>

A conversion from validator ID to full identification.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RuntimeCall = RuntimeCall

The overarching call type.

type Currency = Pallet<Runtime>

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

The overarching event type of the runtime.

type Migrations = MockedMigrations

Mocked migrations for benchmarking only.

type CursorMaxLen = ConstU32<65536>

The maximal length of an encoded cursor.

type IdentifierMaxLen = ConstU32<256>

The maximal length of an encoded identifier.

type MigrationStatusHandler = ()

Notifications for status updates of a runtime upgrade.

type FailedMigrationHandler = FreezeChainOnFailedMigration

Handler for failed migrations.

type MaxServiceWeight = MbmServiceWeight

The maximum weight to spend each block to execute migrations.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for the calls and functions of this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

The currency which is used to calculate account limits.

type StatementCost = StatementCost

Min balance for priority statements.

type ByteCost = StatementByteCost

Cost of data byte used for priority calculation.

type MinAllowedStatements = MinAllowedStatements

Minimum number of statements allowed per account.

type MaxAllowedStatements = MaxAllowedStatements

Maximum number of statements allowed per account.

type MinAllowedBytes = MinAllowedBytes

Minimum data bytes allowed per account.

type MaxAllowedBytes = MaxAllowedBytes

Maximum data bytes allowed per account.

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

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

Helper for weights computations

type MaxAuthorities = MaxAuthorities

Max number of authorities allowed

type MaxNominators = MaxNominators

The maximum number of nominators for each validator.

type KeyOwnerProof = MembershipProof

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 = EquivocationReportSystem<Runtime, Pallet<Runtime>, Pallet<Runtime>, ReportLongevity>

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

impl Config for Runtime

type PalletId = LotteryPalletId

The Lottery’s pallet id

type RuntimeCall = RuntimeCall

A dispatchable call.

type Currency = Pallet<Runtime>

The currency trait.

type Randomness = Pallet<Runtime>

Something that provides randomness in the runtime.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type ManagerOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The manager origin.

type MaxCalls = MaxCalls

The max number of calls available in a single lottery.

type ValidateCall = Pallet<Runtime>

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

Weight information for extrinsics in this pallet.

type RuntimeEvent = RuntimeEvent

type Currency = Pallet<Runtime>

Currency type with which voting happens.

type VoteLockingPeriod = VoteLockingPeriod

The minimum period of vote locking.

type MaxVotes = ConstU32<512>

The maximum number of concurrent votes an account may have.

type MaxTurnout = TotalIssuanceOf<Pallet<Runtime>, <Runtime as Config>::AccountId>

The maximum amount of tokens which may be used for voting. May just be Currency::total_issuance, but you might want to reduce this in order to account for funds in the system which are unable to vote (e.g. parachain auction deposits).

type Polls = Pallet<Runtime>

The implementation of the logic which conducts polls.

impl Config for Runtime

type RuntimeTask = RuntimeTask

type WeightInfo = SubstrateWeight<Runtime>

impl Config for Runtime

type AuthorityId = Public

The identifier type for an authority.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type NextSessionRotation = Pallet<Runtime>

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

type ValidatorSet = Pallet<Runtime>

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

type ReportUnresponsiveness = Pallet<Runtime>

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.

type MaxKeys = MaxKeys

The maximum number of keys that can be added.

type MaxPeerInHeartbeats = MaxPeerInHeartbeats

The maximum number of peers to be stored in ReceivedHeartbeats

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type MaxActiveChildBountyCount = ConstU32<5>

Maximum number of child bounties that can be added to a parent bounty.

type ChildBountyValueMinimum = ChildBountyValueMinimum

Minimum value for a child-bounty.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type LeafVersion = LeafVersion

Current leaf version.

type BeefyAuthorityToMerkleLeaf = BeefyEcdsaToEthereum

Convert BEEFY AuthorityId to a form that would end up in the Merkle Tree.

type LeafExtra = Vec<u8>

The type expected for the leaf extra data

type BeefyDataProvider = ()

Retrieve arbitrary data that should be added to the mmr leaf

type WeightInfo = ()

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type PalletsOrigin = OriginCaller

The caller origin, overarching type of all pallets origins.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

The Weight information for this pallet.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

Currency type for this pallet.

type ManagerOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

An origin that can request a preimage be placed on-chain without a deposit or fee, or manage existing preimages.

type Consideration = HoldConsideration<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Pallet<Runtime>, PreimageHoldReason, LinearStoragePrice<BaseDeposit, ByteDeposit, u128>>

A means of providing some cost while data is stored on-chain.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

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

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 non-zero amount held on deposit for placing a tip report.

type MaxTipAmount = ConstU128<{ 500 * DOLLARS }>

The maximum amount for a single tip.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type OnSlash = Pallet<Runtime>

Handler for the unbalanced decrease when slashing for a removed tip.

impl Config for Runtime

type BeefyId = Public

Authority identifier type

type MaxAuthorities = MaxAuthorities

The maximum number of authorities that can be added.

type MaxNominators = ConstU32<0>

The maximum number of nominators for each validator.

type MaxSetIdSessionEntries = BeefySetIdSessionEntries

The maximum number of entries to keep in the set id to session index mapping.

type OnNewValidatorSet = Pallet<Runtime>

A hook to act on the new BEEFY validator set.

type AncestryHelper = Pallet<Runtime>

Hook for checking commitment canonicity.

type WeightInfo = ()

Weights for this pallet.

type KeyOwnerProof = MembershipProof

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 = EquivocationReportSystem<Runtime, Pallet<Runtime>, Pallet<Runtime>, ReportLongevity>

The equivocation handling subsystem.

impl Config for Runtime

const INDEXING_PREFIX: &'static [u8] = b"mmr"

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

type Hashing = Keccak256

A hasher type for MMR.

type LeafData = ParentNumberAndHash<Runtime>

Data stored in the leaf nodes.

type OnNewRoot = DepositBeefyDigest<Runtime>

A hook to act on the new MMR root.

type BlockHashProvider = DefaultBlockHashProvider<Runtime>

Block hash provider for a given block number.

type WeightInfo = ()

Weights for this pallet.

type BenchmarkHelper = ()

Benchmarking setup helper trait.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeOrigin = RuntimeOrigin

The aggregated origin which the dispatch will take.

type PalletsOrigin = OriginCaller

The caller origin, overarching type of all pallets origins.

type RuntimeCall = RuntimeCall

The aggregated call type.

type MaximumWeight = MaximumSchedulerWeight

The maximum weight that may be scheduled per block for any dispatchables.

type ScheduleOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Required origin to schedule or cancel calls.

type MaxScheduledPerBlock = ConstU32<512>

The maximum number of scheduled calls in the queue for a single block.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type OriginPrivilegeCmp = EqualPrivilegeOnly

Compare the privileges of origins.

type Preimages = Pallet<Runtime>

The preimage provider with which we look up call hashes to get the call.

impl Config for Runtime

type FindAuthor = FindAccountFromAuthorIndex<Runtime, Pallet<Runtime>>

Find the author of a block.

type EventHandler = (Pallet<Runtime>, Pallet<Runtime>)

An event handler for authored blocks.

impl Config for Runtime

type WeightInfo = ()

Weight information for extrinsics in this pallet.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

The currency type used for nomination pool.

type RuntimeFreezeReason = RuntimeFreezeReason

The overarching freeze reason.

type RewardCounter = FixedU128

The type that is used for reward counter.

type BalanceToU256 = BalanceToU256

Infallible method for converting Currency::Balance to U256.

type U256ToBalance = U256ToBalance

Infallible method for converting U256 to Currency::Balance.

type StakeAdapter = TransferStake<Runtime, Pallet<Runtime>>

The interface for nominating.

type PostUnbondingPoolsWindow = PostUnbondPoolsWindow

The amount of eras a SubPools::with_era pool can exist before it gets merged into the SubPools::no_era pool. In other words, this is the amount of eras a member will be able to withdraw from an unbonding pool which is guaranteed to have the correct ratio of points to balance; once the with_era pool is merged into the no_era pool, the ratio can become skewed due to some slashed ratio getting merged in at some point.

type MaxMetadataLen = ConstU32<256>

The maximum length, in bytes, that a pools metadata maybe.

type MaxUnbonding = ConstU32<8>

The maximum number of simultaneous unbonding chunks that can exist per member.

type PalletId = NominationPoolsPalletId

The nomination pool’s pallet id.

type MaxPointsToBalance = MaxPointsToBalance

The maximum pool points-to-balance ratio that an open pool can have.

type AdminOrigin = EitherOfDiverse<EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 3, 4>>

The origin that can manage pool configurations.

impl Config for Runtime

type CreateOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin permissioned to create a conversion rate for an asset.

type RemoveOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin permissioned to remove an existing conversion rate for an asset.

type UpdateOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin permissioned to update an existing conversion rate for an asset.

type Currency = Pallet<Runtime>

The currency mechanism for this pallet.

type AssetKind = u32

The type for asset kinds for which the conversion rate to native balance is set.

type RuntimeEvent = RuntimeEvent

The runtime event type.

type WeightInfo = SubstrateWeight<Runtime>

The Weight information for extrinsics in this pallet.

type BenchmarkHelper = ()

Helper type for benchmarks.

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RuntimeEvent = RuntimeEvent

The overarching event type.

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RuntimeCall = RuntimeCall

type RuntimeEvent = RuntimeEvent

type Scheduler = Pallet<Runtime>

The Scheduler.

type Currency = Pallet<Runtime>

Currency type for this pallet.

type SubmitOrigin = EnsureSigned<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which proposals may be submitted.

type CancelOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which any vote may be cancelled.

type KillOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which any vote may be killed.

type Slash = ()

Handler for the unbalanced reduction when slashing a preimage deposit.

type Votes = <<Runtime as Config>::Currency as Currency<<Runtime as Config>::AccountId>>::Balance

The counting type for votes. Usually just balance.

type Tally = Tally<<<Runtime as Config>::Currency as Currency<<Runtime as Config>::AccountId>>::Balance, <Runtime as Config>::MaxTurnout>

The tallying type.

type SubmissionDeposit = SubmissionDeposit

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

type MaxQueued = ConstU32<100>

Maximum size of the referendum queue for a single track.

type UndecidingTimeout = UndecidingTimeout

The number of blocks after submission that a referendum must begin being decided by. Once this passes, then anyone may cancel the referendum.

type AlarmInterval = AlarmInterval

Quantization level for the referendum wakeup scheduler. A higher number will result in fewer storage reads/writes needed for smaller voters, but also result in delays to the automatic referendum status changes. Explicit servicing instructions are unaffected.

type Tracks = TracksInfo

Information concerning the different referendum tracks.

type Preimages = Pallet<Runtime>

The preimage provider.

impl Config for Runtime

type Signature = MultiSignature

Signature type that the extension of this pallet can verify.

type AccountIdentifier = MultiSigner

The account identifier used by this pallet’s signature type.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type BenchmarkHelper = VerifySignatureBenchmarkHelper

Helper to create a signature to be benchmarked.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type PalletId = ElectionsPhragmenPalletId

Identifier for the elections-phragmen pallet’s lock

type Currency = Pallet<Runtime>

The currency that people are electing with.

type ChangeMembers = Pallet<Runtime, Instance1>

What to do when the members change.

type InitializeMembers = Pallet<Runtime, Instance1>

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

The maximum number of voters to allow in a phragmen election.

type MaxVotesPerVoter = MaxVotesPerVoter

Maximum numbers of votes per voter.

type MaxCandidates = MaxCandidates

The maximum number of candidates in a phragmen election.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Deposit = AssetDeposit

The deposit paid by the user locking an NFT. The deposit is returned to the original NFT owner when the asset is unified and the NFT is unlocked.

type Currency = Pallet<Runtime>

The currency mechanism, used for paying for deposits.

type NewAssetSymbol = NewAssetSymbol

The newly created asset’s symbol.

type NewAssetName = NewAssetName

The newly created asset’s name.

type StringLimit = StringLimit

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

type NftCollectionId = <Runtime as Config>::CollectionId

Identifier for the collection of NFT.

type NftId = <Runtime as Config>::ItemId

The type used to identify an NFT within a collection.

type AssetBalance = <Runtime as Config>::Balance

The type used to describe the amount of fractions converted into assets.

type AssetId = <Runtime as Config<Instance1>>::AssetId

The type used to identify the assets created during fractionalization.

type Assets = Pallet<Runtime, Instance1>

Registry for the minted assets.

type Nfts = Pallet<Runtime>

Registry for minted NFTs.

type PalletId = NftFractionalizationPalletId

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

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type RuntimeHoldReason = RuntimeHoldReason

Overarching hold reason.

type BenchmarkHelper = ()

A set of helper functions for benchmarking.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

A sudo-able call.

type WeightInfo = SubstrateWeight<Runtime>

Type representing the weight of this pallet

impl Config for Runtime

type Moment = u64

Type used for expressing a timestamp.

type OnTimestampSet = Pallet<Runtime>

Something which can be notified (e.g. another pallet) when the timestamp is set.

type MinimumPeriod = MinimumPeriod

The minimum period between blocks.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl ContractsApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128, u32, H256, EventRecord<<Runtime as Config>::RuntimeEvent, <Runtime as Config>::Hash>> for Runtime

fn call( origin: AccountId, dest: AccountId, value: Balance, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, input_data: Vec<u8>, ) -> ContractExecResult<Balance, EventRecord<<Runtime as Config>::RuntimeEvent, <Runtime as Config>::Hash>>

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

fn instantiate( origin: AccountId, value: Balance, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, code: Code<Hash>, data: Vec<u8>, salt: Vec<u8>, ) -> ContractInstantiateResult<AccountId, Balance, EventRecord<<Runtime as Config>::RuntimeEvent, <Runtime as Config>::Hash>>

Instantiate a new contract.

fn upload_code( origin: AccountId, code: Vec<u8>, storage_deposit_limit: Option<Balance>, determinism: Determinism, ) -> CodeUploadResult<Hash, Balance>

Upload new code without instantiating a contract from it.

fn get_storage(address: AccountId, key: Vec<u8>) -> GetStorageResult

Query a given storage key in a given contract.

impl CoreV5<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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, ) -> ExtrinsicInclusionMode

Initialize a block with the given header and return the runtime executive mode.

impl<LocalCall> CreateInherent<LocalCall> for Runtime

where RuntimeCall: From<LocalCall>,

fn create_inherent(call: RuntimeCall) -> UncheckedExtrinsic

Create an inherent.

impl<LocalCall> CreateSignedTransaction<LocalCall> for Runtime

where RuntimeCall: From<LocalCall>,

fn create_signed_transaction<C: AppCrypto<Self::Public, Self::Signature>>( call: RuntimeCall, public: <Signature as Verify>::Signer, account: AccountId, nonce: Nonce, ) -> Option<UncheckedExtrinsic>

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

impl<LocalCall> CreateTransaction<LocalCall> for Runtime

where RuntimeCall: From<LocalCall>,

type Extension = (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, SkipCheckIfFeeless<Runtime, ChargeAssetTxPayment<Runtime>>, CheckMetadataHash<Runtime>)

The extension.

fn create_transaction( call: RuntimeCall, extension: TxExtension, ) -> UncheckedExtrinsic

Create a transaction using the call and the desired transaction extension.

impl<C> CreateTransactionBase<C> for Runtime

where RuntimeCall: From<C>,

type Extrinsic = UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>

The extrinsic.

type RuntimeCall = RuntimeCall

The runtime’s call type.

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, u32>

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

impl GenesisBuilderV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

fn build_state(config: Vec<u8>) -> Result

Build RuntimeGenesisConfig from a JSON blob not using any defaults and store it in the storage.

fn get_preset(id: &Option<PresetId>) -> Option<Vec<u8>>

Returns a JSON blob representation of the built-in RuntimeGenesisConfig identified by id.

fn preset_names() -> Vec<PresetId>

Returns a list of identifiers for available builtin RuntimeGenesisConfig presets.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = <Runtime as Config>::Block

The RuntimeBlock type.

impl GrandpaApiV3<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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: 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 IsInherent<<<Runtime as Config>::Block as Block>::Extrinsic> for Runtime

fn is_inherent(ext: &<<Runtime as Config>::Block as Block>::Extrinsic) -> bool

Whether this extrinsic is an inherent.

impl MetadataV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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 MinerConfig for Runtime

type AccountId = <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId

The account id type.

type MaxLength = MinerMaxLength

Maximum length of the solution that the miner is allowed to generate.

type MaxWeight = MinerMaxWeight

Maximum weight of the solution that the miner is allowed to generate.

type Solution = NposSolution16

The solution that the miner is mining.

type MaxVotesPerVoter = <<Runtime as Config>::DataProvider as ElectionDataProvider>::MaxVotesPerVoter

Maximum number of votes per voter in the snapshots.

type MaxWinners = MaxActiveValidators

The maximum number of winners that can be elected.

fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight

Something that can compute the weight of a solution.

impl MixnetApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

fn session_status() -> SessionStatus

Get the index and phase of the current session.

fn prev_mixnodes() -> Result<Vec<Mixnode>, MixnodesErr>

Get the mixnode set for the previous session.

fn current_mixnodes() -> Result<Vec<Mixnode>, MixnodesErr>

Get the mixnode set for the current session.

fn maybe_register(session_index: SessionIndex, mixnode: Mixnode) -> bool

Try to register a mixnode for the next session.

impl MmrApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, <<Runtime as Config>::Hashing as Hash>::Output, u32> for Runtime

fn mmr_root() -> Result<<<Runtime as Config>::Hashing as Hash>::Output, Error>

Return the on-chain MMR root hash.

fn mmr_leaf_count() -> Result<LeafIndex, Error>

Return the number of MMR blocks in the chain.

fn generate_proof( block_numbers: Vec<BlockNumber>, best_known_block_number: Option<BlockNumber>, ) -> Result<(Vec<EncodableOpaqueLeaf>, LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>), Error>

Generate MMR proof for a series of block numbers. If best_known_block_number = Some(n), use historical MMR state at given block height n. Else, use current MMR state.

fn verify_proof( leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>, ) -> Result<(), Error>

Verify MMR proof against on-chain MMR for a batch of leaves.

fn verify_proof_stateless( root: <<Runtime as Config>::Hashing as Hash>::Output, leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>, ) -> Result<(), Error>

Verify MMR proof against given root hash for a batch of leaves.

impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> MmrApi<__SrApiBlock__, <<Runtime as Config>::Hashing as Hash>::Output, u32> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>

where RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>, &'static RuntimeApiImplCall: Send,

fn mmr_root( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Result<Hash, Error>, ApiError>

Return the on-chain MMR root hash.

fn mmr_leaf_count( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Result<u64, Error>, ApiError>

Return the number of MMR blocks in the chain.

fn generate_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, block_numbers: Vec<BlockNumber>, best_known_block_number: Option<BlockNumber>, ) -> Result<Result<(Vec<EncodableOpaqueLeaf>, LeafProof<Hash>), Error>, ApiError>

Generate MMR proof for a series of block numbers. If best_known_block_number = Some(n), use historical MMR state at given block height n. Else, use current MMR state.

fn verify_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<Hash>, ) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against on-chain MMR for a batch of leaves.

fn verify_proof_stateless( &self, __runtime_api_at_param__: <Block as Block>::Hash, root: Hash, leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<Hash>, ) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against given root hash for a batch of leaves.

impl NftsApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32, u32> for Runtime

fn owner(collection: u32, item: u32) -> Option<AccountId>

fn collection_owner(collection: u32) -> Option<AccountId>

fn attribute(collection: u32, item: u32, key: Vec<u8>) -> Option<Vec<u8>>

fn custom_attribute( account: AccountId, collection: u32, item: u32, key: Vec<u8>, ) -> Option<Vec<u8>>

fn system_attribute( collection: u32, item: Option<u32>, key: Vec<u8>, ) -> Option<Vec<u8>>

fn collection_attribute(collection: u32, key: Vec<u8>) -> Option<Vec<u8>>

impl NominationPoolsApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128> for Runtime

fn pending_rewards(who: AccountId) -> Balance

Returns the pending rewards for the member that the AccountId was given for.

fn points_to_balance(pool_id: PoolId, points: Balance) -> Balance

Returns the equivalent balance of points for a given pool.

fn balance_to_points(pool_id: PoolId, new_funds: Balance) -> Balance

Returns the equivalent points of new_funds for a given pool.

fn pool_pending_slash(pool_id: PoolId) -> Balance

Returns the pending slash for a given pool.

fn member_pending_slash(member: AccountId) -> Balance

Returns the pending slash for a given pool member.

fn pool_needs_delegate_migration(pool_id: PoolId) -> bool

Returns true if the pool with pool_id needs migration.

fn member_needs_delegate_migration(member: AccountId) -> bool

Returns true if the delegated funds of the pool member needs migration.

fn member_total_balance(member: AccountId) -> Balance

Returns the total contribution of a pool member including any balance that is unbonding.

fn pool_balance(pool_id: PoolId) -> Balance

Total balance contributed to the pool.

impl OffchainWorkerApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

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

Starts the off-chain task for given block header.

impl PartialEq 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 ReviveApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128, u32, u32, EventRecord<<Runtime as Config>::RuntimeEvent, <Runtime as Config>::Hash>> for Runtime

fn balance(address: H160) -> Balance

Returns the free balance of the given [H160] address.

fn nonce(address: H160) -> Nonce

Returns the nonce of the given [H160] address.

fn eth_transact( from: H160, dest: Option<H160>, value: Balance, input: Vec<u8>, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, ) -> EthContractResult<Balance>

Perform an Ethereum call.

fn call( origin: AccountId, dest: H160, value: Balance, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, input_data: Vec<u8>, ) -> ContractResult<ExecReturnValue, Balance, EventRecord<<Runtime as Config>::RuntimeEvent, <Runtime as Config>::Hash>>

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

fn instantiate( origin: AccountId, value: Balance, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, code: Code, data: Vec<u8>, salt: Option<[u8; 32]>, ) -> ContractResult<InstantiateReturnValue, Balance, EventRecord<<Runtime as Config>::RuntimeEvent, <Runtime as Config>::Hash>>

Instantiate a new contract.

fn upload_code( origin: AccountId, code: Vec<u8>, storage_deposit_limit: Option<Balance>, ) -> CodeUploadResult<Balance>

Upload new code without instantiating a contract from it.

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

Query a given storage key in a given contract.

impl SessionKeysV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> 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 = <MultiSignature as Verify>::Signer

A public key that is capable of identifying AccountIds.

type Signature = MultiSignature

A matching Signature type.

impl StakingApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, u128, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for Runtime

fn nominations_quota(balance: Balance) -> u32

Returns the nominations quota for a nominator with a given balance.

fn eras_stakers_page_count(era: EraIndex, account: AccountId) -> Page

Returns the page count of exposures for a validator account in a given era.

fn pending_rewards(era: EraIndex, account: AccountId) -> bool

Returns true if validator account has pages to be claimed for the given era.

impl TaggedTransactionQueueV3<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

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

Validate the transaction.

impl TransactionPaymentApiV4<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, 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>

fn query_weight_to_fee(weight: Weight) -> Balance

fn query_length_to_fee(length: u32) -> Balance

impl TransactionPaymentCallApiV3<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>, u128, RuntimeCall> for Runtime

fn query_call_info(call: RuntimeCall, len: u32) -> RuntimeDispatchInfo<Balance>

Query information of a dispatch class, weight, and fee of a given encoded Call.

fn query_call_fee_details(call: RuntimeCall, len: u32) -> FeeDetails<Balance>

Query fee details of a given encoded Call.

fn query_weight_to_fee(weight: Weight) -> Balance

Query the output of the current WeightToFee given some input.

fn query_length_to_fee(length: u32) -> Balance

Query the output of the current LengthToFee given some input.

impl TryRuntimeV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

fn on_runtime_upgrade(checks: UpgradeCheckSelect) -> (Weight, Weight)

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

fn execute_block( block: Block, state_root_check: bool, signature_check: bool, select: TryStateSelect, ) -> Weight

Execute the given block, but optionally disable state-root and signature checks.

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 ValidateStatementV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32>, MultiSignature, EthExtraImpl>>> for Runtime

fn validate_statement( source: StatementSource, statement: Statement, ) -> Result<ValidStatement, InvalidStatement>

Validate the statement.

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

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