Skip to main content

ElectionProviderMultiPhase

Calls​

governanceFallback​

Trigger the governance fallback.

This can only be called when [Phase::Emergency] is enabled, as an alternative to calling [Call::set_emergency_election_result].

Namespace​

api.tx.electionProviderMultiPhase.governanceFallback

Type​

function governanceFallback(
  maybe_max_voters: Option<u32>,
  maybe_max_targets: Option<u32>
)

setEmergencyElectionResult​

Set a solution in the queue, to be handed out to the client of this pallet in the next call to ElectionProvider::elect.

This can only be set by T::ForceOrigin, and only when the phase is Emergency.

The solution is not checked for any feasibility and is assumed to be trustworthy, as any feasibility check itself can in principle cause the election process to fail (due to memory/weight constrains).

Namespace​

api.tx.electionProviderMultiPhase.setEmergencyElectionResult

Type​

function setEmergencyElectionResult(
  supports: Vec<(SeedPrimitivesSignatureAccountId20,SpNposElectionsSupport)>
)

setMinimumUntrustedScore​

Set a new value for MinimumUntrustedScore.

Dispatch origin must be aligned with T::ForceOrigin.

This check can be turned off by setting the value to None.

Namespace​

api.tx.electionProviderMultiPhase.setMinimumUntrustedScore

Type​

function setMinimumUntrustedScore(
  maybe_next_score: Option<SpNposElectionsElectionScore>
)

submit​

Submit a solution for the signed phase.

The dispatch origin fo this call must be signed.

The solution is potentially queued, based on the claimed score and processed at the end of the signed phase.

A deposit is reserved and recorded for the solution. Based on the outcome, the solution might be rewarded, slashed, or get all or a part of the deposit back.

Namespace​

api.tx.electionProviderMultiPhase.submit

Type​

function submit(
  raw_solution: PalletElectionProviderMultiPhaseRawSolution
)

submitUnsigned​

Submit a solution for the unsigned phase.

The dispatch origin fo this call must be none.

This submission is checked on the fly. Moreover, this unsigned solution is only validated when submitted to the pool from the local node. Effectively, this means that only active validators can submit this transaction when authoring a block (similar to an inherent).

To prevent any incorrect solution (and thus wasted time/weight), this transaction will panic if the solution submitted by the validator is invalid in any way, effectively putting their authoring reward at risk.

No deposit or reward is associated with this submission.

Namespace​

api.tx.electionProviderMultiPhase.submitUnsigned

Type​

function submitUnsigned(
  raw_solution: PalletElectionProviderMultiPhaseRawSolution,
  witness: PalletElectionProviderMultiPhaseSolutionOrSnapshotSize
)

Storage​

currentPhase​

Current phase.

Namespace​

api.query.electionProviderMultiPhase.currentPhase

Type​

function currentPhase(

): PalletElectionProviderMultiPhasePhase

desiredTargets​

Desired number of targets to elect for this round.

Only exists when [Snapshot] is present.

Namespace​

api.query.electionProviderMultiPhase.desiredTargets

Type​

function desiredTargets(

): Option<u32>

minimumUntrustedScore​

The minimum score that each 'untrusted' solution must attain in order to be considered feasible.

Can be set via set_minimum_untrusted_score.

Namespace​

api.query.electionProviderMultiPhase.minimumUntrustedScore

Type​

function minimumUntrustedScore(

): Option<SpNposElectionsElectionScore>

queuedSolution​

Current best solution, signed or unsigned, queued to be returned upon elect.

Namespace​

api.query.electionProviderMultiPhase.queuedSolution

Type​

function queuedSolution(

): Option<PalletElectionProviderMultiPhaseReadySolution>

round​

Internal counter for the number of rounds.

This is useful for de-duplication of transactions submitted to the pool, and general diagnostics of the pallet.

This is merely incremented once per every time that an upstream elect is called.

Namespace​

api.query.electionProviderMultiPhase.round

Type​

function round(

): u32

signedSubmissionIndices​

A sorted, bounded set of (score, index), where each index points to a value in SignedSubmissions.

We never need to process more than a single signed submission at a time. Signed submissions can be quite large, so we're willing to pay the cost of multiple database accesses to access them one at a time instead of reading and decoding all of them at once.

Namespace​

api.query.electionProviderMultiPhase.signedSubmissionIndices

Type​

function signedSubmissionIndices(

): BTreeMap<SpNposElectionsElectionScore, u32>

signedSubmissionNextIndex​

The next index to be assigned to an incoming signed submission.

