Recursive ElectionProvider

[kianenigma]

Related to https://github.com/paritytech/srlabs_findings/issues/79 and https://github.com/paritytech/srlabs_findings/issues/65.

The fundamental change here is that instead of assuming a hardcoded:

enum Fallback {
  Nothing,
  OnChain,
} 

We leave this open: The type Fallback is merely another ElectionProvider that might be anything.

Also, we ensure that a fallback method uses the snapshot that is created in the multi-phase pallet. In the past, the DataProvider of Fallback was Staking, meaning that we would need to re-query all validators and nominators from chain-state one by one to trigger the on-chain election. Now, we implement ElectionDataProvider for multi_phase::Pallet<T>, meaning that multi_phase can itself be the data provider of the fallback.

This is beneficial if: The snapshot is created in multi_phase, but election fails. In this case, we use the snapshot and this is much more optimized in terms of storage operations.
This is tricky if: Everything gets fails in multi_phase, and no snapshot exists there. An example of this is if the snapshot creation fails. In these cases, multi_phase has no snapshot to give to the fallback, and the fallback cannot do anything.

We could code impl DataProvider for multi_phase::Pallet in such a way that first tries to return the data from its own snapshot, and if failure, fallback to its own T::DataProvider (staking).

[coriolinus]

Looks good, pending CI.

We could code impl DataProvider for multi_phase::Pallet in such a way that first tries to return the data from its own snapshot, and if failure, fallback to its own T::DataProvider (staking).

Future PR?

[coriolinus]

I find the size name a bit confusing. The implementation can also avoid allocating a new vector:

Suggested change

	fn maybe_trim<T>(items: Vec<T>, maybe_size: Option<usize>) -> Vec<T> {
	if let Some(size) = maybe_size {
	items.into_iter().take(size).collect::<Vec<T>>()
	} else {
	items
	}
	}
	fn maybe_trim<T>(mut items: Vec<T>, maybe_qty: Option<usize>) -> Vec<T> {
	items.truncate(maybe_qty.unwrap_or_else(|| items.len()));
	items
	}

[kianenigma]

I won't work on this PR immediately now, so putting it inprogress temporarily.