Struct pallet_election_provider_multi_phase::unsigned::Miner

pub struct Miner<T: MinerConfig>(_);

A base miner, suitable to be used for both signed and unsigned submissions.

Implementations

impl<T: MinerConfig> Miner<T>

pub fn mine_solution_with_snapshot<S>(
    voters: Vec<(T::AccountId, VoteWeight, BoundedVec<T::AccountId, T::MaxVotesPerVoter>)>,
    targets: Vec<T::AccountId>,
    desired_targets: u32
) -> Result<(SolutionOf<T>, ElectionScore, SolutionOrSnapshotSize), MinerError>where
    S: NposSolver<AccountId = T::AccountId>,

Same as Pallet::mine_solution, but the input snapshot data must be given.

pub fn prepare_election_result_with_snapshot<Accuracy: PerThing128>(
    election_result: ElectionResult<T::AccountId, Accuracy>,
    voters: Vec<(T::AccountId, VoteWeight, BoundedVec<T::AccountId, T::MaxVotesPerVoter>)>,
    targets: Vec<T::AccountId>,
    desired_targets: u32
) -> Result<(SolutionOf<T>, ElectionScore, SolutionOrSnapshotSize), MinerError>

Convert a raw solution from sp_npos_elections::ElectionResult to RawSolution, which is ready to be submitted to the chain.

Will always reduce the solution as well.

pub fn trim_assignments_length(
    max_allowed_length: u32,
    assignments: &mut Vec<IndexAssignmentOf<T>>,
    encoded_size_of: impl Fn(&[IndexAssignmentOf<T>]) -> Result<usize, Error>
) -> Result<(), MinerError>

Greedily reduce the size of the solution to fit into the block w.r.t length.

The length of the solution is largely a function of the number of voters. The number of winners cannot be changed. Thus, to reduce the solution size, we need to strip voters.

Note that this solution is already computed, and winners are elected based on the merit of the total stake in the system. Nevertheless, some of the voters may be removed here.

Sometimes, removing a voter can cause a validator to also be implicitly removed, if that voter was the only backer of that winner. In such cases, this solution is invalid, which will be caught prior to submission.

The score must be computed after this step. If this step reduces the score too much, then the solution must be discarded.

pub fn trim_assignments_weight(
    desired_targets: u32,
    size: SolutionOrSnapshotSize,
    max_weight: Weight,
    assignments: &mut Vec<IndexAssignmentOf<T>>
)

Greedily reduce the size of the solution to fit into the block w.r.t. weight.

The weight of the solution is foremost a function of the number of voters (i.e. assignments.len()). Aside from this, the other components of the weight are invariant. The number of winners shall not be changed (otherwise the solution is invalid) and the ElectionSize is merely a representation of the total number of stakers.

Thus, we reside to stripping away some voters from the assignments.

Note that the solution is already computed, and the winners are elected based on the merit of the entire stake in the system. Nonetheless, some of the voters will be removed further down the line.

Indeed, the score must be computed after this step. If this step reduces the score too much or remove a winner, then the solution must be discarded after this step.

pub fn maximum_voter_for_weight(
    desired_winners: u32,
    size: SolutionOrSnapshotSize,
    max_weight: Weight
) -> u32

Find the maximum len that a solution can have in order to fit into the block weight.

This only returns a value between zero and size.nominators.