> ## Documentation Index > Fetch the complete documentation index at: https://docs.therootnetwork.com/llms.txt > Use this file to discover all available pages before exploring further. # ElectionProviderMultiPhase ## constraintsCalls ### 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, maybe_max_targets: Option ) ``` ### 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 ) ``` ### submit Submit a solution for the signed phase. The dispatch origin for 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 for 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 ``` ### 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 ``` ### queuedSolution Current best solution, signed or unsigned, queued to be returned upon `elect`. **Namespace** ``` api.query.electionProviderMultiPhase.queuedSolution ``` **Type** ``` function queuedSolution( ): Option ``` ### 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 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 ``` ### signedSubmissionNextIndex The next index is 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 ``` ### 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 ``` ### snapshotMetadata The metadata of the \[`RoundSnapshot`] Only exists when \[`Snapshot`] is present. **Namespace** ``` api.query.electionProviderMultiPhase.snapshotMetadata ``` **Type** ``` function snapshotMetadata( ): Option ``` ## 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` 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 ```