Every accepted submission is assigned a unique index; that index is bound to that particular submission for the duration of the election. On election finalization, the next index is reset to 0.

We can't just use SignedSubmissionIndices.len(), because that's a bounded set; past its capacity, it will simply saturate. We can't just iterate over SignedSubmissionsMap, because iteration is slow. Instead, we store the value here.

Namespace​

api.query.electionProviderMultiPhase.signedSubmissionNextIndex

Type​

function signedSubmissionNextIndex(

): u32

signedSubmissionsMap​

Unchecked, signed solutions.

Together with SubmissionIndices, this stores a bounded set of SignedSubmissions while allowing us to keep only a single one in memory at a time.

Twox note: the key of the map is an auto-incrementing index which users cannot inspect or affect; we shouldn't need a cryptographically secure hasher.

Namespace​

api.query.electionProviderMultiPhase.signedSubmissionsMap

Type​

function signedSubmissionsMap(
  u32
): Option<PalletElectionProviderMultiPhaseSignedSignedSubmission>

snapshot​

Snapshot data of the round.

This is created at the beginning of the signed phase and cleared upon calling elect.

Namespace​

api.query.electionProviderMultiPhase.snapshot

Type​

function snapshot(

): Option<PalletElectionProviderMultiPhaseRoundSnapshot>

snapshotMetadata​

The metadata of the [RoundSnapshot]

Only exists when [Snapshot] is present.

Namespace​

api.query.electionProviderMultiPhase.snapshotMetadata

Type​

function snapshotMetadata(

): Option<PalletElectionProviderMultiPhaseSolutionOrSnapshotSize>

Events​

ElectionFailed​

An election failed.

Not much can be said about which computes failed in the process.

Namespace​

api.events.electionProviderMultiPhase.ElectionFailed

Type​

type ElectionFailed = {

}

ElectionFinalized​

The election has been finalized, with the given computation and score.

Namespace​

api.events.electionProviderMultiPhase.ElectionFinalized

Type​

type ElectionFinalized = {
  compute: PalletElectionProviderMultiPhaseElectionCompute,
  score: SpNposElectionsElectionScore
}

Rewarded​

An account has been rewarded for their signed submission being finalized.

Namespace​

api.events.electionProviderMultiPhase.Rewarded

Type​

type Rewarded = {
  account: SeedPrimitivesSignatureAccountId20,
  value: u128
}

SignedPhaseStarted​

The signed phase of the given round has started.

Namespace​

api.events.electionProviderMultiPhase.SignedPhaseStarted

Type​

type SignedPhaseStarted = {
  round: u32
}

Slashed​

An account has been slashed for submitting an invalid signed submission.

Namespace​

api.events.electionProviderMultiPhase.Slashed

Type​

type Slashed = {
  account: SeedPrimitivesSignatureAccountId20,
  value: u128
}

SolutionStored​

A solution was stored with the given compute.

If the solution is signed, this means that it hasn't yet been processed. If the solution is unsigned, this means that it has also been processed.

The bool is true when a previous solution was ejected to make room for this one.

Namespace​

api.events.electionProviderMultiPhase.SolutionStored

Type​

type SolutionStored = {
  compute: PalletElectionProviderMultiPhaseElectionCompute,
  prev_ejected: bool
}

UnsignedPhaseStarted​

The unsigned phase of the given round has started.

Namespace​

api.events.electionProviderMultiPhase.UnsignedPhaseStarted

Type​

type UnsignedPhaseStarted = {
  round: u32
}

Errors​

CallNotAllowed​

The call is not allowed at this point.

Namespace​

api.errors.electionProviderMultiPhase.CallNotAllowed

FallbackFailed​

The fallback failed

Namespace​

api.errors.electionProviderMultiPhase.FallbackFailed

InvalidSubmissionIndex​

Self::insert_submission returned an invalid index.

Namespace​

api.errors.electionProviderMultiPhase.InvalidSubmissionIndex

MissingSnapshotMetadata​

Snapshot metadata should exist but didn't.

Namespace​

api.errors.electionProviderMultiPhase.MissingSnapshotMetadata

OcwCallWrongEra​

OCW submitted solution for wrong round

Namespace​

api.errors.electionProviderMultiPhase.OcwCallWrongEra

PreDispatchEarlySubmission​

Submission was too early.

Namespace​

api.errors.electionProviderMultiPhase.PreDispatchEarlySubmission

PreDispatchWeakSubmission​

Submission was too weak, score-wise.

Namespace​

api.errors.electionProviderMultiPhase.PreDispatchWeakSubmission

PreDispatchWrongWinnerCount​

Wrong number of winners presented.

Namespace​

api.errors.electionProviderMultiPhase.PreDispatchWrongWinnerCount

SignedCannotPayDeposit​

The origin failed to pay the deposit.

Namespace​

api.errors.electionProviderMultiPhase.SignedCannotPayDeposit

SignedInvalidWitness​

Witness data to dispatchable is invalid.

Namespace​

api.errors.electionProviderMultiPhase.SignedInvalidWitness

SignedQueueFull​

The queue was full, and the solution was not better than any of the existing ones.

Namespace​

api.errors.electionProviderMultiPhase.SignedQueueFull

SignedTooMuchWeight​

The signed submission consumes too much weight

Namespace​

api.errors.electionProviderMultiPhase.SignedTooMuchWeight

Constants​

betterSignedThreshold​

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

Namespace​

api.consts.electionProviderMultiPhase.betterSignedThreshold

Type​

type betterSignedThreshold = Perbill

betterUnsignedThreshold​

The minimum amount of improvement to the solution score that defines a solution as "better" in the Unsigned phase.

Namespace​

api.consts.electionProviderMultiPhase.betterUnsignedThreshold

Type​

type betterUnsignedThreshold = Perbill

maxElectableTargets​

The maximum number of electable targets to put in the snapshot.

Namespace​

api.consts.electionProviderMultiPhase.maxElectableTargets

Type​

type maxElectableTargets = u16

maxElectingVoters​

The maximum number of electing voters 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.

Namespace​

api.consts.electionProviderMultiPhase.maxElectingVoters

Type​

type maxElectingVoters = u32

minerMaxLength​

Namespace​

api.consts.electionProviderMultiPhase.minerMaxLength

Type​

type minerMaxLength = u32

minerMaxVotesPerVoter​

Namespace​

api.consts.electionProviderMultiPhase.minerMaxVotesPerVoter

Type​

type minerMaxVotesPerVoter = u32

minerMaxWeight​

Namespace​

api.consts.electionProviderMultiPhase.minerMaxWeight

Type​

type minerMaxWeight = WeightV1

minerTxPriority​

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

Namespace​

api.consts.electionProviderMultiPhase.minerTxPriority

Type​

type minerTxPriority = u64

offchainRepeat​

The repeat threshold of the offchain worker.

For example, if it is 5, that means that at least 5 blocks will elapse between attempts to submit the worker's solution.

Namespace​

api.consts.electionProviderMultiPhase.offchainRepeat

Type​

type offchainRepeat = u32

signedDepositBase​

Base deposit for a signed solution.

Namespace​

api.consts.electionProviderMultiPhase.signedDepositBase

Type​

type signedDepositBase = u128

signedDepositByte​

Per-byte deposit for a signed solution.

Namespace​

api.consts.electionProviderMultiPhase.signedDepositByte

Type​

type signedDepositByte = u128

signedDepositWeight​

Per-weight deposit for a signed solution.

Namespace​

api.consts.electionProviderMultiPhase.signedDepositWeight

Type​

type signedDepositWeight = u128

signedMaxRefunds​

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

Namespace​

api.consts.electionProviderMultiPhase.signedMaxRefunds

Type​

type signedMaxRefunds = u32

signedMaxSubmissions​

Maximum number of signed submissions that can be queued.

It is best to avoid adjusting this during an election, as it impacts downstream data structures. In particular, SignedSubmissionIndices<T> is bounded on this value. If you update this value during an election, you must ensure that SignedSubmissionIndices.len() is less than or equal to the new value. Otherwise, attempts to submit new solutions may cause a runtime panic.

Namespace​

api.consts.electionProviderMultiPhase.signedMaxSubmissions

Type​

type signedMaxSubmissions = u32

signedMaxWeight​

Maximum weight of a signed solution.

If [Config::MinerConfig] is being implemented to submit signed solutions (outside of this pallet), then [MinerConfig::solution_weight] is used to compare against this value.

Namespace​

api.consts.electionProviderMultiPhase.signedMaxWeight

Type​

type signedMaxWeight = WeightV1

signedPhase​

Duration of the signed phase.

Namespace​

api.consts.electionProviderMultiPhase.signedPhase

Type​

type signedPhase = u32

signedRewardBase​

Base reward for a signed solution

Namespace​

api.consts.electionProviderMultiPhase.signedRewardBase

Type​

type signedRewardBase = u128

unsignedPhase​

Duration of the unsigned phase.

Namespace​

api.consts.electionProviderMultiPhase.unsignedPhase

Type​

type unsignedPhase = u32